watir-webdriver 0.0.6 → 0.0.7

data/lib/watir-webdriver/container.rb

@@ -1,17 +1,6 @@
 # encoding: utf-8
 module Watir
   module Container
-    class << self
-
-      #
-      # @api private
-      #
-
-      def add(method, &blk)
-        define_method(method, &blk)
-      end
-    end
-
     include XpathSupport
 
     private
@@ -25,5 +14,22 @@ module Watir
       @browserbot_script ||= File.read("#{File.dirname(__FILE__)}/browserbot.js")
     end
 
+    def extract_selector(selectors)
+      case selectors.size
+      when 2
+        { selectors[0] => selectors[1] }
+      when 1
+        unless selectors.first.kind_of? Hash
+          raise ArgumentError, "expected Hash or (:how, 'what')"
+        end
+
+        selectors.first
+      when 0
+        {}
+      else
+        raise ArgumentError, selectors.inspect
+      end
+    end
+
   end # Container
 end # Watir

data/lib/watir-webdriver/element.rb

@@ -0,0 +1,201 @@
+# encoding: utf-8
+
+module Watir
+  class Element
+    include Exception
+    include Container
+    include Selenium
+    extend AttributeHelper
+    
+    def initialize(parent, selector)
+      @parent   = parent
+      @selector = selector
+
+      unless @selector.kind_of? Hash
+        raise ArgumentError, "invalid argument: #{selector.inspect}"
+      end
+
+      if @selector.has_key?(:element)
+        @element = @selector[:element]
+      end
+    end
+
+    def exists?
+      assert_exists
+      true
+    rescue UnknownObjectException, UnknownFrameException
+      false
+    end
+    alias_method :exist?, :exists?
+
+    def inspect
+      if @selector.has_key?(:element)
+        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, '{:element=>(webdriver element)}']
+      else
+        '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]
+      end
+    end
+
+    def text
+      assert_exists
+      @element.text
+    end
+
+    def tag_name
+      assert_exists
+      @element.tag_name
+    end
+
+    def click
+      assert_exists
+      assert_enabled
+      @element.click
+      run_checkers
+    end
+
+    def double_click
+      assert_exists
+      raise NotImplementedError, "need support in WebDriver"
+
+      @element.double_click
+      run_checkers
+    end
+
+    def right_click
+      assert_exists
+      raise NotImplementedError, "need support in WebDriver"
+
+      @element.right_click
+      run_checkers
+    end
+
+    def flash
+      assert_exists
+      original_color = driver.execute_script("arguments[0].style.backgroundColor", @element)
+      10.times do |n|
+        color = (n % 2 == 0) ? "red" : original_color
+        driver.execute_script("arguments[0].style.backgroundColor = '#{color}'", @element)
+      end
+    end
+
+    def value
+      assert_exists
+
+      begin
+        @element.value
+      rescue WebDriver::Error::ElementNotEnabledError
+        ""
+      end
+    end
+
+    def attribute_value(attribute_name)
+      assert_exists
+      @element.attribute attribute_name
+    end
+
+    def html
+      assert_exists
+      browserbot('getOuterHTML', @element).strip
+    end
+
+    def send_keys(*args)
+      assert_exists
+      @element.send_keys(*args)
+    end
+
+    #
+    # Note: Firefox queues focus events until the window actually has focus.
+    #
+    # See http://code.google.com/p/selenium/issues/detail?id=157
+    #
+
+    def focus
+      assert_exists
+      driver.execute_script "return arguments[0].focus()", @element
+    end
+
+    def fire_event(event_name, bubble = false)
+      assert_exists
+      event_name = event_name.to_s.sub(/^on/, '')
+      browserbot('triggerEvent', @element, event_name, bubble)
+    end
+
+    def parent
+      assert_exists
+
+      e = driver.execute_script "return arguments[0].parentNode", @element
+
+      if e.kind_of?(WebDriver::Element)
+        Watir.element_class_for(e.tag_name).new(@parent, :element => e)
+      end
+    end
+
+    def driver
+      @parent.driver
+    end
+
+    def element
+      assert_exists
+      @element
+    end
+    alias_method :wd, :element # ensures duck typing with Browser
+
+    def visible?
+      assert_exists
+      @element.displayed?
+    end
+
+    def style(property = nil)
+      if property
+        assert_exists
+        @element.style property
+      else
+        attribute_value "style" || ''
+      end
+    end
+
+    def run_checkers
+      @parent.run_checkers
+    end
+
+  protected
+
+    def assert_exists
+      @element ||= locate
+
+      unless @element
+        raise UnknownObjectException, "unable to locate element, using #{selector_string}"
+      end
+    end
+
+    def browser
+      @parent.browser
+    end
+
+    def locate
+      @parent.assert_exists
+      ElementLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
+    end
+
+  private
+
+    def selector_string
+      @selector.inspect
+    end
+
+    def attribute?(attribute)
+      assert_exists
+      driver.execute_script "return !!arguments[0].getAttributeNode(arguments[1]);", @element, attribute.to_s.downcase
+    end
+
+    def assert_enabled
+      raise ObjectDisabledException, "object is disabled #{selector_string}" unless @element.enabled?
+    end
+
+    def assert_writable
+      assert_enabled
+      raise ObjectReadOnlyException if respond_to?(:readonly?) && readonly?
+    end
+
+  end # Element
+end # Watir

data/lib/watir-webdriver/elements/button.rb

@@ -12,6 +12,15 @@ module Watir
     # add the attributes from <input>
     attributes Watir::Input.typed_attributes
 
+
+    def self.from(parent, element)
+      if element.tag_name == "button" ||
+         element.tag_name == "input" && %w[submit reset image button].include?(element.attribute(:type))
+        Button.new(parent, :element => element)
+      else
+        raise TypeError, "expected button or input[@type=submit|reset|image|button] for #{element.inspect}"
+      end
+    end
     #
     # Returns the text of the button.
     #
@@ -48,5 +57,13 @@ module Watir
       ButtonLocator.new(@parent.wd, @selector, self.class.attribute_list).locate
     end
 
-  end
-end
+  end # Button
+
+  class ButtonCollection < ElementCollection
+    private
+
+    def locator_class
+      ButtonLocator
+    end
+  end # ButtonsCollection
+end # Watir

data/lib/watir-webdriver/elements/checkbox.rb

@@ -1,10 +1,14 @@
 # encoding: utf-8
 module Watir
   class CheckBox < Input
-    identifier :type => 'checkbox'
 
-    container_method  :checkbox
-    collection_method :checkboxes
+    def self.from(parent, element)
+      if element.attribute(:type) != "checkbox"
+        raise TypeError, "expected type=checkbox for #{element.inspect}"
+      end
+
+      super
+    end
 
     #
     # Set this checkbox to the given value
@@ -48,6 +52,22 @@ module Watir
     def clear
       set false
     end
+  end # CheckBox
 
-  end
+
+  module Container
+    def checkbox(*args)
+      CheckBox.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
+    end
+
+    def checkboxes(*args)
+      CheckBoxCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "checkbox"))
+    end
+  end # Container
+
+  class CheckBoxCollection < InputCollection
+    def element_name
+      CheckBox
+    end
+  end # CheckBoxCollection
 end

data/lib/watir-webdriver/elements/file_field.rb

@@ -1,10 +1,13 @@
 # encoding: utf-8
 module Watir
   class FileField < Input
-    identifier :type => 'file'
+    def self.from(parent, element)
+      if element.attribute(:type) != "file"
+        raise TypeError, "expected type=file for #{element.inspect}"
+      end
 
-    container_method  :file_field
-    collection_method :file_fields
+      super
+    end
 
     #
     # Set the file field to the given path
@@ -14,6 +17,7 @@ module Watir
 
     def set(value)
       assert_exists
+      value.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
       @element.send_keys value
     end
 
@@ -29,4 +33,20 @@ module Watir
       @element.value
     end
   end
-end
+
+  module Container
+    def file_field(*args)
+      FileField.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))
+    end
+
+    def file_fields(*args)
+      FileFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "file"))
+    end
+  end # Container
+
+  class FileFieldCollection < InputCollection
+    def element_class
+      FileField
+    end
+  end # FileFieldCollection
+end # Watir

data/lib/watir-webdriver/elements/font.rb

@@ -1,12 +1,11 @@
-# encoding: utf-8
-
 module Watir
-  class Font < HTMLElement
-    identifier        :tag_name => 'font'
-    container_method  :font
-    collection_method :fonts
-
-    attributes :string => [:color, :face], :int => [:size]
-  end
-end
-
+  module Container
+    def font(*args)
+      Font.new(self, extract_selector(args).merge(:tag_name => "font"))
+    end
+    
+    def fonts(*args)
+      FontCollection.new(self, extract_selector(args).merge(:tag_name => "font"))
+    end
+  end # Container
+end # Watir

data/lib/watir-webdriver/elements/frame.rb

@@ -24,7 +24,6 @@ module Watir
     end
 
     def assert_exists
-      @parent.assert_exists
       # we always run locate(), to make sure the frame is switched
       @element = locate
     end
@@ -47,7 +46,7 @@ module Watir
 
     def locate_iframe
       # hack - frame doesn't have IFrame's attributes either
-      @iframe = IFrame.new(@parent, @selector).locate
+      @iframe = IFrame.new(@parent, @selector.merge(:tag_name => "iframe")).locate
 
       if @iframe
         switch_to_iframe @iframe
@@ -97,6 +96,15 @@ module Watir
 
       driver.switch_to.frame loc
     end
-
   end # Frame
+
+  module Container
+    def frame(*args)
+      Frame.new(self, extract_selector(args))
+    end
+
+    def frames(*args)
+      FrameCollection.new(self, extract_selector(args))
+    end
+  end
 end # Watir

data/lib/watir-webdriver/elements/generated.rb

@@ -1,1346 +1,2524 @@
 # Autogenerated from the HTML5 specification. Edits may be lost.
 module Watir
-  class HTMLElement < BaseElement
-    attributes(:token_list => ([:class_list]), :string => ([:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :access_key, :access_key_label, :content_editable, :spellcheck, :command_type, :label, :icon]), :string_map => ([:dataset]), :style => ([:style]), :html_element => ([:context_menu]), :bool => ([:hidden, :draggable, :is_content_editable, :disabled, :checked]), :function => ([:onabort, :onblur, :oncanplay, :oncanplaythrough, :onchange, :onclick, :oncontextmenu, :ondblclick, :ondrag, :ondragend, :ondragenter, :ondragleave, :ondragover, :ondragstart, :ondrop, :ondurationchange, :onemptied, :onended, :onerror, :onfocus, :onformchange, :onforminput, :oninput, :oninvalid, :onkeydown, :onkeypress, :onkeyup, :onload, :onloadeddata, :onloadedmetadata, :onloadstart, :onmousedown, :onmousemove, :onmouseout, :onmouseover, :onmouseup, :onmousewheel, :onpause, :onplay, :onplaying, :onprogress, :onratechange, :onreadystatechange, :onscroll, :onseeked, :onseeking, :onselect, :onshow, :onstalled, :onsubmit, :onsuspend, :ontimeupdate, :onvolumechange, :onwaiting]), :int => ([:tab_index]))
-  end
 
-  class Html < HTMLElement
-    identifier(:tag_name => "html")
 
-    container_method(:html)
 
-    collection_method(:htmls)
 
-    # do nothing
-  end
 
-  class Head < HTMLElement
-    identifier(:tag_name => "head")
 
-    container_method(:head)
 
-    collection_method(:heads)
 
-    # do nothing
-  end
 
-  class Title < HTMLElement
-    identifier(:tag_name => "title")
 
-    container_method(:title)
 
-    collection_method(:titles)
 
-    attributes(:string => ([:text]))
-  end
 
-  class Base < HTMLElement
-    identifier(:tag_name => "base")
 
-    container_method(:base)
 
-    collection_method(:bases)
 
-    attributes(:string => ([:href, :target]))
-  end
 
-  # class Link < HTMLElement
-  #   identifier(:tag_name => "link")
-  #
-  #   container_method(:link)
-  #
-  #   collection_method(:links)
-  #
-  #   attributes(:token_list => ([:rel_list, :sizes]), :string => ([:href, :rel, :media, :hreflang, :type]), :bool => ([:disabled]))
-  # end
 
-  class Meta < HTMLElement
-    identifier(:tag_name => "meta")
 
-    container_method(:meta)
 
-    collection_method(:metas)
 
-    attributes(:string => ([:name, :http_equiv, :content]))
-  end
 
-  class Style < HTMLElement
-    identifier(:tag_name => "style")
 
-    container_method(:style)
 
-    collection_method(:styles)
 
-    attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
-  end
 
-  class Script < HTMLElement
-    identifier(:tag_name => "script")
 
-    container_method(:script)
 
-    collection_method(:scripts)
 
-    attributes(:string => ([:src, :type, :charset, :text]), :bool => ([:async, :defer]))
-  end
 
-  class Body < HTMLElement
-    identifier(:tag_name => "body")
 
-    container_method(:body)
-
-    collection_method(:bodys)
-
-    attributes(:function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpopstate, :onpagehide, :onpageshow, :onredo, :onresize, :onstorage, :onundo, :onunload]))
-  end
-
-  class Heading < HTMLElement
-    identifier(:tag_name => "h1")
-
-    container_method(:h1)
-
-    collection_method(:h1s)
-
-    # do nothing
-  end
-
-  class Paragraph < HTMLElement
-    identifier(:tag_name => "p")
-
-    container_method(:p)
-
-    collection_method(:ps)
-
-    # do nothing
-  end
-
-  class HR < HTMLElement
-    identifier(:tag_name => "hr")
-
-    container_method(:hr)
-
-    collection_method(:hrs)
-
-    # do nothing
-  end
-
-  class Pre < HTMLElement
-    identifier(:tag_name => "pre")
-
-    container_method(:pre)
-
-    collection_method(:pres)
-
-    # do nothing
-  end
-
-  class Quote < HTMLElement
-    identifier(:tag_name => "blockquote")
-
-    container_method(:blockquote)
-
-    collection_method(:blockquotes)
-
-    attributes(:string => ([:cite]))
-  end
-
-  class OList < HTMLElement
-    identifier(:tag_name => "ol")
-
-    container_method(:ol)
-
-    collection_method(:ols)
-
-    attributes(:bool => ([:reversed]), :int => ([:start]))
-  end
-
-  class UList < HTMLElement
-    identifier(:tag_name => "ul")
-
-    container_method(:ul)
-
-    collection_method(:uls)
-
-    # do nothing
-  end
-
-  class LI < HTMLElement
-    identifier(:tag_name => "li")
-
-    container_method(:li)
-
-    collection_method(:lis)
-
-    attributes(:int => ([:value]))
-  end
-
-  class DList < HTMLElement
-    identifier(:tag_name => "dl")
-
-    container_method(:dl)
-
-    collection_method(:dls)
-
-    # do nothing
-  end
-
-  class Div < HTMLElement
-    identifier(:tag_name => "div")
-
-    container_method(:div)
-
-    collection_method(:divs)
-
-    # do nothing
-  end
-
-  class Anchor < HTMLElement
-    identifier(:tag_name => "a")
-
-    container_method(:a)
-
-    collection_method(:as)
-
-    attributes(:token_list => ([:rel_list]), :string => ([:href, :target, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
-  end
-
-  class Time < HTMLElement
-    identifier(:tag_name => "time")
-
-    container_method(:time)
-
-    collection_method(:times)
-
-    attributes(:string => ([:date_time]), :date => ([:value_as_date]), :bool => ([:pub_date]))
-  end
-
-  class Span < HTMLElement
-    identifier(:tag_name => "span")
-
-    container_method(:span)
-
-    collection_method(:spans)
-
-    # do nothing
-  end
-
-  class BR < HTMLElement
-    identifier(:tag_name => "br")
-
-    container_method(:br)
-
-    collection_method(:brs)
-
-    # do nothing
-  end
-
-  class Mod < HTMLElement
-    attributes(:string => ([:cite, :date_time]))
-  end
-
-  class Image < HTMLElement
-    identifier(:tag_name => "img")
-
-    container_method(:image)
-
-    collection_method(:images)
-
-    attributes(:string => ([:alt, :src, :use_map]), :bool => ([:is_map, :complete]), :int => ([:width, :height, :natural_width, :natural_height]))
-  end
-
-  class IFrame < HTMLElement
-    identifier(:tag_name => "iframe")
-
-    container_method(:iframe)
-
-    collection_method(:iframes)
-
-    attributes(:token_list => ([:sandbox]), :string => ([:src, :srcdoc, :name, :width, :height, :content_window]), :document => ([:content_document]), :bool => ([:seamless]))
-  end
-
-  class Embed < HTMLElement
-    identifier(:tag_name => "embed")
-
-    container_method(:embed)
-
-    collection_method(:embeds)
-
-    attributes(:string => ([:src, :type, :width, :height]))
-  end
-
-  class Object < HTMLElement
-    identifier(:tag_name => "object")
-
-    container_method(:object)
-
-    collection_method(:objects)
-
-    attributes(:string => ([:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:will_validate]), :document => ([:content_document]))
-  end
-
-  class Param < HTMLElement
-    identifier(:tag_name => "param")
-
-    container_method(:param)
-
-    collection_method(:params)
-
-    attributes(:string => ([:name, :value]))
-  end
-
-  class Media < HTMLElement
-    attributes(:string => ([:error, :src, :current_src, :preload, :buffered, :played, :seekable]), :float => ([:current_time, :start_time, :duration, :default_playback_rate, :playback_rate, :volume]), :bool => ([:seeking, :paused, :ended, :autoplay, :loop, :controls, :muted]), :int => ([:network_state, :ready_state]))
-  end
-
-  class Video < Media
-    identifier(:tag_name => "video")
-
-    container_method(:video)
-
-    collection_method(:videos)
-
-    attributes(:string => ([:width, :height, :poster]), :int => ([:video_width, :video_height]))
-  end
-
-  class Audio < Media
-    identifier(:tag_name => "audio")
-
-    container_method(:audio)
-
-    collection_method(:audios)
-
-    # do nothing
-  end
-
-  class Source < HTMLElement
-    identifier(:tag_name => "source")
-
-    container_method(:source)
-
-    collection_method(:sources)
-
-    attributes(:string => ([:src, :type, :media]))
-  end
-
-  class Canvas < HTMLElement
-    identifier(:tag_name => "canvas")
-
-    container_method(:canvas)
-
-    collection_method(:canvases)
-
-    attributes(:int => ([:width, :height]))
-  end
-
-  class Map < HTMLElement
-    identifier(:tag_name => "map")
-
-    container_method(:map)
-
-    collection_method(:maps)
-
-    attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
-  end
-
-  class Area < HTMLElement
-    attributes(:token_list => ([:rel_list]), :string => ([:alt, :coords, :shape, :href, :target, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
-  end
-
-  class Table < HTMLElement
-    identifier(:tag_name => "table")
-
-    container_method(:table)
-
-    collection_method(:tables)
-
-    attributes(:string => ([:summary]), :html_element => ([:caption, :t_head, :t_foot]), :html_collection => ([:t_bodies, :rows]))
-  end
-
-  class TableCaption < HTMLElement
-    identifier(:tag_name => "caption")
-
-    container_method(:caption)
-
-    collection_method(:captions)
-
-    # do nothing
-  end
-
-  class TableCol < HTMLElement
-    identifier(:tag_name => "colgroup")
-
-    container_method(:colgroup)
-
-    collection_method(:colgroups)
-
-    attributes(:int => ([:span]))
-  end
-
-  class TableSection < HTMLElement
-    identifier(:tag_name => "tbody")
-
-    container_method(:tbody)
-
-    collection_method(:tbodys)
-
-    attributes(:html_collection => ([:rows]))
-  end
-
-  class TableRow < HTMLElement
-    identifier(:tag_name => "tr")
-
-    container_method(:tr)
-
-    collection_method(:trs)
-
-    attributes(:html_collection => ([:cells]), :int => ([:row_index, :section_row_index]))
-  end
-
-  class TableCell < HTMLElement
-    identifier(:tag_name => "td")
-
-    container_method(:td)
-
-    collection_method(:tds)
-
-    attributes(:string => ([:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width]), :bool => ([:no_wrap]))
-  end
-
-  class TableDataCell < TableCell
-    identifier(:tag_name => "td")
-
-    container_method(:td)
-
-    collection_method(:tds)
-
-    # do nothing
-  end
-
-  class TableHeaderCell < TableCell
-    identifier(:tag_name => "th")
-
-    container_method(:th)
-
-    collection_method(:ths)
-
-    attributes(:string => ([:scope]))
-  end
-
-  class TableCell < HTMLElement
-    attributes(:token_list => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
-  end
-
-  class Form < HTMLElement
-    identifier(:tag_name => "form")
-
-    container_method(:form)
-
-    collection_method(:forms)
-
-    attributes(:string => ([:accept_charset, :action, :autocomplete, :enctype, :method, :name, :target]), :bool => ([:no_validate]), :html_collection => ([:elements]), :int => ([:length]))
-  end
-
-  class FieldSet < HTMLElement
-    identifier(:tag_name => "fieldset")
-
-    container_method(:fieldset)
-
-    collection_method(:fieldsets)
-
-    attributes(:string => ([:name, :type, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:disabled, :will_validate]), :html_collection => ([:elements]))
-  end
-
-  class Legend < HTMLElement
-    identifier(:tag_name => "legend")
-
-    container_method(:legend)
-
-    collection_method(:legends)
-
-    attributes(:html_element => ([:form]))
-  end
-
-  class Label < HTMLElement
-    identifier(:tag_name => "label")
-
-    container_method(:label)
-
-    collection_method(:labels)
-
-    attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
-  end
-
-  class Input < HTMLElement
-    identifier(:tag_name => "input")
-
-    container_method(:input)
-
-    collection_method(:inputs)
-
-    attributes(:string => ([:accept, :alt, :autocomplete, :form_action, :form_enctype, :form_method, :form_target, :height, :max, :min, :name, :pattern, :placeholder, :src, :step, :type, :default_value, :value, :width, :validity, :validation_message]), :date => ([:value_as_date]), :float => ([:value_as_number]), :list => ([:files, :labels]), :html_element => ([:form, :list, :selected_option]), :bool => ([:autofocus, :default_checked, :checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate]), :int => ([:max_length, :size, :selection_start, :selection_end]))
-  end
-
-  class Button < HTMLElement
-    identifier(:tag_name => "button")
-
-    container_method(:button)
-
-    collection_method(:buttons)
-
-    attributes(:string => ([:form_action, :form_enctype, :form_method, :form_no_validate, :form_target, :name, :type, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
-  end
-
-  class Select < HTMLElement
-    identifier(:tag_name => "select")
-
-    container_method(:select)
-
-    collection_method(:selects)
-
-    attributes(:string => ([:name, :type, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :multiple, :will_validate]), :html_collection => ([:options, :selected_options]), :int => ([:size, :length, :selected_index]))
-  end
-
-  class DataList < HTMLElement
-    identifier(:tag_name => "datalist")
-
-    container_method(:datalist)
-
-    collection_method(:datalists)
-
-    attributes(:html_collection => ([:options]))
-  end
-
-  class OptGroup < HTMLElement
-    identifier(:tag_name => "optgroup")
-
-    container_method(:optgroup)
-
-    collection_method(:optgroups)
-
-    attributes(:string => ([:label]), :bool => ([:disabled]))
-  end
-
-  class Option < HTMLElement
-    identifier(:tag_name => "option")
-
-    container_method(:option)
-
-    collection_method(:options)
-
-    attributes(:string => ([:label, :value, :text]), :html_element => ([:form]), :bool => ([:disabled, :default_selected, :selected]), :int => ([:index]))
-  end
-
-  class TextArea < HTMLElement
-    identifier(:tag_name => "textarea")
-
-    container_method(:textarea)
-
-    collection_method(:textareas)
-
-    attributes(:string => ([:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :read_only, :required, :will_validate]), :int => ([:cols, :max_length, :rows, :text_length, :selection_start, :selection_end]))
-  end
-
-  class Keygen < HTMLElement
-    identifier(:tag_name => "keygen")
-
-    container_method(:keygen)
-
-    collection_method(:keygens)
-
-    attributes(:string => ([:challenge, :keytype, :name, :type, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
-  end
-
-  class Output < HTMLElement
-    identifier(:tag_name => "output")
-
-    container_method(:output)
-
-    collection_method(:outputs)
-
-    attributes(:token_list => ([:html_for]), :string => ([:name, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:will_validate]))
-  end
-
-  class Progress < HTMLElement
-    identifier(:tag_name => "progress")
-
-    container_method(:progress)
-
-    collection_method(:progresses)
-
-    attributes(:list => ([:labels]), :float => ([:value, :max, :position]), :html_element => ([:form]))
-  end
-
-  class Meter < HTMLElement
-    identifier(:tag_name => "meter")
-
-    container_method(:meter)
-
-    collection_method(:meters)
-
-    attributes(:list => ([:labels]), :float => ([:value, :min, :max, :low, :high, :optimum]), :html_element => ([:form]))
-  end
-
-  class Details < HTMLElement
-    identifier(:tag_name => "details")
-
-    container_method(:details)
-
-    collection_method(:details)
-
-    attributes(:bool => ([:open]))
-  end
-
-  class Command < HTMLElement
-    identifier(:tag_name => "command")
-
-    container_method(:command)
-
-    collection_method(:commands)
-
-    attributes(:string => ([:type, :label, :icon, :radiogroup]), :bool => ([:disabled, :checked]))
-  end
-
-  class Menu < HTMLElement
-    identifier(:tag_name => "menu")
-
-    container_method(:menu)
-
-    collection_method(:menus)
-
-    attributes(:string => ([:type, :label]))
-  end
-
-  class Applet < HTMLElement
-    identifier(:tag_name => "applet")
-
-    container_method(:applet)
-
-    collection_method(:applets)
-
-    attributes(:string => ([:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width]), :int => ([:hspace, :vspace]))
-  end
-
-  class Marquee < HTMLElement
-    identifier(:tag_name => "marquee")
-
-    container_method(:marquee)
-
-    collection_method(:marquees)
-
-    attributes(:string => ([:behavior, :bg_color, :direction, :height, :true_speed, :width]), :function => ([:onbounce, :onfinish, :onstart]), :int => ([:hspace, :loop, :scroll_amount, :scroll_delay, :vspace]))
-  end
-
-  class FrameSet < HTMLElement
-    identifier(:tag_name => "frameset")
-
-    container_method(:frameset)
-
-    collection_method(:framesets)
-
-    attributes(:string => ([:cols, :rows]), :function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onredo, :onresize, :onstorage, :onundo, :onunload]))
-  end
-
-  class Frame < HTMLElement
-    identifier(:tag_name => "frame")
-
-    container_method(:frame)
-
-    collection_method(:frames)
-
-    attributes(:string => ([:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src]), :document => ([:content_document]), :bool => ([:no_resize]))
-  end
-
-  class Anchor < HTMLElement
-    identifier(:tag_name => "a")
-
-    container_method(:a)
-
-    collection_method(:as)
-
-    attributes(:string => ([:coords, :charset, :name, :rev, :shape]))
-  end
-
-  class Area < HTMLElement
-    identifier(:tag_name => "area")
-
-    container_method(:area)
-
-    collection_method(:areas)
-
-    attributes(:bool => ([:no_href]))
-  end
-
-  class BaseFont < HTMLElement
-    identifier(:tag_name => "basefont")
-
-    container_method(:basefont)
-
-    collection_method(:basefonts)
-
-    attributes(:string => ([:color, :face]), :int => ([:size]))
-  end
-
-  class Body < HTMLElement
-    identifier(:tag_name => "body")
-
-    container_method(:body)
-
-    collection_method(:bodys)
-
-    attributes(:string => ([:text, :bg_color, :background, :link, :v_link, :a_link]))
-  end
-
-  class BR < HTMLElement
-    identifier(:tag_name => "br")
-
-    container_method(:br)
-
-    collection_method(:brs)
-
-    attributes(:string => ([:clear]))
-  end
-
-  class TableCaption < HTMLElement
-    identifier(:tag_name => "caption")
-
-    container_method(:caption)
-
-    collection_method(:captions)
-
-    attributes(:string => ([:align]))
-  end
-
-  class TableCol < HTMLElement
-    identifier(:tag_name => "col")
-
-    container_method(:col)
-
-    collection_method(:cols)
-
-    attributes(:string => ([:align, :ch, :ch_off, :v_align, :width]))
-  end
-
-  class Directory < HTMLElement
-    attributes(:bool => ([:compact]))
-  end
-
-  class Div < HTMLElement
-    identifier(:tag_name => "div")
-
-    container_method(:div)
-
-    collection_method(:divs)
-
-    attributes(:string => ([:align]))
-  end
-
-  class DList < HTMLElement
-    identifier(:tag_name => "dl")
-
-    container_method(:dl)
-
-    collection_method(:dls)
-
-    attributes(:bool => ([:compact]))
-  end
-
-  class Embed < HTMLElement
-    identifier(:tag_name => "embed")
-
-    container_method(:embed)
-
-    collection_method(:embeds)
-
-    attributes(:string => ([:align, :name]))
-  end
-
-  class Font < HTMLElement
-    identifier(:tag_name => "font")
-
-    container_method(:font)
-
-    collection_method(:fonts)
-
-    attributes(:string => ([:color, :face, :size]))
-  end
-
-  class Heading < HTMLElement
-    identifier(:tag_name => "h1")
-
-    container_method(:h1)
-
-    collection_method(:h1s)
-
-    attributes(:string => ([:align]))
-  end
-
-  class HR < HTMLElement
-    identifier(:tag_name => "hr")
-
-    container_method(:hr)
-
-    collection_method(:hrs)
-
-    attributes(:string => ([:align, :color, :size, :width]), :bool => ([:no_shade]))
-  end
-
-  class Html < HTMLElement
-    identifier(:tag_name => "html")
-
-    container_method(:html)
-
-    collection_method(:htmls)
-
-    attributes(:string => ([:version]))
-  end
-
-  class IFrame < HTMLElement
-    identifier(:tag_name => "iframe")
-
-    container_method(:iframe)
-
-    collection_method(:iframes)
-
-    attributes(:string => ([:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling]))
-  end
-
-  class Image < HTMLElement
-    identifier(:tag_name => "img")
-
-    container_method(:image)
-
-    collection_method(:images)
-
-    attributes(:string => ([:name, :align, :border, :long_desc]), :int => ([:hspace, :vspace]))
-  end
-
-  class Input < HTMLElement
-    identifier(:tag_name => "input")
-
-    container_method(:input)
-
-    collection_method(:inputs)
-
-    attributes(:string => ([:align, :use_map]))
-  end
-
-  class Legend < HTMLElement
-    identifier(:tag_name => "legend")
-
-    container_method(:legend)
-
-    collection_method(:legends)
-
-    attributes(:string => ([:align]))
-  end
-
-  class LI < HTMLElement
-    identifier(:tag_name => "li")
-
-    container_method(:li)
-
-    collection_method(:lis)
-
-    attributes(:string => ([:type]))
-  end
-
-  # class Link < HTMLElement
-  #   identifier(:tag_name => "link")
-  #
-  #   container_method(:link)
-  #
-  #   collection_method(:links)
-  #
-  #   attributes(:string => ([:charset, :rev, :target]))
-  # end
-
-  class Menu < HTMLElement
-    identifier(:tag_name => "menu")
-
-    container_method(:menu)
-
-    collection_method(:menus)
-
-    attributes(:bool => ([:compact]))
-  end
-
-  class Meta < HTMLElement
-    identifier(:tag_name => "meta")
-
-    container_method(:meta)
-
-    collection_method(:metas)
-
-    attributes(:string => ([:scheme]))
-  end
-
-  class Object < HTMLElement
-    identifier(:tag_name => "object")
-
-    container_method(:object)
-
-    collection_method(:objects)
-
-    attributes(:string => ([:align, :archive, :border, :code, :code_base, :code_type, :standby]), :bool => ([:declare]), :int => ([:hspace, :vspace]))
-  end
-
-  class OList < HTMLElement
-    identifier(:tag_name => "ol")
-
-    container_method(:ol)
-
-    collection_method(:ols)
-
-    attributes(:string => ([:type]), :bool => ([:compact]))
-  end
-
-  class Paragraph < HTMLElement
-    identifier(:tag_name => "p")
-
-    container_method(:p)
-
-    collection_method(:ps)
-
-    attributes(:string => ([:align]))
-  end
-
-  class Param < HTMLElement
-    identifier(:tag_name => "param")
-
-    container_method(:param)
-
-    collection_method(:params)
-
-    attributes(:string => ([:type, :value_type]))
-  end
-
-  class Pre < HTMLElement
-    identifier(:tag_name => "pre")
-
-    container_method(:pre)
-
-    collection_method(:pres)
-
-    attributes(:int => ([:width]))
-  end
-
-  class Script < HTMLElement
-    identifier(:tag_name => "script")
-
-    container_method(:script)
-
-    collection_method(:scripts)
-
-    attributes(:string => ([:event, :html_for]))
-  end
-
-  class Table < HTMLElement
-    identifier(:tag_name => "table")
-
-    container_method(:table)
-
-    collection_method(:tables)
-
-    attributes(:string => ([:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width]))
-  end
-
-  class TableSection < HTMLElement
-    identifier(:tag_name => "tbody")
-
-    container_method(:tbody)
-
-    collection_method(:tbodys)
-
-    attributes(:string => ([:align, :ch, :ch_off, :v_align]))
-  end
-
-  class TableRow < HTMLElement
-    identifier(:tag_name => "tr")
-
-    container_method(:tr)
-
-    collection_method(:trs)
-
-    attributes(:string => ([:align, :bg_color, :ch, :ch_off, :v_align]))
-  end
-
-  class UList < HTMLElement
-    identifier(:tag_name => "ul")
-
-    container_method(:ul)
-
-    collection_method(:uls)
-
-    attributes(:string => ([:type]), :bool => ([:compact]))
-  end
-
-  class Thead < TableSection
-    identifier(:tag_name => "thead")
-
-    container_method(:thead)
-
-    collection_method(:theads)
-
-    # do nothing
-  end
-
-  class Dd < HTMLElement
-    identifier(:tag_name => "dd")
-
-    container_method(:dd)
-
-    collection_method(:dds)
-
-    # do nothing
-  end
-
-  class Address < HTMLElement
-    identifier(:tag_name => "address")
-
-    container_method(:address)
-
-    collection_method(:addresses)
-
-    # do nothing
-  end
-
-  class Nav < HTMLElement
-    identifier(:tag_name => "nav")
-
-    container_method(:nav)
-
-    collection_method(:navs)
-
-    # do nothing
-  end
-
-  class TFoot < TableSection
-    identifier(:tag_name => "tfoot")
-
-    container_method(:tfoot)
-
-    collection_method(:tfoots)
-
-    # do nothing
-  end
-
-  class Sub < HTMLElement
-    identifier(:tag_name => "sub")
-
-    container_method(:sub)
-
-    collection_method(:subs)
-
-    # do nothing
-  end
-
-  class Sup < HTMLElement
-    identifier(:tag_name => "sup")
-
-    container_method(:sup)
-
-    collection_method(:sups)
-
-    # do nothing
-  end
-
-  class Bdo < HTMLElement
-    identifier(:tag_name => "bdo")
-
-    container_method(:bdo)
-
-    collection_method(:bdos)
-
-    # do nothing
-  end
-
-  class Rp < HTMLElement
-    identifier(:tag_name => "rp")
-
-    container_method(:rp)
-
-    collection_method(:rps)
-
-    # do nothing
-  end
-
-  class Rt < HTMLElement
-    identifier(:tag_name => "rt")
-
-    container_method(:rt)
-
-    collection_method(:rts)
-
-    # do nothing
-  end
-
-  class Mark < HTMLElement
-    identifier(:tag_name => "mark")
-
-    container_method(:mark)
-
-    collection_method(:marks)
-
-    # do nothing
-  end
-
-  class Kbd < HTMLElement
-    identifier(:tag_name => "kbd")
-
-    container_method(:kbd)
-
-    collection_method(:kbds)
-
-    # do nothing
-  end
-
-  class Dfn < HTMLElement
-    identifier(:tag_name => "dfn")
-
-    container_method(:dfn)
-
-    collection_method(:dfns)
-
-    # do nothing
-  end
-
-  class Cite < HTMLElement
-    identifier(:tag_name => "cite")
-
-    container_method(:cite)
-
-    collection_method(:cites)
-
-    # do nothing
-  end
-
-  class Ins < Mod
-    identifier(:tag_name => "ins")
-
-    container_method(:ins)
-
-    collection_method(:inses)
-
-    # do nothing
-  end
-
-  class B < HTMLElement
-    identifier(:tag_name => "b")
-
-    container_method(:b)
-
-    collection_method(:bs)
-
-    # do nothing
-  end
-
-  class Noscript < HTMLElement
-    identifier(:tag_name => "noscript")
-
-    container_method(:noscript)
-
-    collection_method(:noscripts)
-
-    # do nothing
-  end
-
-  class Figure < HTMLElement
-    identifier(:tag_name => "figure")
-
-    container_method(:figure)
-
-    collection_method(:figures)
-
-    # do nothing
-  end
-
-  class Code < HTMLElement
-    identifier(:tag_name => "code")
-
-    container_method(:code)
-
-    collection_method(:codes)
-
-    # do nothing
-  end
-
-  class Q < Quote
-    identifier(:tag_name => "q")
-
-    container_method(:q)
-
-    collection_method(:qs)
-
-    # do nothing
-  end
-
-  class Strong < HTMLElement
-    identifier(:tag_name => "strong")
-
-    container_method(:strong)
-
-    collection_method(:strongs)
-
-    # do nothing
-  end
-
-  class Header < HTMLElement
-    identifier(:tag_name => "header")
-
-    container_method(:header)
-
-    collection_method(:headers)
-
-    # do nothing
-  end
-
-  class Hgroup < HTMLElement
-    identifier(:tag_name => "hgroup")
-
-    container_method(:hgroup)
-
-    collection_method(:hgroups)
-
-    # do nothing
-  end
-
-  class Aside < HTMLElement
-    identifier(:tag_name => "aside")
-
-    container_method(:aside)
-
-    collection_method(:asides)
-
-    # do nothing
-  end
-
-  class Samp < HTMLElement
-    identifier(:tag_name => "samp")
-
-    container_method(:samp)
-
-    collection_method(:samps)
-
-    # do nothing
-  end
-
-  class Section < HTMLElement
-    identifier(:tag_name => "section")
-
-    container_method(:section)
-
-    collection_method(:sections)
-
-    # do nothing
-  end
-
-  class Dt < HTMLElement
-    identifier(:tag_name => "dt")
-
-    container_method(:dt)
-
-    collection_method(:dts)
-
-    # do nothing
-  end
-
-  class Col < TableCol
-    identifier(:tag_name => "col")
-
-    container_method(:col)
-
-    collection_method(:cols)
-
-    # do nothing
-  end
-
-  class I < HTMLElement
-    identifier(:tag_name => "i")
-
-    container_method(:i)
-
-    collection_method(:is)
-
-    # do nothing
-  end
-
-  class Var < HTMLElement
-    identifier(:tag_name => "var")
-
-    container_method(:var)
-
-    collection_method(:vars)
-
-    # do nothing
-  end
-
-  class Abbr < HTMLElement
-    identifier(:tag_name => "abbr")
-
-    container_method(:abbr)
-
-    collection_method(:abbrs)
-
-    # do nothing
-  end
-
-  class Small < HTMLElement
-    identifier(:tag_name => "small")
-
-    container_method(:small)
-
-    collection_method(:smalls)
-
-    # do nothing
-  end
-
-  class Footer < HTMLElement
-    identifier(:tag_name => "footer")
-
-    container_method(:footer)
-
-    collection_method(:footers)
-
-    # do nothing
-  end
-
-  class Ruby < HTMLElement
-    identifier(:tag_name => "ruby")
-
-    container_method(:ruby)
-
-    collection_method(:rubies)
-
-    # do nothing
-  end
-
-  class Article < HTMLElement
-    identifier(:tag_name => "article")
-
-    container_method(:article)
-
-    collection_method(:articles)
-
-    # do nothing
-  end
-
-  class Del < Mod
-    identifier(:tag_name => "del")
-
-    container_method(:del)
-
-    collection_method(:dels)
-
-    # do nothing
-  end
-
-  class Em < HTMLElement
-    identifier(:tag_name => "em")
-
-    container_method(:em)
-
-    collection_method(:ems)
-
-    # do nothing
-  end
-end
+ class HTMLElement < Element
+   attributes(:token_list => ([:class_list, :item_ref, :item_prop]), :style => ([:style]), :string_map => ([:dataset]), :string => ([:innerhtml, :outerhtml, :id, :title, :lang, :dir, :class_name, :item_type, :item_id, :item_value, :access_key, :access_key_label, :content_editable, :command_type, :label, :icon]), :properties_collection => ([:properties]), :int => ([:tab_index]), :html_element => ([:context_menu]), :function => ([:onabort, :onblur, :oncanplay, :oncanplaythrough, :onchange, :onclick, :oncontextmenu, :oncuechange, :ondblclick, :ondrag, :ondragend, :ondragenter, :ondragleave, :ondragover, :ondragstart, :ondrop, :ondurationchange, :onemptied, :onended, :onerror, :onfocus, :onformchange, :onforminput, :oninput, :oninvalid, :onkeydown, :onkeypress, :onkeyup, :onload, :onloadeddata, :onloadedmetadata, :onloadstart, :onmousedown, :onmousemove, :onmouseout, :onmouseover, :onmouseup, :onmousewheel, :onpause, :onplay, :onplaying, :onprogress, :onratechange, :onreadystatechange, :onscroll, :onseeked, :onseeking, :onselect, :onshow, :onstalled, :onsubmit, :onsuspend, :ontimeupdate, :onvolumechange, :onwaiting]), :bool => ([:item_scope, :hidden, :draggable, :is_content_editable, :spellcheck, :disabled, :checked]))
+ end
+ class HTMLElementCollection < ElementCollection
+   def element_class
+     HTMLElement
+   end
+ end
+ class Directory < HTMLElement
+   attributes(:bool => ([:compact]))
+ end
+ class DirectoryCollection < ElementCollection
+   def element_class
+     Directory
+   end
+ end
+ class Frame < HTMLElement
+   attributes(:string => ([:frame_border, :long_desc, :margin_height, :margin_width, :name, :scrolling, :src]), :bool => ([:no_resize]), :document => ([:content_document]))
+ end
+ class FrameCollection < ElementCollection
+   def element_class
+     Frame
+   end
+ end
+ class FrameSet < HTMLElement
+   attributes(:string => ([:cols, :rows]), :function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onredo, :onresize, :onstorage, :onundo, :onunload]))
+ end
+ class FrameSetCollection < ElementCollection
+   def element_class
+     FrameSet
+   end
+ end
+ class Applet < HTMLElement
+   attributes(:string => ([:align, :alt, :archive, :code, :code_base, :height, :name, :object, :width]), :int => ([:hspace, :vspace]))
+ end
+ class AppletCollection < ElementCollection
+   def element_class
+     Applet
+   end
+ end
+ class Menu < HTMLElement
+   attributes(:string => ([:type, :label]))
+ end
+ class MenuCollection < ElementCollection
+   def element_class
+     Menu
+   end
+ end
+ class Menu < HTMLElement
+   attributes(:bool => ([:compact]))
+ end
+ # do nothing
+ class Command < HTMLElement
+   attributes(:string => ([:type, :label, :icon, :radiogroup]), :bool => ([:disabled, :checked]))
+ end
+ class CommandCollection < ElementCollection
+   def element_class
+     Command
+   end
+ end
+ class Meter < HTMLElement
+   attributes(:float => ([:value, :min, :max, :low, :high, :optimum]), :list => ([:labels]), :html_element => ([:form]))
+ end
+ class MeterCollection < ElementCollection
+   def element_class
+     Meter
+   end
+ end
+ class Progress < HTMLElement
+   attributes(:float => ([:value, :max, :position]), :list => ([:labels]), :html_element => ([:form]))
+ end
+ class ProgressCollection < ElementCollection
+   def element_class
+     Progress
+   end
+ end
+ class Keygen < HTMLElement
+   attributes(:string => ([:challenge, :keytype, :name, :type, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
+ end
+ class KeygenCollection < ElementCollection
+   def element_class
+     Keygen
+   end
+ end
+ class TextArea < HTMLElement
+   attributes(:string => ([:name, :placeholder, :wrap, :type, :default_value, :value, :validity, :validation_message]), :int => ([:cols, :max_length, :rows, :text_length, :selection_start, :selection_end]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :read_only, :required, :will_validate]))
+ end
+ class TextAreaCollection < ElementCollection
+   def element_class
+     TextArea
+   end
+ end
+ class Option < HTMLElement
+   attributes(:string => ([:label, :value, :text]), :int => ([:index]), :html_element => ([:form]), :bool => ([:disabled, :default_selected, :selected]))
+ end
+ class OptionCollection < ElementCollection
+   def element_class
+     Option
+   end
+ end
+ class DataList < HTMLElement
+   attributes(:html_collection => ([:options]))
+ end
+ class DataListCollection < ElementCollection
+   def element_class
+     DataList
+   end
+ end
+ class Input < HTMLElement
+   attributes(:string => ([:accept, :alt, :autocomplete, :form_action, :form_enctype, :form_method, :form_target, :height, :max, :min, :name, :pattern, :placeholder, :src, :step, :type, :default_value, :value, :width, :validity, :validation_message]), :float => ([:value_as_number]), :int => ([:max_length, :size, :selection_start, :selection_end]), :list => ([:files, :labels]), :html_element => ([:form, :list, :selected_option]), :bool => ([:autofocus, :default_checked, :checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate]), :date => ([:value_as_date]))
+ end
+ class InputCollection < ElementCollection
+   def element_class
+     Input
+   end
+ end
+ class Input < HTMLElement
+   attributes(:string => ([:align, :use_map]))
+ end
+ # do nothing
+ class Label < HTMLElement
+   attributes(:string => ([:html_for]), :html_element => ([:form, :control]))
+ end
+ class LabelCollection < ElementCollection
+   def element_class
+     Label
+   end
+ end
+ class Legend < HTMLElement
+   attributes(:html_element => ([:form]))
+ end
+ class LegendCollection < ElementCollection
+   def element_class
+     Legend
+   end
+ end
+ class Legend < HTMLElement
+   attributes(:string => ([:align]))
+ end
+ # do nothing
+ class Form < HTMLElement
+   attributes(:string => ([:accept_charset, :action, :autocomplete, :enctype, :method, :name, :target]), :int => ([:length]), :html_collection => ([:elements]), :bool => ([:no_validate]))
+ end
+ class FormCollection < ElementCollection
+   def element_class
+     Form
+   end
+ end
+ class TableRow < HTMLElement
+   attributes(:int => ([:row_index, :section_row_index]), :html_collection => ([:cells]))
+ end
+ class TableRowCollection < ElementCollection
+   def element_class
+     TableRow
+   end
+ end
+ class TableRow < HTMLElement
+   attributes(:string => ([:align, :bg_color, :ch, :ch_off, :v_align]))
+ end
+ # do nothing
+ class TableSection < HTMLElement
+   attributes(:html_collection => ([:rows]))
+ end
+ class TableSectionCollection < ElementCollection
+   def element_class
+     TableSection
+   end
+ end
+ class TableSection < HTMLElement
+   attributes(:string => ([:align, :ch, :ch_off, :v_align]))
+ end
+ # do nothing
+ class TableCol < HTMLElement
+   attributes(:int => ([:span]))
+ end
+ class TableColCollection < ElementCollection
+   def element_class
+     TableCol
+   end
+ end
+ class TableCol < HTMLElement
+   attributes(:string => ([:align, :ch, :ch_off, :v_align, :width]))
+ end
+ # do nothing
+ class Table < HTMLElement
+   attributes(:string => ([:summary]), :html_element => ([:caption, :t_head, :t_foot]), :html_collection => ([:t_bodies, :rows]))
+ end
+ class TableCollection < ElementCollection
+   def element_class
+     Table
+   end
+ end
+ class Table < HTMLElement
+   attributes(:string => ([:align, :bg_color, :border, :cell_padding, :cell_spacing, :frame, :rules, :width]))
+ end
+ # do nothing
+ class Map < HTMLElement
+   attributes(:string => ([:name]), :html_collection => ([:areas, :images]))
+ end
+ class MapCollection < ElementCollection
+   def element_class
+     Map
+   end
+ end
+ class Media < HTMLElement
+   attributes(:string => ([:error, :src, :current_src, :preload, :buffered, :played, :seekable, :tracks]), :float => ([:current_time, :initial_time, :duration, :default_playback_rate, :playback_rate, :volume]), :int => ([:network_state, :ready_state]), :bool => ([:seeking, :paused, :ended, :autoplay, :loop, :controls, :muted]), :date => ([:start_offset_time]))
+ end
+ class MediaCollection < ElementCollection
+   def element_class
+     Media
+   end
+ end
+ class Audio < Media
+   # do nothing
+ end
+ class AudioCollection < ElementCollection
+   def element_class
+     Audio
+   end
+ end
+ class Video < Media
+   attributes(:string => ([:width, :height, :poster]), :int => ([:video_width, :video_height]))
+ end
+ class VideoCollection < ElementCollection
+   def element_class
+     Video
+   end
+ end
+ class Source < HTMLElement
+   attributes(:string => ([:src, :type, :media]))
+ end
+ class SourceCollection < ElementCollection
+   def element_class
+     Source
+   end
+ end
+ class Param < HTMLElement
+   attributes(:string => ([:name, :value]))
+ end
+ class ParamCollection < ElementCollection
+   def element_class
+     Param
+   end
+ end
+ class Param < HTMLElement
+   attributes(:string => ([:type, :value_type]))
+ end
+ # do nothing
+ class Object < HTMLElement
+   attributes(:string => ([:data, :type, :name, :use_map, :width, :height, :content_window, :validity, :validation_message]), :html_element => ([:form]), :bool => ([:will_validate]), :document => ([:content_document]))
+ end
+ class ObjectCollection < ElementCollection
+   def element_class
+     Object
+   end
+ end
+ class Object < HTMLElement
+   attributes(:string => ([:align, :archive, :border, :code, :code_base, :code_type, :standby]), :int => ([:hspace, :vspace]), :bool => ([:declare]))
+ end
+ # do nothing
+ class IFrame < HTMLElement
+   attributes(:token_list => ([:sandbox]), :string => ([:src, :srcdoc, :name, :width, :height, :content_window]), :bool => ([:seamless]), :document => ([:content_document]))
+ end
+ class IFrameCollection < ElementCollection
+   def element_class
+     IFrame
+   end
+ end
+ class IFrame < HTMLElement
+   attributes(:string => ([:align, :frame_border, :long_desc, :margin_height, :margin_width, :scrolling]))
+ end
+ # do nothing
+ class Image < HTMLElement
+   attributes(:string => ([:alt, :src, :use_map]), :int => ([:width, :height, :natural_width, :natural_height]), :bool => ([:is_map, :complete]))
+ end
+ class ImageCollection < ElementCollection
+   def element_class
+     Image
+   end
+ end
+ class Image < HTMLElement
+   attributes(:string => ([:name, :align, :border, :long_desc]), :int => ([:hspace, :vspace]))
+ end
+ # do nothing
+ class Mod < HTMLElement
+   attributes(:string => ([:cite, :date_time]))
+ end
+ class ModCollection < ElementCollection
+   def element_class
+     Mod
+   end
+ end
+ class BR < HTMLElement
+   # do nothing
+ end
+ class BRCollection < ElementCollection
+   def element_class
+     BR
+   end
+ end
+ class BR < HTMLElement
+   attributes(:string => ([:clear]))
+ end
+ # do nothing
+ class Span < HTMLElement
+   # do nothing
+ end
+ class SpanCollection < ElementCollection
+   def element_class
+     Span
+   end
+ end
+ class Anchor < HTMLElement
+   attributes(:token_list => ([:rel_list]), :string => ([:href, :target, :ping, :rel, :media, :hreflang, :type, :text, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
+ end
+ class AnchorCollection < ElementCollection
+   def element_class
+     Anchor
+   end
+ end
+ class Anchor < HTMLElement
+   attributes(:string => ([:coords, :charset, :name, :rev, :shape]))
+ end
+ # do nothing
+ class DList < HTMLElement
+   # do nothing
+ end
+ class DListCollection < ElementCollection
+   def element_class
+     DList
+   end
+ end
+ class DList < HTMLElement
+   attributes(:bool => ([:compact]))
+ end
+ # do nothing
+ class LI < HTMLElement
+   attributes(:int => ([:value]))
+ end
+ class LICollection < ElementCollection
+   def element_class
+     LI
+   end
+ end
+ class LI < HTMLElement
+   attributes(:string => ([:type]))
+ end
+ # do nothing
+ class Pre < HTMLElement
+   # do nothing
+ end
+ class PreCollection < ElementCollection
+   def element_class
+     Pre
+   end
+ end
+ class Pre < HTMLElement
+   attributes(:int => ([:width]))
+ end
+ # do nothing
+ class HR < HTMLElement
+   # do nothing
+ end
+ class HRCollection < ElementCollection
+   def element_class
+     HR
+   end
+ end
+ class HR < HTMLElement
+   attributes(:string => ([:align, :color, :size, :width]), :bool => ([:no_shade]))
+ end
+ # do nothing
+ class Paragraph < HTMLElement
+   # do nothing
+ end
+ class ParagraphCollection < ElementCollection
+   def element_class
+     Paragraph
+   end
+ end
+ class Paragraph < HTMLElement
+   attributes(:string => ([:align]))
+ end
+ # do nothing
+ class Heading < HTMLElement
+   # do nothing
+ end
+ class HeadingCollection < ElementCollection
+   def element_class
+     Heading
+   end
+ end
+ class Heading < HTMLElement
+   attributes(:string => ([:align]))
+ end
+ # do nothing
+ class Body < HTMLElement
+   attributes(:function => ([:onafterprint, :onbeforeprint, :onbeforeunload, :onblur, :onerror, :onfocus, :onhashchange, :onload, :onmessage, :onoffline, :ononline, :onpopstate, :onpagehide, :onpageshow, :onredo, :onresize, :onstorage, :onundo, :onunload]))
+ end
+ class BodyCollection < ElementCollection
+   def element_class
+     Body
+   end
+ end
+ class Body < HTMLElement
+   attributes(:string => ([:text, :bg_color, :background, :link, :v_link, :a_link]))
+ end
+ # do nothing
+ class Script < HTMLElement
+   attributes(:string => ([:src, :type, :charset, :text]), :bool => ([:async, :defer]))
+ end
+ class ScriptCollection < ElementCollection
+   def element_class
+     Script
+   end
+ end
+ class Script < HTMLElement
+   attributes(:string => ([:event, :html_for]))
+ end
+ # do nothing
+ class Style < HTMLElement
+   attributes(:string => ([:media, :type]), :bool => ([:disabled, :scoped]))
+ end
+ class StyleCollection < ElementCollection
+   def element_class
+     Style
+   end
+ end
+ class Meta < HTMLElement
+   attributes(:string => ([:name, :http_equiv, :content]))
+ end
+ class MetaCollection < ElementCollection
+   def element_class
+     Meta
+   end
+ end
+ class Meta < HTMLElement
+   attributes(:string => ([:scheme]))
+ end
+ # do nothing
+ class Base < HTMLElement
+   attributes(:string => ([:href, :target]))
+ end
+ class BaseCollection < ElementCollection
+   def element_class
+     Base
+   end
+ end
+ class Head < HTMLElement
+   # do nothing
+ end
+ class HeadCollection < ElementCollection
+   def element_class
+     Head
+   end
+ end
+
+ class Time < HTMLElement
+   attributes(:string => ([:date_time]), :bool => ([:pub_date]), :date => ([:value_as_date]))
+ end
+ class TimeCollection < ElementCollection
+   def element_class
+     Time
+   end
+ end
+
+
+
+
+ class Marquee < HTMLElement
+   attributes(:string => ([:behavior, :bg_color, :direction, :height, :true_speed, :width]), :int => ([:hspace, :loop, :scroll_amount, :scroll_delay, :vspace]), :function => ([:onbounce, :onfinish, :onstart]))
+ end
+ class MarqueeCollection < ElementCollection
+   def element_class
+     Marquee
+   end
+ end
+ class Font < HTMLElement
+   attributes(:string => ([:color, :face, :size]))
+ end
+ class FontCollection < ElementCollection
+   def element_class
+     Font
+   end
+ end
+ class TableCaption < HTMLElement
+   # do nothing
+ end
+ class TableCaptionCollection < ElementCollection
+   def element_class
+     TableCaption
+   end
+ end
+ class TableCaption < HTMLElement
+   attributes(:string => ([:align]))
+ end
+ # do nothing
+
+
+
+
+
+
+ class Select < HTMLElement
+   attributes(:string => ([:name, :type, :value, :validity, :validation_message]), :int => ([:size, :length, :selected_index]), :list => ([:labels]), :html_element => ([:form]), :html_collection => ([:options, :selected_options]), :bool => ([:autofocus, :disabled, :multiple, :required, :will_validate]))
+ end
+ class SelectCollection < ElementCollection
+   def element_class
+     Select
+   end
+ end
+ class UList < HTMLElement
+   # do nothing
+ end
+ class UListCollection < ElementCollection
+   def element_class
+     UList
+   end
+ end
+ class UList < HTMLElement
+   attributes(:string => ([:type]), :bool => ([:compact]))
+ end
+ # do nothing
+
+ class OptGroup < HTMLElement
+   attributes(:string => ([:label]), :bool => ([:disabled]))
+ end
+ class OptGroupCollection < ElementCollection
+   def element_class
+     OptGroup
+   end
+ end
+ class Canvas < HTMLElement
+   attributes(:int => ([:width, :height]))
+ end
+ class CanvasCollection < ElementCollection
+   def element_class
+     Canvas
+   end
+ end
+ class TableCell < HTMLElement
+   attributes(:token_list => ([:headers]), :int => ([:col_span, :row_span, :cell_index]))
+ end
+ class TableCellCollection < ElementCollection
+   def element_class
+     TableCell
+   end
+ end
+ class TableCell < HTMLElement
+   attributes(:string => ([:abbr, :align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width]), :bool => ([:no_wrap]))
+ end
+ # do nothing
+ class TableHeaderCell < TableCell
+   attributes(:string => ([:scope]))
+ end
+ class TableHeaderCellCollection < ElementCollection
+   def element_class
+     TableHeaderCell
+   end
+ end
+ class TableDataCell < TableCell
+   # do nothing
+ end
+ class TableDataCellCollection < ElementCollection
+   def element_class
+     TableDataCell
+   end
+ end
+ class Quote < HTMLElement
+   attributes(:string => ([:cite]))
+ end
+ class QuoteCollection < ElementCollection
+   def element_class
+     Quote
+   end
+ end
+ class Div < HTMLElement
+   # do nothing
+ end
+ class DivCollection < ElementCollection
+   def element_class
+     Div
+   end
+ end
+ class Div < HTMLElement
+   attributes(:string => ([:align]))
+ end
+ # do nothing
+
+ class Device < HTMLElement
+   attributes(:string => ([:type, :data]))
+ end
+ class DeviceCollection < ElementCollection
+   def element_class
+     Device
+   end
+ end
+
+
+ class Output < HTMLElement
+   attributes(:token_list => ([:html_for]), :string => ([:name, :type, :default_value, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:will_validate]))
+ end
+ class OutputCollection < ElementCollection
+   def element_class
+     Output
+   end
+ end
+ class Track < HTMLElement
+   attributes(:string => ([:kind, :label, :src, :srclang, :track]))
+ end
+ class TrackCollection < ElementCollection
+   def element_class
+     Track
+   end
+ end
+
+
+ class Embed < HTMLElement
+   attributes(:string => ([:src, :type, :width, :height]))
+ end
+ class EmbedCollection < ElementCollection
+   def element_class
+     Embed
+   end
+ end
+ class Embed < HTMLElement
+   attributes(:string => ([:align, :name]))
+ end
+ # do nothing
+
+
+
+ class Area < HTMLElement
+   attributes(:token_list => ([:rel_list]), :string => ([:alt, :coords, :shape, :href, :target, :ping, :rel, :media, :hreflang, :type, :protocol, :host, :hostname, :port, :pathname, :search, :hash]))
+ end
+ class AreaCollection < ElementCollection
+   def element_class
+     Area
+   end
+ end
+ class Area < HTMLElement
+   attributes(:bool => ([:no_href]))
+ end
+ # do nothing
+
+ class OList < HTMLElement
+   attributes(:int => ([:start]), :bool => ([:reversed]))
+ end
+ class OListCollection < ElementCollection
+   def element_class
+     OList
+   end
+ end
+ class OList < HTMLElement
+   attributes(:string => ([:type]), :bool => ([:compact]))
+ end
+ # do nothing
+
+ class Unknown < HTMLElement
+   # do nothing
+ end
+ class UnknownCollection < ElementCollection
+   def element_class
+     Unknown
+   end
+ end
+ class Button < HTMLElement
+   attributes(:string => ([:form_action, :form_enctype, :form_method, :form_no_validate, :form_target, :name, :type, :value, :validity, :validation_message]), :list => ([:labels]), :html_element => ([:form]), :bool => ([:autofocus, :disabled, :will_validate]))
+ end
+ class ButtonCollection < ElementCollection
+   def element_class
+     Button
+   end
+ end
+ class Html < HTMLElement
+   # do nothing
+ end
+ class HtmlCollection < ElementCollection
+   def element_class
+     Html
+   end
+ end
+ class Html < HTMLElement
+   attributes(:string => ([:version]))
+ end
+ # do nothing
+ class Title < HTMLElement
+   attributes(:string => ([:text]))
+ end
+ class TitleCollection < ElementCollection
+   def element_class
+     Title
+   end
+ end
+ class FieldSet < HTMLElement
+   attributes(:string => ([:name, :type, :validity, :validation_message]), :html_element => ([:form]), :html_collection => ([:elements]), :bool => ([:disabled, :will_validate]))
+ end
+ class FieldSetCollection < ElementCollection
+   def element_class
+     FieldSet
+   end
+ end
+ class Details < HTMLElement
+   attributes(:bool => ([:open]))
+ end
+ class DetailsCollection < ElementCollection
+   def element_class
+     Details
+   end
+ end
+
+
+ class BaseFont < HTMLElement
+   attributes(:string => ([:color, :face]), :int => ([:size]))
+ end
+ class BaseFontCollection < ElementCollection
+   def element_class
+     BaseFont
+   end
+ end
+ module Container
+   #
+   # @return [Anchor]
+   #
+   
+   def a(*args)
+     Anchor.new(self, extract_selector(args).merge(:tag_name => "a"))
+   end
+   
+   #
+   # @return [AnchorCollection]
+   #
+   
+   def as(*args)
+     AnchorCollection.new(self, extract_selector(args).merge(:tag_name => "a"))
+   end
+   
+   Watir.tag_to_class[:a] = Anchor
+   #
+   # @return [HTMLElement]
+   #
+   
+   def abbr(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "abbr"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def abbrs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "abbr"))
+   end
+   
+   Watir.tag_to_class[:abbr] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def address(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "address"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def addresses(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "address"))
+   end
+   
+   Watir.tag_to_class[:address] = HTMLElement
+   #
+   # @return [Area]
+   #
+   
+   def area(*args)
+     Area.new(self, extract_selector(args).merge(:tag_name => "area"))
+   end
+   
+   #
+   # @return [AreaCollection]
+   #
+   
+   def areas(*args)
+     AreaCollection.new(self, extract_selector(args).merge(:tag_name => "area"))
+   end
+   
+   Watir.tag_to_class[:area] = Area
+   #
+   # @return [HTMLElement]
+   #
+   
+   def article(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "article"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def articles(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "article"))
+   end
+   
+   Watir.tag_to_class[:article] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def aside(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "aside"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def asides(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "aside"))
+   end
+   
+   Watir.tag_to_class[:aside] = HTMLElement
+   #
+   # @return [Audio]
+   #
+   
+   def audio(*args)
+     Audio.new(self, extract_selector(args).merge(:tag_name => "audio"))
+   end
+   
+   #
+   # @return [AudioCollection]
+   #
+   
+   def audios(*args)
+     AudioCollection.new(self, extract_selector(args).merge(:tag_name => "audio"))
+   end
+   
+   Watir.tag_to_class[:audio] = Audio
+   #
+   # @return [HTMLElement]
+   #
+   
+   def b(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "b"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def bs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "b"))
+   end
+   
+   Watir.tag_to_class[:b] = HTMLElement
+   #
+   # @return [Base]
+   #
+   
+   def base(*args)
+     Base.new(self, extract_selector(args).merge(:tag_name => "base"))
+   end
+   
+   #
+   # @return [BaseCollection]
+   #
+   
+   def bases(*args)
+     BaseCollection.new(self, extract_selector(args).merge(:tag_name => "base"))
+   end
+   
+   Watir.tag_to_class[:base] = Base
+   #
+   # @return [HTMLElement]
+   #
+   
+   def bdo(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdo"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def bdos(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "bdo"))
+   end
+   
+   Watir.tag_to_class[:bdo] = HTMLElement
+   #
+   # @return [Quote]
+   #
+   
+   def blockquote(*args)
+     Quote.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
+   end
+   
+   #
+   # @return [QuoteCollection]
+   #
+   
+   def blockquotes(*args)
+     QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
+   end
+   
+   Watir.tag_to_class[:blockquote] = Quote
+   #
+   # @return [Body]
+   #
+   
+   def body(*args)
+     Body.new(self, extract_selector(args).merge(:tag_name => "body"))
+   end
+   
+   #
+   # @return [BodyCollection]
+   #
+   
+   def bodys(*args)
+     BodyCollection.new(self, extract_selector(args).merge(:tag_name => "body"))
+   end
+   
+   Watir.tag_to_class[:body] = Body
+   #
+   # @return [BR]
+   #
+   
+   def br(*args)
+     BR.new(self, extract_selector(args).merge(:tag_name => "br"))
+   end
+   
+   #
+   # @return [BRCollection]
+   #
+   
+   def brs(*args)
+     BRCollection.new(self, extract_selector(args).merge(:tag_name => "br"))
+   end
+   
+   Watir.tag_to_class[:br] = BR
+   #
+   # @return [Button]
+   #
+   
+   def button(*args)
+     Button.new(self, extract_selector(args).merge(:tag_name => "button"))
+   end
+   
+   #
+   # @return [ButtonCollection]
+   #
+   
+   def buttons(*args)
+     ButtonCollection.new(self, extract_selector(args).merge(:tag_name => "button"))
+   end
+   
+   Watir.tag_to_class[:button] = Button
+   #
+   # @return [Canvas]
+   #
+   
+   def canvas(*args)
+     Canvas.new(self, extract_selector(args).merge(:tag_name => "canvas"))
+   end
+   
+   #
+   # @return [CanvasCollection]
+   #
+   
+   def canvases(*args)
+     CanvasCollection.new(self, extract_selector(args).merge(:tag_name => "canvas"))
+   end
+   
+   Watir.tag_to_class[:canvas] = Canvas
+   #
+   # @return [TableCaption]
+   #
+   
+   def caption(*args)
+     TableCaption.new(self, extract_selector(args).merge(:tag_name => "caption"))
+   end
+   
+   #
+   # @return [TableCaptionCollection]
+   #
+   
+   def captions(*args)
+     TableCaptionCollection.new(self, extract_selector(args).merge(:tag_name => "caption"))
+   end
+   
+   Watir.tag_to_class[:caption] = TableCaption
+   #
+   # @return [HTMLElement]
+   #
+   
+   def cite(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "cite"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def cites(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "cite"))
+   end
+   
+   Watir.tag_to_class[:cite] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def code(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "code"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def codes(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "code"))
+   end
+   
+   Watir.tag_to_class[:code] = HTMLElement
+   #
+   # @return [TableCol]
+   #
+   
+   def col(*args)
+     TableCol.new(self, extract_selector(args).merge(:tag_name => "col"))
+   end
+   
+   #
+   # @return [TableColCollection]
+   #
+   
+   def cols(*args)
+     TableColCollection.new(self, extract_selector(args).merge(:tag_name => "col"))
+   end
+   
+   Watir.tag_to_class[:col] = TableCol
+   #
+   # @return [TableCol]
+   #
+   
+   def colgroup(*args)
+     TableCol.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
+   end
+   
+   #
+   # @return [TableColCollection]
+   #
+   
+   def colgroups(*args)
+     TableColCollection.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
+   end
+   
+   Watir.tag_to_class[:colgroup] = TableCol
+   #
+   # @return [Command]
+   #
+   
+   def command(*args)
+     Command.new(self, extract_selector(args).merge(:tag_name => "command"))
+   end
+   
+   #
+   # @return [CommandCollection]
+   #
+   
+   def commands(*args)
+     CommandCollection.new(self, extract_selector(args).merge(:tag_name => "command"))
+   end
+   
+   Watir.tag_to_class[:command] = Command
+   #
+   # @return [DataList]
+   #
+   
+   def datalist(*args)
+     DataList.new(self, extract_selector(args).merge(:tag_name => "datalist"))
+   end
+   
+   #
+   # @return [DataListCollection]
+   #
+   
+   def datalists(*args)
+     DataListCollection.new(self, extract_selector(args).merge(:tag_name => "datalist"))
+   end
+   
+   Watir.tag_to_class[:datalist] = DataList
+   #
+   # @return [HTMLElement]
+   #
+   
+   def dd(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dd"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def dds(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dd"))
+   end
+   
+   Watir.tag_to_class[:dd] = HTMLElement
+   #
+   # @return [Mod]
+   #
+   
+   def del(*args)
+     Mod.new(self, extract_selector(args).merge(:tag_name => "del"))
+   end
+   
+   #
+   # @return [ModCollection]
+   #
+   
+   def dels(*args)
+     ModCollection.new(self, extract_selector(args).merge(:tag_name => "del"))
+   end
+   
+   Watir.tag_to_class[:del] = Mod
+   #
+   # @return [Details]
+   #
+   
+   def details(*args)
+     Details.new(self, extract_selector(args).merge(:tag_name => "details"))
+   end
+   
+   #
+   # @return [DetailsCollection]
+   #
+   
+   def details(*args)
+     DetailsCollection.new(self, extract_selector(args).merge(:tag_name => "details"))
+   end
+   
+   Watir.tag_to_class[:details] = Details
+   #
+   # @return [HTMLElement]
+   #
+   
+   def dfn(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dfn"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def dfns(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dfn"))
+   end
+   
+   Watir.tag_to_class[:dfn] = HTMLElement
+   #
+   # @return [Div]
+   #
+   
+   def div(*args)
+     Div.new(self, extract_selector(args).merge(:tag_name => "div"))
+   end
+   
+   #
+   # @return [DivCollection]
+   #
+   
+   def divs(*args)
+     DivCollection.new(self, extract_selector(args).merge(:tag_name => "div"))
+   end
+   
+   Watir.tag_to_class[:div] = Div
+   #
+   # @return [DList]
+   #
+   
+   def dl(*args)
+     DList.new(self, extract_selector(args).merge(:tag_name => "dl"))
+   end
+   
+   #
+   # @return [DListCollection]
+   #
+   
+   def dls(*args)
+     DListCollection.new(self, extract_selector(args).merge(:tag_name => "dl"))
+   end
+   
+   Watir.tag_to_class[:dl] = DList
+   #
+   # @return [HTMLElement]
+   #
+   
+   def dt(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dt"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def dts(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dt"))
+   end
+   
+   Watir.tag_to_class[:dt] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def em(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "em"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def ems(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "em"))
+   end
+   
+   Watir.tag_to_class[:em] = HTMLElement
+   #
+   # @return [Embed]
+   #
+   
+   def embed(*args)
+     Embed.new(self, extract_selector(args).merge(:tag_name => "embed"))
+   end
+   
+   #
+   # @return [EmbedCollection]
+   #
+   
+   def embeds(*args)
+     EmbedCollection.new(self, extract_selector(args).merge(:tag_name => "embed"))
+   end
+   
+   Watir.tag_to_class[:embed] = Embed
+   #
+   # @return [FieldSet]
+   #
+   
+   def fieldset(*args)
+     FieldSet.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
+   end
+   
+   #
+   # @return [FieldSetCollection]
+   #
+   
+   def fieldsets(*args)
+     FieldSetCollection.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
+   end
+   
+   Watir.tag_to_class[:fieldset] = FieldSet
+   #
+   # @return [HTMLElement]
+   #
+   
+   def figcaption(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def figcaptions(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
+   end
+   
+   Watir.tag_to_class[:figcaption] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def figure(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figure"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def figures(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figure"))
+   end
+   
+   Watir.tag_to_class[:figure] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def footer(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "footer"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def footers(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "footer"))
+   end
+   
+   Watir.tag_to_class[:footer] = HTMLElement
+   #
+   # @return [Form]
+   #
+   
+   def form(*args)
+     Form.new(self, extract_selector(args).merge(:tag_name => "form"))
+   end
+   
+   #
+   # @return [FormCollection]
+   #
+   
+   def forms(*args)
+     FormCollection.new(self, extract_selector(args).merge(:tag_name => "form"))
+   end
+   
+   Watir.tag_to_class[:form] = Form
+   #
+   # @return [Heading]
+   #
+   
+   def h1(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h1"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h1s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h1"))
+   end
+   
+   Watir.tag_to_class[:h1] = Heading
+   #
+   # @return [Heading]
+   #
+   
+   def h2(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h2"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h2s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h2"))
+   end
+   
+   Watir.tag_to_class[:h2] = Heading
+   #
+   # @return [Heading]
+   #
+   
+   def h3(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h3"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h3s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h3"))
+   end
+   
+   Watir.tag_to_class[:h3] = Heading
+   #
+   # @return [Heading]
+   #
+   
+   def h4(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h4"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h4s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h4"))
+   end
+   
+   Watir.tag_to_class[:h4] = Heading
+   #
+   # @return [Heading]
+   #
+   
+   def h5(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h5"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h5s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h5"))
+   end
+   
+   Watir.tag_to_class[:h5] = Heading
+   #
+   # @return [Heading]
+   #
+   
+   def h6(*args)
+     Heading.new(self, extract_selector(args).merge(:tag_name => "h6"))
+   end
+   
+   #
+   # @return [HeadingCollection]
+   #
+   
+   def h6s(*args)
+     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h6"))
+   end
+   
+   Watir.tag_to_class[:h6] = Heading
+   #
+   # @return [Head]
+   #
+   
+   def head(*args)
+     Head.new(self, extract_selector(args).merge(:tag_name => "head"))
+   end
+   
+   #
+   # @return [HeadCollection]
+   #
+   
+   def heads(*args)
+     HeadCollection.new(self, extract_selector(args).merge(:tag_name => "head"))
+   end
+   
+   Watir.tag_to_class[:head] = Head
+   #
+   # @return [HTMLElement]
+   #
+   
+   def header(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "header"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def headers(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "header"))
+   end
+   
+   Watir.tag_to_class[:header] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def hgroup(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def hgroups(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
+   end
+   
+   Watir.tag_to_class[:hgroup] = HTMLElement
+   #
+   # @return [HR]
+   #
+   
+   def hr(*args)
+     HR.new(self, extract_selector(args).merge(:tag_name => "hr"))
+   end
+   
+   #
+   # @return [HRCollection]
+   #
+   
+   def hrs(*args)
+     HRCollection.new(self, extract_selector(args).merge(:tag_name => "hr"))
+   end
+   
+   Watir.tag_to_class[:hr] = HR
+   #
+   # @return [Html]
+   #
+   
+   def html(*args)
+     Html.new(self, extract_selector(args).merge(:tag_name => "html"))
+   end
+   
+   #
+   # @return [HtmlCollection]
+   #
+   
+   def htmls(*args)
+     HtmlCollection.new(self, extract_selector(args).merge(:tag_name => "html"))
+   end
+   
+   Watir.tag_to_class[:html] = Html
+   #
+   # @return [HTMLElement]
+   #
+   
+   def i(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "i"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def is(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "i"))
+   end
+   
+   Watir.tag_to_class[:i] = HTMLElement
+   #
+   # @return [IFrame]
+   #
+   
+   def iframe(*args)
+     IFrame.new(self, extract_selector(args).merge(:tag_name => "iframe"))
+   end
+   
+   #
+   # @return [IFrameCollection]
+   #
+   
+   def iframes(*args)
+     IFrameCollection.new(self, extract_selector(args).merge(:tag_name => "iframe"))
+   end
+   
+   Watir.tag_to_class[:iframe] = IFrame
+   #
+   # @return [Image]
+   #
+   
+   def image(*args)
+     Image.new(self, extract_selector(args).merge(:tag_name => "img"))
+   end
+   
+   #
+   # @return [ImageCollection]
+   #
+   
+   def images(*args)
+     ImageCollection.new(self, extract_selector(args).merge(:tag_name => "img"))
+   end
+   
+   Watir.tag_to_class[:img] = Image
+   #
+   # @return [Input]
+   #
+   
+   def input(*args)
+     Input.new(self, extract_selector(args).merge(:tag_name => "input"))
+   end
+   
+   #
+   # @return [InputCollection]
+   #
+   
+   def inputs(*args)
+     InputCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
+   end
+   
+   Watir.tag_to_class[:input] = Input
+   #
+   # @return [Mod]
+   #
+   
+   def ins(*args)
+     Mod.new(self, extract_selector(args).merge(:tag_name => "ins"))
+   end
+   
+   #
+   # @return [ModCollection]
+   #
+   
+   def inses(*args)
+     ModCollection.new(self, extract_selector(args).merge(:tag_name => "ins"))
+   end
+   
+   Watir.tag_to_class[:ins] = Mod
+   #
+   # @return [HTMLElement]
+   #
+   
+   def kbd(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "kbd"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def kbds(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "kbd"))
+   end
+   
+   Watir.tag_to_class[:kbd] = HTMLElement
+   #
+   # @return [Keygen]
+   #
+   
+   def keygen(*args)
+     Keygen.new(self, extract_selector(args).merge(:tag_name => "keygen"))
+   end
+   
+   #
+   # @return [KeygenCollection]
+   #
+   
+   def keygens(*args)
+     KeygenCollection.new(self, extract_selector(args).merge(:tag_name => "keygen"))
+   end
+   
+   Watir.tag_to_class[:keygen] = Keygen
+   #
+   # @return [Label]
+   #
+   
+   def label(*args)
+     Label.new(self, extract_selector(args).merge(:tag_name => "label"))
+   end
+   
+   #
+   # @return [LabelCollection]
+   #
+   
+   def labels(*args)
+     LabelCollection.new(self, extract_selector(args).merge(:tag_name => "label"))
+   end
+   
+   Watir.tag_to_class[:label] = Label
+   #
+   # @return [Legend]
+   #
+   
+   def legend(*args)
+     Legend.new(self, extract_selector(args).merge(:tag_name => "legend"))
+   end
+   
+   #
+   # @return [LegendCollection]
+   #
+   
+   def legends(*args)
+     LegendCollection.new(self, extract_selector(args).merge(:tag_name => "legend"))
+   end
+   
+   Watir.tag_to_class[:legend] = Legend
+   #
+   # @return [LI]
+   #
+   
+   def li(*args)
+     LI.new(self, extract_selector(args).merge(:tag_name => "li"))
+   end
+   
+   #
+   # @return [LICollection]
+   #
+   
+   def lis(*args)
+     LICollection.new(self, extract_selector(args).merge(:tag_name => "li"))
+   end
+   
+   Watir.tag_to_class[:li] = LI
+   #
+   # @return [Map]
+   #
+   
+   def map(*args)
+     Map.new(self, extract_selector(args).merge(:tag_name => "map"))
+   end
+   
+   #
+   # @return [MapCollection]
+   #
+   
+   def maps(*args)
+     MapCollection.new(self, extract_selector(args).merge(:tag_name => "map"))
+   end
+   
+   Watir.tag_to_class[:map] = Map
+   #
+   # @return [HTMLElement]
+   #
+   
+   def mark(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "mark"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def marks(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "mark"))
+   end
+   
+   Watir.tag_to_class[:mark] = HTMLElement
+   #
+   # @return [Menu]
+   #
+   
+   def menu(*args)
+     Menu.new(self, extract_selector(args).merge(:tag_name => "menu"))
+   end
+   
+   #
+   # @return [MenuCollection]
+   #
+   
+   def menus(*args)
+     MenuCollection.new(self, extract_selector(args).merge(:tag_name => "menu"))
+   end
+   
+   Watir.tag_to_class[:menu] = Menu
+   #
+   # @return [Meta]
+   #
+   
+   def meta(*args)
+     Meta.new(self, extract_selector(args).merge(:tag_name => "meta"))
+   end
+   
+   #
+   # @return [MetaCollection]
+   #
+   
+   def metas(*args)
+     MetaCollection.new(self, extract_selector(args).merge(:tag_name => "meta"))
+   end
+   
+   Watir.tag_to_class[:meta] = Meta
+   #
+   # @return [Meter]
+   #
+   
+   def meter(*args)
+     Meter.new(self, extract_selector(args).merge(:tag_name => "meter"))
+   end
+   
+   #
+   # @return [MeterCollection]
+   #
+   
+   def meters(*args)
+     MeterCollection.new(self, extract_selector(args).merge(:tag_name => "meter"))
+   end
+   
+   Watir.tag_to_class[:meter] = Meter
+   #
+   # @return [HTMLElement]
+   #
+   
+   def nav(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "nav"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def navs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "nav"))
+   end
+   
+   Watir.tag_to_class[:nav] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def noscript(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "noscript"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def noscripts(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "noscript"))
+   end
+   
+   Watir.tag_to_class[:noscript] = HTMLElement
+   #
+   # @return [Object]
+   #
+   
+   def object(*args)
+     Object.new(self, extract_selector(args).merge(:tag_name => "object"))
+   end
+   
+   #
+   # @return [ObjectCollection]
+   #
+   
+   def objects(*args)
+     ObjectCollection.new(self, extract_selector(args).merge(:tag_name => "object"))
+   end
+   
+   Watir.tag_to_class[:object] = Object
+   #
+   # @return [OList]
+   #
+   
+   def ol(*args)
+     OList.new(self, extract_selector(args).merge(:tag_name => "ol"))
+   end
+   
+   #
+   # @return [OListCollection]
+   #
+   
+   def ols(*args)
+     OListCollection.new(self, extract_selector(args).merge(:tag_name => "ol"))
+   end
+   
+   Watir.tag_to_class[:ol] = OList
+   #
+   # @return [OptGroup]
+   #
+   
+   def optgroup(*args)
+     OptGroup.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
+   end
+   
+   #
+   # @return [OptGroupCollection]
+   #
+   
+   def optgroups(*args)
+     OptGroupCollection.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
+   end
+   
+   Watir.tag_to_class[:optgroup] = OptGroup
+   #
+   # @return [Option]
+   #
+   
+   def option(*args)
+     Option.new(self, extract_selector(args).merge(:tag_name => "option"))
+   end
+   
+   #
+   # @return [OptionCollection]
+   #
+   
+   def options(*args)
+     OptionCollection.new(self, extract_selector(args).merge(:tag_name => "option"))
+   end
+   
+   Watir.tag_to_class[:option] = Option
+   #
+   # @return [Output]
+   #
+   
+   def output(*args)
+     Output.new(self, extract_selector(args).merge(:tag_name => "output"))
+   end
+   
+   #
+   # @return [OutputCollection]
+   #
+   
+   def outputs(*args)
+     OutputCollection.new(self, extract_selector(args).merge(:tag_name => "output"))
+   end
+   
+   Watir.tag_to_class[:output] = Output
+   #
+   # @return [Paragraph]
+   #
+   
+   def p(*args)
+     Paragraph.new(self, extract_selector(args).merge(:tag_name => "p"))
+   end
+   
+   #
+   # @return [ParagraphCollection]
+   #
+   
+   def ps(*args)
+     ParagraphCollection.new(self, extract_selector(args).merge(:tag_name => "p"))
+   end
+   
+   Watir.tag_to_class[:p] = Paragraph
+   #
+   # @return [Param]
+   #
+   
+   def param(*args)
+     Param.new(self, extract_selector(args).merge(:tag_name => "param"))
+   end
+   
+   #
+   # @return [ParamCollection]
+   #
+   
+   def params(*args)
+     ParamCollection.new(self, extract_selector(args).merge(:tag_name => "param"))
+   end
+   
+   Watir.tag_to_class[:param] = Param
+   #
+   # @return [Pre]
+   #
+   
+   def pre(*args)
+     Pre.new(self, extract_selector(args).merge(:tag_name => "pre"))
+   end
+   
+   #
+   # @return [PreCollection]
+   #
+   
+   def pres(*args)
+     PreCollection.new(self, extract_selector(args).merge(:tag_name => "pre"))
+   end
+   
+   Watir.tag_to_class[:pre] = Pre
+   #
+   # @return [Progress]
+   #
+   
+   def progress(*args)
+     Progress.new(self, extract_selector(args).merge(:tag_name => "progress"))
+   end
+   
+   #
+   # @return [ProgressCollection]
+   #
+   
+   def progresses(*args)
+     ProgressCollection.new(self, extract_selector(args).merge(:tag_name => "progress"))
+   end
+   
+   Watir.tag_to_class[:progress] = Progress
+   #
+   # @return [Quote]
+   #
+   
+   def q(*args)
+     Quote.new(self, extract_selector(args).merge(:tag_name => "q"))
+   end
+   
+   #
+   # @return [QuoteCollection]
+   #
+   
+   def qs(*args)
+     QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "q"))
+   end
+   
+   Watir.tag_to_class[:q] = Quote
+   #
+   # @return [HTMLElement]
+   #
+   
+   def rp(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rp"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def rps(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rp"))
+   end
+   
+   Watir.tag_to_class[:rp] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def rt(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rt"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def rts(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rt"))
+   end
+   
+   Watir.tag_to_class[:rt] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def ruby(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "ruby"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def rubies(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "ruby"))
+   end
+   
+   Watir.tag_to_class[:ruby] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def samp(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "samp"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def samps(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "samp"))
+   end
+   
+   Watir.tag_to_class[:samp] = HTMLElement
+   #
+   # @return [Script]
+   #
+   
+   def script(*args)
+     Script.new(self, extract_selector(args).merge(:tag_name => "script"))
+   end
+   
+   #
+   # @return [ScriptCollection]
+   #
+   
+   def scripts(*args)
+     ScriptCollection.new(self, extract_selector(args).merge(:tag_name => "script"))
+   end
+   
+   Watir.tag_to_class[:script] = Script
+   #
+   # @return [HTMLElement]
+   #
+   
+   def section(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "section"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def sections(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "section"))
+   end
+   
+   Watir.tag_to_class[:section] = HTMLElement
+   #
+   # @return [Select]
+   #
+   
+   def select(*args)
+     Select.new(self, extract_selector(args).merge(:tag_name => "select"))
+   end
+   
+   #
+   # @return [SelectCollection]
+   #
+   
+   def selects(*args)
+     SelectCollection.new(self, extract_selector(args).merge(:tag_name => "select"))
+   end
+   
+   Watir.tag_to_class[:select] = Select
+   #
+   # @return [HTMLElement]
+   #
+   
+   def small(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "small"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def smalls(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "small"))
+   end
+   
+   Watir.tag_to_class[:small] = HTMLElement
+   #
+   # @return [Source]
+   #
+   
+   def source(*args)
+     Source.new(self, extract_selector(args).merge(:tag_name => "source"))
+   end
+   
+   #
+   # @return [SourceCollection]
+   #
+   
+   def sources(*args)
+     SourceCollection.new(self, extract_selector(args).merge(:tag_name => "source"))
+   end
+   
+   Watir.tag_to_class[:source] = Source
+   #
+   # @return [Span]
+   #
+   
+   def span(*args)
+     Span.new(self, extract_selector(args).merge(:tag_name => "span"))
+   end
+   
+   #
+   # @return [SpanCollection]
+   #
+   
+   def spans(*args)
+     SpanCollection.new(self, extract_selector(args).merge(:tag_name => "span"))
+   end
+   
+   Watir.tag_to_class[:span] = Span
+   #
+   # @return [HTMLElement]
+   #
+   
+   def strong(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "strong"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def strongs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "strong"))
+   end
+   
+   Watir.tag_to_class[:strong] = HTMLElement
+   #
+   # @return [Style]
+   #
+   
+   def style(*args)
+     Style.new(self, extract_selector(args).merge(:tag_name => "style"))
+   end
+   
+   #
+   # @return [StyleCollection]
+   #
+   
+   def styles(*args)
+     StyleCollection.new(self, extract_selector(args).merge(:tag_name => "style"))
+   end
+   
+   Watir.tag_to_class[:style] = Style
+   #
+   # @return [HTMLElement]
+   #
+   
+   def sub(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sub"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def subs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sub"))
+   end
+   
+   Watir.tag_to_class[:sub] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def summary(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "summary"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def summaries(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "summary"))
+   end
+   
+   Watir.tag_to_class[:summary] = HTMLElement
+   #
+   # @return [HTMLElement]
+   #
+   
+   def sup(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sup"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def sups(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sup"))
+   end
+   
+   Watir.tag_to_class[:sup] = HTMLElement
+   #
+   # @return [Table]
+   #
+   
+   def table(*args)
+     Table.new(self, extract_selector(args).merge(:tag_name => "table"))
+   end
+   
+   #
+   # @return [TableCollection]
+   #
+   
+   def tables(*args)
+     TableCollection.new(self, extract_selector(args).merge(:tag_name => "table"))
+   end
+   
+   Watir.tag_to_class[:table] = Table
+   #
+   # @return [TableSection]
+   #
+   
+   def tbody(*args)
+     TableSection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
+   end
+   
+   #
+   # @return [TableSectionCollection]
+   #
+   
+   def tbodys(*args)
+     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
+   end
+   
+   Watir.tag_to_class[:tbody] = TableSection
+   #
+   # @return [TableDataCell]
+   #
+   
+   def td(*args)
+     TableDataCell.new(self, extract_selector(args).merge(:tag_name => "td"))
+   end
+   
+   #
+   # @return [TableDataCellCollection]
+   #
+   
+   def tds(*args)
+     TableDataCellCollection.new(self, extract_selector(args).merge(:tag_name => "td"))
+   end
+   
+   Watir.tag_to_class[:td] = TableDataCell
+   #
+   # @return [TextArea]
+   #
+   
+   def textarea(*args)
+     TextArea.new(self, extract_selector(args).merge(:tag_name => "textarea"))
+   end
+   
+   #
+   # @return [TextAreaCollection]
+   #
+   
+   def textareas(*args)
+     TextAreaCollection.new(self, extract_selector(args).merge(:tag_name => "textarea"))
+   end
+   
+   Watir.tag_to_class[:textarea] = TextArea
+   #
+   # @return [TableSection]
+   #
+   
+   def tfoot(*args)
+     TableSection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
+   end
+   
+   #
+   # @return [TableSectionCollection]
+   #
+   
+   def tfoots(*args)
+     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
+   end
+   
+   Watir.tag_to_class[:tfoot] = TableSection
+   #
+   # @return [TableHeaderCell]
+   #
+   
+   def th(*args)
+     TableHeaderCell.new(self, extract_selector(args).merge(:tag_name => "th"))
+   end
+   
+   #
+   # @return [TableHeaderCellCollection]
+   #
+   
+   def ths(*args)
+     TableHeaderCellCollection.new(self, extract_selector(args).merge(:tag_name => "th"))
+   end
+   
+   Watir.tag_to_class[:th] = TableHeaderCell
+   #
+   # @return [TableSection]
+   #
+   
+   def thead(*args)
+     TableSection.new(self, extract_selector(args).merge(:tag_name => "thead"))
+   end
+   
+   #
+   # @return [TableSectionCollection]
+   #
+   
+   def theads(*args)
+     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "thead"))
+   end
+   
+   Watir.tag_to_class[:thead] = TableSection
+   #
+   # @return [Time]
+   #
+   
+   def time(*args)
+     Time.new(self, extract_selector(args).merge(:tag_name => "time"))
+   end
+   
+   #
+   # @return [TimeCollection]
+   #
+   
+   def times(*args)
+     TimeCollection.new(self, extract_selector(args).merge(:tag_name => "time"))
+   end
+   
+   Watir.tag_to_class[:time] = Time
+   #
+   # @return [Title]
+   #
+   
+   def title(*args)
+     Title.new(self, extract_selector(args).merge(:tag_name => "title"))
+   end
+   
+   #
+   # @return [TitleCollection]
+   #
+   
+   def titles(*args)
+     TitleCollection.new(self, extract_selector(args).merge(:tag_name => "title"))
+   end
+   
+   Watir.tag_to_class[:title] = Title
+   #
+   # @return [TableRow]
+   #
+   
+   def tr(*args)
+     TableRow.new(self, extract_selector(args).merge(:tag_name => "tr"))
+   end
+   
+   #
+   # @return [TableRowCollection]
+   #
+   
+   def trs(*args)
+     TableRowCollection.new(self, extract_selector(args).merge(:tag_name => "tr"))
+   end
+   
+   Watir.tag_to_class[:tr] = TableRow
+   #
+   # @return [Track]
+   #
+   
+   def track(*args)
+     Track.new(self, extract_selector(args).merge(:tag_name => "track"))
+   end
+   
+   #
+   # @return [TrackCollection]
+   #
+   
+   def tracks(*args)
+     TrackCollection.new(self, extract_selector(args).merge(:tag_name => "track"))
+   end
+   
+   Watir.tag_to_class[:track] = Track
+   #
+   # @return [UList]
+   #
+   
+   def ul(*args)
+     UList.new(self, extract_selector(args).merge(:tag_name => "ul"))
+   end
+   
+   #
+   # @return [UListCollection]
+   #
+   
+   def uls(*args)
+     UListCollection.new(self, extract_selector(args).merge(:tag_name => "ul"))
+   end
+   
+   Watir.tag_to_class[:ul] = UList
+   #
+   # @return [HTMLElement]
+   #
+   
+   def var(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "var"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def vars(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "var"))
+   end
+   
+   Watir.tag_to_class[:var] = HTMLElement
+   #
+   # @return [Video]
+   #
+   
+   def video(*args)
+     Video.new(self, extract_selector(args).merge(:tag_name => "video"))
+   end
+   
+   #
+   # @return [VideoCollection]
+   #
+   
+   def videos(*args)
+     VideoCollection.new(self, extract_selector(args).merge(:tag_name => "video"))
+   end
+   
+   Watir.tag_to_class[:video] = Video
+   #
+   # @return [HTMLElement]
+   #
+   
+   def wbr(*args)
+     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "wbr"))
+   end
+   
+   #
+   # @return [HTMLElementCollection]
+   #
+   
+   def wbrs(*args)
+     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "wbr"))
+   end
+   
+   Watir.tag_to_class[:wbr] = HTMLElement
+ end # Container
+end # Watir