lib/watir-webdriver/elements/generated.rb in watir-webdriver-0.6.9 vs lib/watir-webdriver/elements/generated.rb in watir-webdriver-0.6.10

@@ -1,2701 +1,3093 @@
 # Autogenerated from the HTML5 specification. Edits may be lost.
 module Watir
+  class HTMLElement < Element
+    attribute(String, :title, :title)
+    attribute(String, :lang, :lang)
+    attribute("Boolean", :translate?, :translate)
+    attribute(String, :dir, :dir)
+    attribute(String, :dataset, :dataset)
+    attribute("Boolean", :item_scope?, :itemScope)
+    attribute(String, :item_type, :itemType)
+    attribute(String, :item_id, :itemId)
+    attribute(String, :item_ref, :itemRef)
+    attribute(String, :item_prop, :itemProp)
+    attribute(String, :properties, :properties)
+    attribute(String, :item_value, :itemValue)
+    attribute("Boolean", :hidden?, :hidden)
+    attribute(Fixnum, :tab_index, :tabIndex)
+    attribute(String, :access_key, :accessKey)
+    attribute(String, :access_key_label, :accessKeyLabel)
+    attribute("Boolean", :draggable?, :draggable)
+    attribute(String, :dropzone, :dropzone)
+    attribute(String, :content_editable, :contentEditable)
+    attribute("Boolean", :content_editable?, :isContentEditable)
+    attribute(String, :context_menu, :contextMenu)
+    attribute("Boolean", :spellcheck?, :spellcheck)
+    attribute(String, :command_type, :commandType)
+    attribute(String, :command_label, :commandLabel)
+    attribute(String, :command_icon, :commandIcon)
+    attribute("Boolean", :command_hidden?, :commandHidden)
+    attribute("Boolean", :command_disabled?, :commandDisabled)
+    attribute("Boolean", :command_checked?, :commandChecked)
+    attribute(String, :onabort, :onabort)
+    attribute(String, :onautocomplete, :onautocomplete)
+    attribute(String, :onautocompleteerror, :onautocompleteerror)
+    attribute(String, :onblur, :onblur)
+    attribute(String, :oncancel, :oncancel)
+    attribute(String, :oncanplay, :oncanplay)
+    attribute(String, :oncanplaythrough, :oncanplaythrough)
+    attribute(String, :onchange, :onchange)
+    attribute(String, :onclick, :onclick)
+    attribute(String, :onclose, :onclose)
+    attribute(String, :oncontextmenu, :oncontextmenu)
+    attribute(String, :oncuechange, :oncuechange)
+    attribute(String, :ondblclick, :ondblclick)
+    attribute(String, :ondrag, :ondrag)
+    attribute(String, :ondragend, :ondragend)
+    attribute(String, :ondragenter, :ondragenter)
+    attribute(String, :ondragexit, :ondragexit)
+    attribute(String, :ondragleave, :ondragleave)
+    attribute(String, :ondragover, :ondragover)
+    attribute(String, :ondragstart, :ondragstart)
+    attribute(String, :ondrop, :ondrop)
+    attribute(String, :ondurationchange, :ondurationchange)
+    attribute(String, :onemptied, :onemptied)
+    attribute(String, :onended, :onended)
+    attribute(String, :onerror, :onerror)
+    attribute(String, :onfocus, :onfocus)
+    attribute(String, :oninput, :oninput)
+    attribute(String, :oninvalid, :oninvalid)
+    attribute(String, :onkeydown, :onkeydown)
+    attribute(String, :onkeypress, :onkeypress)
+    attribute(String, :onkeyup, :onkeyup)
+    attribute(String, :onload, :onload)
+    attribute(String, :onloadeddata, :onloadeddata)
+    attribute(String, :onloadedmetadata, :onloadedmetadata)
+    attribute(String, :onloadstart, :onloadstart)
+    attribute(String, :onmousedown, :onmousedown)
+    attribute(String, :onmouseenter, :onmouseenter)
+    attribute(String, :onmouseleave, :onmouseleave)
+    attribute(String, :onmousemove, :onmousemove)
+    attribute(String, :onmouseout, :onmouseout)
+    attribute(String, :onmouseover, :onmouseover)
+    attribute(String, :onmouseup, :onmouseup)
+    attribute(String, :onmousewheel, :onmousewheel)
+    attribute(String, :onpause, :onpause)
+    attribute(String, :onplay, :onplay)
+    attribute(String, :onplaying, :onplaying)
+    attribute(String, :onprogress, :onprogress)
+    attribute(String, :onratechange, :onratechange)
+    attribute(String, :onreset, :onreset)
+    attribute(String, :onresize, :onresize)
+    attribute(String, :onscroll, :onscroll)
+    attribute(String, :onseeked, :onseeked)
+    attribute(String, :onseeking, :onseeking)
+    attribute(String, :onselect, :onselect)
+    attribute(String, :onshow, :onshow)
+    attribute(String, :onsort, :onsort)
+    attribute(String, :onstalled, :onstalled)
+    attribute(String, :onsubmit, :onsubmit)
+    attribute(String, :onsuspend, :onsuspend)
+    attribute(String, :ontimeupdate, :ontimeupdate)
+    attribute(String, :ontoggle, :ontoggle)
+    attribute(String, :onvolumechange, :onvolumechange)
+    attribute(String, :onwaiting, :onwaiting)
+  end
+  class HTMLElementCollection < ElementCollection
+    def element_class
+      HTMLElement
+    end
+  end
+  class Font < HTMLElement
+    attribute(String, :color, :color)
+    attribute(String, :face, :face)
+    attribute(String, :size, :size)
+  end
+  class FontCollection < ElementCollection
+    def element_class
+      Font
+    end
+  end
+  class Directory < HTMLElement
+    attribute("Boolean", :compact?, :compact)
+  end
+  class DirectoryCollection < ElementCollection
+    def element_class
+      Directory
+    end
+  end
+  class FrameSet < HTMLElement
+    attribute(String, :cols, :cols)
+    attribute(String, :onafterprint, :onafterprint)
+    attribute(String, :onbeforeprint, :onbeforeprint)
+    attribute(String, :onbeforeunload, :onbeforeunload)
+    attribute(String, :onhashchange, :onhashchange)
+    attribute(String, :onlanguagechange, :onlanguagechange)
+    attribute(String, :onmessage, :onmessage)
+    attribute(String, :onoffline, :onoffline)
+    attribute(String, :ononline, :ononline)
+    attribute(String, :onpagehide, :onpagehide)
+    attribute(String, :onpageshow, :onpageshow)
+    attribute(String, :onpopstate, :onpopstate)
+    attribute(String, :onstorage, :onstorage)
+    attribute(String, :onunload, :onunload)
+  end
+  class FrameSetCollection < ElementCollection
+    def element_class
+      FrameSet
+    end
+  end
+  class Marquee < HTMLElement
+    attribute(String, :behavior, :behavior)
+    attribute(String, :bg_color, :bgColor)
+    attribute(String, :direction, :direction)
+    attribute(String, :height, :height)
+    attribute(Fixnum, :hspace, :hspace)
+    attribute(Fixnum, :loop, :loop)
+    attribute(Fixnum, :scroll_amount, :scrollAmount)
+    attribute(Fixnum, :scroll_delay, :scrollDelay)
+    attribute("Boolean", :true_speed?, :trueSpeed)
+    attribute(Fixnum, :vspace, :vspace)
+    attribute(String, :width, :width)
+    attribute(String, :onbounce, :onbounce)
+    attribute(String, :onfinish, :onfinish)
+    attribute(String, :onstart, :onstart)
+  end
+  class MarqueeCollection < ElementCollection
+    def element_class
+      Marquee
+    end
+  end
+  class Applet < HTMLElement
+    attribute(String, :align, :align)
+    attribute(String, :alt, :alt)
+    attribute(String, :archive, :archive)
+    attribute(String, :code, :code)
+    attribute(String, :code_base, :codeBase)
+    attribute(String, :height, :height)
+    attribute(Fixnum, :hspace, :hspace)
+    attribute(String, :name, :name)
+    attribute(String, :object, :object)
+    attribute(Fixnum, :vspace, :vspace)
+    attribute(String, :width, :width)
+  end
+  class AppletCollection < ElementCollection
+    def element_class
+      Applet
+    end
+  end
+  class Canvas < HTMLElement
+    attribute(Fixnum, :width, :width)
+    attribute(Fixnum, :height, :height)
+  end
+  class CanvasCollection < ElementCollection
+    def element_class
+      Canvas
+    end
+  end
+  class Template < HTMLElement
+    attribute(String, :content, :content)
+  end
+  class TemplateCollection < ElementCollection
+    def element_class
+      Template
+    end
+  end
+  class Script < HTMLElement
+    attribute(String, :src, :src)
+    attribute(String, :type, :type)
+    attribute(String, :charset, :charset)
+    attribute("Boolean", :async?, :async)
+    attribute("Boolean", :defer?, :defer)
+    attribute(String, :cross_origin, :crossOrigin)
+    attribute(String, :event, :event)
+    attribute(String, :for, :htmlFor)
+  end
+  class ScriptCollection < ElementCollection
+    def element_class
+      Script
+    end
+  end
+  class Dialog < HTMLElement
+    attribute("Boolean", :open?, :open)
+    attribute(String, :return_value, :returnValue)
+  end
+  class DialogCollection < ElementCollection
+    def element_class
+      Dialog
+    end
+  end
+  class MenuItem < HTMLElement
+    attribute(String, :type, :type)
+    attribute(String, :label, :label)
+    attribute(String, :icon, :icon)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute("Boolean", :checked?, :checked)
+    attribute(String, :radiogroup, :radiogroup)
+    attribute("Boolean", :default?, :default)
+    attribute(String, :command, :command)
+  end
+  class MenuItemCollection < ElementCollection
+    def element_class
+      MenuItem
+    end
+  end
+  class Menu < HTMLElement
+    attribute(String, :type, :type)
+    attribute(String, :label, :label)
+    attribute("Boolean", :compact?, :compact)
+  end
+  class MenuCollection < ElementCollection
+    def element_class
+      Menu
+    end
+  end
+  class Details < HTMLElement
+    attribute("Boolean", :open?, :open)
+  end
+  class DetailsCollection < ElementCollection
+    def element_class
+      Details
+    end
+  end
+  class Legend < HTMLElement
+    attribute(String, :form, :form)
+    attribute(String, :align, :align)
+  end
+  class LegendCollection < ElementCollection
+    def element_class
+      Legend
+    end
+  end
+  class FieldSet < HTMLElement
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :name, :name)
+    attribute(String, :type, :type)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+  end
+  class FieldSetCollection < ElementCollection
+    def element_class
+      FieldSet
+    end
+  end
+  class Meter < HTMLElement
+    attribute(Float, :value, :value)
+    attribute(Float, :min, :min)
+    attribute(Float, :max, :max)
+    attribute(Float, :low, :low)
+    attribute(Float, :high, :high)
+    attribute(Float, :optimum, :optimum)
+    attribute(String, :labels, :labels)
+  end
+  class MeterCollection < ElementCollection
+    def element_class
+      Meter
+    end
+  end
+  class Progress < HTMLElement
+    attribute(Float, :value, :value)
+    attribute(Float, :max, :max)
+    attribute(Float, :position, :position)
+    attribute(String, :labels, :labels)
+  end
+  class ProgressCollection < ElementCollection
+    def element_class
+      Progress
+    end
+  end
+  class Output < HTMLElement
+    attribute(String, :for, :htmlFor)
+    attribute(String, :form, :form)
+    attribute(String, :name, :name)
+    attribute(String, :type, :type)
+    attribute(String, :default_value, :defaultValue)
+    attribute(String, :value, :value)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+  end
+  class OutputCollection < ElementCollection
+    def element_class
+      Output
+    end
+  end
+  class Keygen < HTMLElement
+    attribute("Boolean", :autofocus?, :autofocus)
+    attribute(String, :challenge, :challenge)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :keytype, :keytype)
+    attribute(String, :name, :name)
+    attribute(String, :type, :type)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+  end
+  class KeygenCollection < ElementCollection
+    def element_class
+      Keygen
+    end
+  end
+  class TextArea < HTMLElement
+    attribute(String, :autocomplete, :autocomplete)
+    attribute("Boolean", :autofocus?, :autofocus)
+    attribute(Fixnum, :cols, :cols)
+    attribute(String, :dir_name, :dirName)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :input_mode, :inputMode)
+    attribute(Fixnum, :max_length, :maxLength)
+    attribute(Fixnum, :min_length, :minLength)
+    attribute(String, :name, :name)
+    attribute(String, :placeholder, :placeholder)
+    attribute("Boolean", :read_only?, :readOnly)
+    attribute("Boolean", :required?, :required)
+    attribute(String, :wrap, :wrap)
+    attribute(String, :type, :type)
+    attribute(String, :default_value, :defaultValue)
+    attribute(String, :value, :value)
+    attribute(Fixnum, :text_length, :textLength)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+    attribute(Fixnum, :selection_start, :selectionStart)
+    attribute(Fixnum, :selection_end, :selectionEnd)
+    attribute(String, :selection_direction, :selectionDirection)
+  end
+  class TextAreaCollection < ElementCollection
+    def element_class
+      TextArea
+    end
+  end
+  class Option < HTMLElement
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :label, :label)
+    attribute("Boolean", :default_selected?, :defaultSelected)
+    attribute("Boolean", :selected?, :selected)
+    attribute(String, :value, :value)
+    attribute(Fixnum, :index, :index)
+  end
+  class OptionCollection < ElementCollection
+    def element_class
+      Option
+    end
+  end
+  class OptGroup < HTMLElement
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :label, :label)
+  end
+  class OptGroupCollection < ElementCollection
+    def element_class
+      OptGroup
+    end
+  end
+  class DataList < HTMLElement
+    attribute(String, :options, :options)
+  end
+  class DataListCollection < ElementCollection
+    def element_class
+      DataList
+    end
+  end
+  class Select < HTMLElement
+    attribute(String, :autocomplete, :autocomplete)
+    attribute("Boolean", :autofocus?, :autofocus)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute("Boolean", :multiple?, :multiple)
+    attribute(String, :name, :name)
+    attribute("Boolean", :required?, :required)
+    attribute(Fixnum, :size, :size)
+    attribute(String, :type, :type)
+    attribute(String, :options, :options)
+    attribute(Fixnum, :length, :length)
+    attribute(String, :selected_options, :selectedOptions)
+    attribute(Fixnum, :selected_index, :selectedIndex)
+    attribute(String, :value, :value)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+  end
+  class SelectCollection < ElementCollection
+    def element_class
+      Select
+    end
+  end
+  class Button < HTMLElement
+    attribute("Boolean", :autofocus?, :autofocus)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :form_action, :formAction)
+    attribute(String, :form_enctype, :formEnctype)
+    attribute(String, :form_method, :formMethod)
+    attribute("Boolean", :form_no_validate?, :formNoValidate)
+    attribute(String, :form_target, :formTarget)
+    attribute(String, :name, :name)
+    attribute(String, :type, :type)
+    attribute(String, :value, :value)
+    attribute(String, :menu, :menu)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+  end
+  class ButtonCollection < ElementCollection
+    def element_class
+      Button
+    end
+  end
+  class Input < HTMLElement
+    attribute(String, :accept, :accept)
+    attribute(String, :alt, :alt)
+    attribute(String, :autocomplete, :autocomplete)
+    attribute("Boolean", :autofocus?, :autofocus)
+    attribute("Boolean", :default_checked?, :defaultChecked)
+    attribute("Boolean", :checked?, :checked)
+    attribute(String, :dir_name, :dirName)
+    attribute("Boolean", :disabled?, :disabled)
+    attribute(String, :form, :form)
+    attribute(String, :files, :files)
+    attribute(String, :form_action, :formAction)
+    attribute(String, :form_enctype, :formEnctype)
+    attribute(String, :form_method, :formMethod)
+    attribute("Boolean", :form_no_validate?, :formNoValidate)
+    attribute(String, :form_target, :formTarget)
+    attribute(Fixnum, :height, :height)
+    attribute("Boolean", :indeterminate?, :indeterminate)
+    attribute(String, :input_mode, :inputMode)
+    attribute(String, :list, :list)
+    attribute(String, :max, :max)
+    attribute(Fixnum, :max_length, :maxLength)
+    attribute(String, :min, :min)
+    attribute(Fixnum, :min_length, :minLength)
+    attribute("Boolean", :multiple?, :multiple)
+    attribute(String, :name, :name)
+    attribute(String, :pattern, :pattern)
+    attribute(String, :placeholder, :placeholder)
+    attribute("Boolean", :read_only?, :readOnly)
+    attribute("Boolean", :required?, :required)
+    attribute(Fixnum, :size, :size)
+    attribute(String, :src, :src)
+    attribute(String, :step, :step)
+    attribute(String, :type, :type)
+    attribute(String, :default_value, :defaultValue)
+    attribute(String, :value, :value)
+    attribute(String, :value_as_date, :valueAsDate)
+    attribute(Float, :value_as_number, :valueAsNumber)
+    attribute(Float, :value_low, :valueLow)
+    attribute(Float, :value_high, :valueHigh)
+    attribute(Fixnum, :width, :width)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :labels, :labels)
+    attribute(Fixnum, :selection_start, :selectionStart)
+    attribute(Fixnum, :selection_end, :selectionEnd)
+    attribute(String, :selection_direction, :selectionDirection)
+    attribute(String, :align, :align)
+    attribute(String, :use_map, :useMap)
+  end
+  class InputCollection < ElementCollection
+    def element_class
+      Input
+    end
+  end
+  class Label < HTMLElement
+    attribute(String, :form, :form)
+    attribute(String, :for, :htmlFor)
+    attribute(String, :control, :control)
+  end
+  class LabelCollection < ElementCollection
+    def element_class
+      Label
+    end
+  end
+  class Form < HTMLElement
+    attribute(String, :accept_charset, :acceptCharset)
+    attribute(String, :action, :action)
+    attribute(String, :autocomplete, :autocomplete)
+    attribute(String, :enctype, :enctype)
+    attribute(String, :encoding, :encoding)
+    attribute(String, :method, :method)
+    attribute(String, :name, :name)
+    attribute("Boolean", :no_validate?, :noValidate)
+    attribute(String, :target, :target)
+    attribute(Fixnum, :length, :length)
+  end
+  class FormCollection < ElementCollection
+    def element_class
+      Form
+    end
+  end
+  class TableCell < HTMLElement
+    attribute(Fixnum, :col_span, :colSpan)
+    attribute(Fixnum, :row_span, :rowSpan)
+    attribute(String, :headers, :headers)
+    attribute(Fixnum, :cell_index, :cellIndex)
+    attribute(String, :align, :align)
+    attribute(String, :axis, :axis)
+    attribute(String, :height, :height)
+    attribute(String, :width, :width)
+    attribute(String, :ch, :ch)
+    attribute(String, :ch_off, :chOff)
+    attribute("Boolean", :no_wrap?, :noWrap)
+    attribute(String, :v_align, :vAlign)
+    attribute(String, :bg_color, :bgColor)
+  end
+  class TableCellCollection < ElementCollection
+    def element_class
+      TableCell
+    end
+  end
+  class TableHeaderCell < TableCell
+    attribute(String, :scope, :scope)
+    attribute(String, :abbr, :abbr)
+    attribute(String, :sorted, :sorted)
+  end
+  class TableHeaderCellCollection < ElementCollection
+    def element_class
+      TableHeaderCell
+    end
+  end
+  class TableDataCell < TableCell
+    attribute(String, :abbr, :abbr)
+  end
+  class TableDataCellCollection < ElementCollection
+    def element_class
+      TableDataCell
+    end
+  end
+  class TableRow < HTMLElement
+    attribute(Fixnum, :row_index, :rowIndex)
+    attribute(Fixnum, :section_row_index, :sectionRowIndex)
+    attribute(String, :align, :align)
+    attribute(String, :ch, :ch)
+    attribute(String, :ch_off, :chOff)
+    attribute(String, :v_align, :vAlign)
+    attribute(String, :bg_color, :bgColor)
+  end
+  class TableRowCollection < ElementCollection
+    def element_class
+      TableRow
+    end
+  end
+  class TableSection < HTMLElement
+    attribute(String, :align, :align)
+    attribute(String, :ch, :ch)
+    attribute(String, :ch_off, :chOff)
+    attribute(String, :v_align, :vAlign)
+  end
+  class TableSectionCollection < ElementCollection
+    def element_class
+      TableSection
+    end
+  end
+  class TableCol < HTMLElement
+    attribute(String, :align, :align)
+    attribute(String, :ch, :ch)
+    attribute(String, :ch_off, :chOff)
+    attribute(String, :v_align, :vAlign)
+    attribute(String, :width, :width)
+  end
+  class TableColCollection < ElementCollection
+    def element_class
+      TableCol
+    end
+  end
+  class TableCaption < HTMLElement
+    attribute(String, :align, :align)
+  end
+  class TableCaptionCollection < ElementCollection
+    def element_class
+      TableCaption
+    end
+  end
+  class Table < HTMLElement
+    attribute(String, :caption, :caption)
+    attribute(String, :t_head, :tHead)
+    attribute(String, :t_foot, :tFoot)
+    attribute(String, :t_bodies, :tBodies)
+    attribute("Boolean", :sortable?, :sortable)
+    attribute(String, :align, :align)
+    attribute(String, :border, :border)
+    attribute(String, :frame, :frame)
+    attribute(String, :rules, :rules)
+    attribute(String, :summary, :summary)
+    attribute(String, :width, :width)
+    attribute(String, :bg_color, :bgColor)
+    attribute(String, :cell_padding, :cellPadding)
+    attribute(String, :cell_spacing, :cellSpacing)
+  end
+  class TableCollection < ElementCollection
+    def element_class
+      Table
+    end
+  end
+  class Area < HTMLElement
+    attribute(String, :alt, :alt)
+    attribute(String, :coords, :coords)
+    attribute(String, :shape, :shape)
+    attribute(String, :target, :target)
+    attribute(String, :download, :download)
+    attribute(String, :ping, :ping)
+    attribute(String, :rel, :rel)
+    attribute(String, :rel_list, :relList)
+    attribute(String, :hreflang, :hreflang)
+    attribute(String, :type, :type)
+    attribute("Boolean", :no_href?, :noHref)
+  end
+  class AreaCollection < ElementCollection
+    def element_class
+      Area
+    end
+  end
+  class Map < HTMLElement
+    attribute(String, :name, :name)
+    attribute(String, :areas, :areas)
+    attribute(String, :images, :images)
+  end
+  class MapCollection < ElementCollection
+    def element_class
+      Map
+    end
+  end
+  class Media < HTMLElement
+    attribute(String, :error, :error)
+    attribute(String, :src, :src)
+    attribute(String, :current_src, :currentSrc)
+    attribute(String, :cross_origin, :crossOrigin)
+    attribute(Fixnum, :network_state, :networkState)
+    attribute(String, :preload, :preload)
+    attribute(String, :buffered, :buffered)
+    attribute(Fixnum, :ready_state, :readyState)
+    attribute("Boolean", :seeking?, :seeking)
+    attribute(Float, :current_time, :currentTime)
+    attribute(Float, :duration, :duration)
+    attribute("Boolean", :paused?, :paused)
+    attribute(Float, :default_playback_rate, :defaultPlaybackRate)
+    attribute(Float, :playback_rate, :playbackRate)
+    attribute(String, :played, :played)
+    attribute(String, :seekable, :seekable)
+    attribute("Boolean", :ended?, :ended)
+    attribute("Boolean", :autoplay?, :autoplay)
+    attribute("Boolean", :loop?, :loop)
+    attribute(String, :media_group, :mediaGroup)
+    attribute(String, :controller, :controller)
+    attribute("Boolean", :controls?, :controls)
+    attribute(Float, :volume, :volume)
+    attribute("Boolean", :muted?, :muted)
+    attribute("Boolean", :default_muted?, :defaultMuted)
+    attribute(String, :audio_tracks, :audioTracks)
+    attribute(String, :video_tracks, :videoTracks)
+    attribute(String, :text_tracks, :textTracks)
+  end
+  class MediaCollection < ElementCollection
+    def element_class
+      Media
+    end
+  end
+  class Audio < Media
+  end
+  class AudioCollection < ElementCollection
+    def element_class
+      Audio
+    end
+  end
+  class Video < Media
+    attribute(Fixnum, :width, :width)
+    attribute(Fixnum, :height, :height)
+    attribute(Fixnum, :video_width, :videoWidth)
+    attribute(Fixnum, :video_height, :videoHeight)
+    attribute(String, :poster, :poster)
+  end
+  class VideoCollection < ElementCollection
+    def element_class
+      Video
+    end
+  end
+  class Track < HTMLElement
+    attribute(String, :kind, :kind)
+    attribute(String, :src, :src)
+    attribute(String, :srclang, :srclang)
+    attribute(String, :label, :label)
+    attribute("Boolean", :default?, :default)
+    attribute(Fixnum, :ready_state, :readyState)
+    attribute(String, :track, :track)
+  end
+  class TrackCollection < ElementCollection
+    def element_class
+      Track
+    end
+  end
+  class Source < HTMLElement
+    attribute(String, :src, :src)
+    attribute(String, :type, :type)
+  end
+  class SourceCollection < ElementCollection
+    def element_class
+      Source
+    end
+  end
+  class Param < HTMLElement
+    attribute(String, :name, :name)
+    attribute(String, :value, :value)
+    attribute(String, :type, :type)
+    attribute(String, :value_type, :valueType)
+  end
+  class ParamCollection < ElementCollection
+    def element_class
+      Param
+    end
+  end
+  class Object < HTMLElement
+    attribute(String, :data, :data)
+    attribute(String, :type, :type)
+    attribute("Boolean", :type_must_match?, :typeMustMatch)
+    attribute(String, :name, :name)
+    attribute(String, :use_map, :useMap)
+    attribute(String, :form, :form)
+    attribute(String, :width, :width)
+    attribute(String, :height, :height)
+    attribute(String, :content_document, :contentDocument)
+    attribute(String, :content_window, :contentWindow)
+    attribute("Boolean", :will_validate?, :willValidate)
+    attribute(String, :validity, :validity)
+    attribute(String, :validation_message, :validationMessage)
+    attribute(String, :align, :align)
+    attribute(String, :archive, :archive)
+    attribute(String, :code, :code)
+    attribute("Boolean", :declare?, :declare)
+    attribute(Fixnum, :hspace, :hspace)
+    attribute(String, :standby, :standby)
+    attribute(Fixnum, :vspace, :vspace)
+    attribute(String, :code_base, :codeBase)
+    attribute(String, :code_type, :codeType)
+    attribute(String, :border, :border)
+  end
+  class ObjectCollection < ElementCollection
+    def element_class
+      Object
+    end
+  end
+  class Embed < HTMLElement
+    attribute(String, :src, :src)
+    attribute(String, :type, :type)
+    attribute(String, :width, :width)
+    attribute(String, :height, :height)
+    attribute(String, :align, :align)
+    attribute(String, :name, :name)
+  end
+  class EmbedCollection < ElementCollection
+    def element_class
+      Embed
+    end
+  end
+  class IFrame < HTMLElement
+    attribute(String, :src, :src)
+    attribute(String, :srcdoc, :srcdoc)
+    attribute(String, :name, :name)
+    attribute(String, :sandbox, :sandbox)
+    attribute("Boolean", :seamless?, :seamless)
+    attribute("Boolean", :allow_fullscreen?, :allowFullscreen)
+    attribute(String, :width, :width)
+    attribute(String, :height, :height)
+    attribute(String, :content_document, :contentDocument)
+    attribute(String, :content_window, :contentWindow)
+    attribute(String, :align, :align)
+    attribute(String, :scrolling, :scrolling)
+    attribute(String, :frame_border, :frameBorder)
+    attribute(String, :long_desc, :longDesc)
+    attribute(String, :margin_height, :marginHeight)
+    attribute(String, :margin_width, :marginWidth)
+  end
+  class IFrameCollection < ElementCollection
+    def element_class
+      IFrame
+    end
+  end
+  class Image < HTMLElement
+    attribute(String, :alt, :alt)
+    attribute(String, :src, :src)
+    attribute(String, :srcset, :srcset)
+    attribute(String, :cross_origin, :crossOrigin)
+    attribute(String, :use_map, :useMap)
+    attribute("Boolean", :map?, :isMap)
+    attribute(Fixnum, :width, :width)
+    attribute(Fixnum, :height, :height)
+    attribute(Fixnum, :natural_width, :naturalWidth)
+    attribute(Fixnum, :natural_height, :naturalHeight)
+    attribute("Boolean", :complete?, :complete)
+    attribute(String, :name, :name)
+    attribute(String, :lowsrc, :lowsrc)
+    attribute(String, :align, :align)
+    attribute(Fixnum, :hspace, :hspace)
+    attribute(Fixnum, :vspace, :vspace)
+    attribute(String, :long_desc, :longDesc)
+    attribute(String, :border, :border)
+  end
+  class ImageCollection < ElementCollection
+    def element_class
+      Image
+    end
+  end
+  class Mod < HTMLElement
+    attribute(String, :cite, :cite)
+    attribute(String, :date_time, :dateTime)
+  end
+  class ModCollection < ElementCollection
+    def element_class
+      Mod
+    end
+  end
+  class BR < HTMLElement
+    attribute(String, :clear, :clear)
+  end
+  class BRCollection < ElementCollection
+    def element_class
+      BR
+    end
+  end
+  class Span < HTMLElement
+  end
+  class SpanCollection < ElementCollection
+    def element_class
+      Span
+    end
+  end
+  class Time < HTMLElement
+    attribute(String, :date_time, :dateTime)
+  end
+  class TimeCollection < ElementCollection
+    def element_class
+      Time
+    end
+  end
+  class Data < HTMLElement
+    attribute(String, :value, :value)
+  end
+  class DataCollection < ElementCollection
+    def element_class
+      Data
+    end
+  end
+  class Anchor < HTMLElement
+    attribute(String, :target, :target)
+    attribute(String, :download, :download)
+    attribute(String, :ping, :ping)
+    attribute(String, :rel, :rel)
+    attribute(String, :rel_list, :relList)
+    attribute(String, :hreflang, :hreflang)
+    attribute(String, :type, :type)
+    attribute(String, :coords, :coords)
+    attribute(String, :charset, :charset)
+    attribute(String, :name, :name)
+    attribute(String, :rev, :rev)
+    attribute(String, :shape, :shape)
+  end
+  class AnchorCollection < ElementCollection
+    def element_class
+      Anchor
+    end
+  end
+  class Div < HTMLElement
+    attribute(String, :align, :align)
+  end
+  class DivCollection < ElementCollection
+    def element_class
+      Div
+    end
+  end
+  class DList < HTMLElement
+    attribute("Boolean", :compact?, :compact)
+  end
+  class DListCollection < ElementCollection
+    def element_class
+      DList
+    end
+  end
+  class LI < HTMLElement
+    attribute(Fixnum, :value, :value)
+    attribute(String, :type, :type)
+  end
+  class LICollection < ElementCollection
+    def element_class
+      LI
+    end
+  end
+  class UList < HTMLElement
+    attribute("Boolean", :compact?, :compact)
+    attribute(String, :type, :type)
+  end
+  class UListCollection < ElementCollection
+    def element_class
+      UList
+    end
+  end
+  class OList < HTMLElement
+    attribute("Boolean", :reversed?, :reversed)
+    attribute(Fixnum, :start, :start)
+    attribute(String, :type, :type)
+    attribute("Boolean", :compact?, :compact)
+  end
+  class OListCollection < ElementCollection
+    def element_class
+      OList
+    end
+  end
+  class Quote < HTMLElement
+    attribute(String, :cite, :cite)
+  end
+  class QuoteCollection < ElementCollection
+    def element_class
+      Quote
+    end
+  end
+  class Pre < HTMLElement
+    attribute(Fixnum, :width, :width)
+  end
+  class PreCollection < ElementCollection
+    def element_class
+      Pre
+    end
+  end
+  class HR < HTMLElement
+    attribute(String, :align, :align)
+    attribute(String, :color, :color)
+    attribute("Boolean", :no_shade?, :noShade)
+    attribute(String, :size, :size)
+    attribute(String, :width, :width)
+  end
+  class HRCollection < ElementCollection
+    def element_class
+      HR
+    end
+  end
+  class Paragraph < HTMLElement
+    attribute(String, :align, :align)
+  end
+  class ParagraphCollection < ElementCollection
+    def element_class
+      Paragraph
+    end
+  end
+  class Heading < HTMLElement
+    attribute(String, :align, :align)
+  end
+  class HeadingCollection < ElementCollection
+    def element_class
+      Heading
+    end
+  end
+  class Body < HTMLElement
+    attribute(String, :link, :link)
+    attribute(String, :v_link, :vLink)
+    attribute(String, :a_link, :aLink)
+    attribute(String, :bg_color, :bgColor)
+    attribute(String, :background, :background)
+    attribute(String, :onafterprint, :onafterprint)
+    attribute(String, :onbeforeprint, :onbeforeprint)
+    attribute(String, :onbeforeunload, :onbeforeunload)
+    attribute(String, :onhashchange, :onhashchange)
+    attribute(String, :onlanguagechange, :onlanguagechange)
+    attribute(String, :onmessage, :onmessage)
+    attribute(String, :onoffline, :onoffline)
+    attribute(String, :ononline, :ononline)
+    attribute(String, :onpagehide, :onpagehide)
+    attribute(String, :onpageshow, :onpageshow)
+    attribute(String, :onpopstate, :onpopstate)
+    attribute(String, :onstorage, :onstorage)
+    attribute(String, :onunload, :onunload)
+  end
+  class BodyCollection < ElementCollection
+    def element_class
+      Body
+    end
+  end
+  class Style < HTMLElement
+    attribute(String, :media, :media)
+    attribute(String, :type, :type)
+    attribute("Boolean", :scoped?, :scoped)
+  end
+  class StyleCollection < ElementCollection
+    def element_class
+      Style
+    end
+  end
+  class Meta < HTMLElement
+    attribute(String, :name, :name)
+    attribute(String, :http_equiv, :httpEquiv)
+    attribute(String, :content, :content)
+    attribute(String, :scheme, :scheme)
+  end
+  class MetaCollection < ElementCollection
+    def element_class
+      Meta
+    end
+  end
+  class Base < HTMLElement
+    attribute(String, :href, :href)
+    attribute(String, :target, :target)
+  end
+  class BaseCollection < ElementCollection
+    def element_class
+      Base
+    end
+  end
+  class Title < HTMLElement
+  end
+  class TitleCollection < ElementCollection
+    def element_class
+      Title
+    end
+  end
+  class Head < HTMLElement
+  end
+  class HeadCollection < ElementCollection
+    def element_class
+      Head
+    end
+  end
+  class Html < HTMLElement
+    attribute(String, :version, :version)
+  end
+  class HtmlCollection < ElementCollection
+    def element_class
+      Html
+    end
+  end
+  class Unknown < HTMLElement
+  end
+  class UnknownCollection < ElementCollection
+    def element_class
+      Unknown
+    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 bdi(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdi"))
+      end
 
+      #
+      # @return [HTMLElementCollection]
+      #
 
+      def bdis(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "bdi"))
+      end
 
+      Watir.tag_to_class[:bdi] = HTMLElement
 
+      #
+      # @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
 
- class HTMLElement < Element
-   attributes(:string => [:access_key, :access_key_label, :command_icon, :command_label, :command_type, :content_editable, :dir, :item_id, :item_value, :lang, :title], :bool => [:command_checked, :command_disabled, :command_hidden, :draggable, :hidden, :inert, :content_editable, :item_scope, :spellcheck, :translate], :html_element => [:context_menu], :string_map => [:dataset], :token_list => [:dropzone, :item_prop, :item_ref, :item_type], :function => [:onabort, :onblur, :oncancel, :oncanplay, :oncanplaythrough, :onchange, :onclick, :onclose, :oncontextmenu, :oncuechange, :ondblclick, :ondrag, :ondragend, :ondragenter, :ondragexit, :ondragleave, :ondragover, :ondragstart, :ondrop, :ondurationchange, :onemptied, :onended, :onerror, :onfocus, :oninput, :oninvalid, :onkeydown, :onkeypress, :onkeyup, :onload, :onloadeddata, :onloadedmetadata, :onloadstart, :onmousedown, :onmouseenter, :onmouseleave, :onmousemove, :onmouseout, :onmouseover, :onmouseup, :onmousewheel, :onpause, :onplay, :onplaying, :onprogress, :onratechange, :onreset, :onscroll, :onseeked, :onseeking, :onselect, :onshow, :onsort, :onstalled, :onsubmit, :onsuspend, :ontimeupdate, :onvolumechange, :onwaiting], :properties_collection => [:properties], :int => [:tab_index])
- end
- class HTMLElementCollection < ElementCollection
-   def element_class
-     HTMLElement
-   end
- end
- class Font < HTMLElement
-   attributes(:string => [:color, :face, :size])
- end
- class FontCollection < ElementCollection
-   def element_class
-     Font
-   end
- end
- class Directory < HTMLElement
-   attributes(:bool => [:compact])
- end
- class DirectoryCollection < ElementCollection
-   def element_class
-     Directory
-   end
- end
- class FrameSet < HTMLElement
-   attributes(:string => [:cols, :rows], :function => [:onafterprint, :onbeforeprint, :onbeforeunload, :onhashchange, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onresize, :onstorage, :onunload])
- end
- class FrameSetCollection < ElementCollection
-   def element_class
-     FrameSet
-   end
- end
- class Marquee < HTMLElement
-   attributes(:string => [:behavior, :bg_color, :direction, :height, :width], :int => [:hspace, :loop, :scroll_amount, :scroll_delay, :vspace], :function => [:onbounce, :onfinish, :onstart], :bool => [:true_speed])
- end
- class MarqueeCollection < ElementCollection
-   def element_class
-     Marquee
-   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 Dialog < HTMLElement
-   attributes(:bool => [:open], :string => [:return_value])
- end
- class DialogCollection < ElementCollection
-   def element_class
-     Dialog
-   end
- end
- class MenuItem < HTMLElement
-   attributes(:bool => [:checked, :default, :disabled], :html_element => [:command], :string => [:icon, :label, :radiogroup, :type])
- end
- class MenuItemCollection < ElementCollection
-   def element_class
-     MenuItem
-   end
- end
- class Menu < HTMLElement
-   attributes(:string => [:label, :type])
- end
- class MenuCollection < ElementCollection
-   def element_class
-     Menu
-   end
- end
- class Menu < HTMLElement
-   attributes(:bool => [:compact])
- end
- # do nothing
- class Details < HTMLElement
-   attributes(:bool => [:open])
- end
- class DetailsCollection < ElementCollection
-   def element_class
-     Details
-   end
- end
- class Meter < HTMLElement
-   attributes(:float => [:high, :low, :max, :min, :optimum, :value], :list => [:labels])
- end
- class MeterCollection < ElementCollection
-   def element_class
-     Meter
-   end
- end
- class Progress < HTMLElement
-   attributes(:list => [:labels], :float => [:max, :position, :value])
- end
- class ProgressCollection < ElementCollection
-   def element_class
-     Progress
-   end
- end
- class Output < HTMLElement
-   attributes(:string => [:default_value, :name, :type, :validation_message, :validity, :value], :html_element => [:form], :token_list => [:html_for], :list => [:labels], :bool => [:will_validate])
- end
- class OutputCollection < ElementCollection
-   def element_class
-     Output
-   end
- end
- class Keygen < HTMLElement
-   attributes(:bool => [:autofocus, :disabled, :will_validate], :string => [:challenge, :keytype, :name, :type, :validation_message, :validity], :html_element => [:form], :list => [:labels])
- end
- class KeygenCollection < ElementCollection
-   def element_class
-     Keygen
-   end
- end
- class TextArea < HTMLElement
-   attributes(:string => [:autocomplete, :default_value, :dir_name, :input_mode, :name, :placeholder, :selection_direction, :type, :validation_message, :validity, :value, :wrap], :bool => [:autofocus, :disabled, :read_only, :required, :will_validate], :int => [:cols, :max_length, :rows, :selection_end, :selection_start, :text_length], :html_element => [:form], :list => [:labels])
- end
- class TextAreaCollection < ElementCollection
-   def element_class
-     TextArea
-   end
- end
- class Option < HTMLElement
-   attributes(:bool => [:default_selected, :disabled, :selected], :html_element => [:form], :int => [:index], :string => [:label, :text, :value])
- end
- class OptionCollection < ElementCollection
-   def element_class
-     Option
-   end
- end
- class OptGroup < HTMLElement
-   attributes(:bool => [:disabled], :string => [:label])
- end
- class OptGroupCollection < ElementCollection
-   def element_class
-     OptGroup
-   end
- end
- class DataList < HTMLElement
-   attributes(:html_collection => [:options])
- end
- class DataListCollection < ElementCollection
-   def element_class
-     DataList
-   end
- end
- class Select < HTMLElement
-   attributes(:bool => [:autofocus, :disabled, :multiple, :required, :will_validate], :html_element => [:form], :list => [:labels], :int => [:length, :selected_index, :size], :string => [:name, :type, :validation_message, :validity, :value], :html_collection => [:options, :selected_options])
- end
- class SelectCollection < ElementCollection
-   def element_class
-     Select
-   end
- end
- class Button < HTMLElement
-   attributes(:bool => [:autofocus, :disabled, :form_no_validate, :will_validate], :html_element => [:form, :menu], :string => [:form_action, :form_enctype, :form_method, :form_target, :name, :type, :validation_message, :validity, :value], :list => [:labels])
- end
- class ButtonCollection < ElementCollection
-   def element_class
-     Button
-   end
- end
- class Input < HTMLElement
-   attributes(:string => [:accept, :alt, :autocomplete, :default_value, :dir_name, :form_action, :form_enctype, :form_method, :form_target, :input_mode, :max, :min, :name, :pattern, :placeholder, :selection_direction, :src, :step, :type, :validation_message, :validity, :value], :bool => [:autofocus, :checked, :default_checked, :disabled, :form_no_validate, :indeterminate, :multiple, :read_only, :required, :will_validate], :list => [:files, :labels], :html_element => [:form, :list], :int => [:height, :max_length, :selection_end, :selection_start, :size, :width], :date => [:value_as_date], :float => [:value_as_number])
- 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(:html_element => [:control, :form], :string => [:html_for])
- 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 FieldSet < HTMLElement
-   attributes(:bool => [:disabled, :will_validate], :html_collection => [:elements], :html_element => [:form], :string => [:name, :type, :validation_message, :validity])
- end
- class FieldSetCollection < ElementCollection
-   def element_class
-     FieldSet
-   end
- end
- class Form < HTMLElement
-   attributes(:string => [:accept_charset, :action, :autocomplete, :encoding, :enctype, :method, :name, :target], :html_collection => [:elements], :int => [:length], :bool => [:no_validate])
- end
- class FormCollection < ElementCollection
-   def element_class
-     Form
-   end
- end
- class TableCell < HTMLElement
-   attributes(:int => [:cell_index, :col_span, :row_span], :token_list => [:headers])
- end
- class TableCellCollection < ElementCollection
-   def element_class
-     TableCell
-   end
- end
- class TableCell < HTMLElement
-   attributes(:string => [:align, :axis, :bg_color, :ch, :ch_off, :height, :v_align, :width], :bool => [:no_wrap])
- end
- # do nothing
- class TableHeaderCell < TableCell
-   attributes(:string => [:abbr, :scope, :sorted])
- 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 TableDataCell < TableCell
-   attributes(:string => [:abbr])
- end
- # do nothing
- class TableRow < HTMLElement
-   attributes(:html_collection => [:cells], :int => [:row_index, :section_row_index])
- 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 TableCaption < HTMLElement
-   # do nothing
- end
- class TableCaptionCollection < ElementCollection
-   def element_class
-     TableCaption
-   end
- end
- class TableCaption < HTMLElement
-   attributes(:string => [:align])
- end
- # do nothing
- class Table < HTMLElement
-   attributes(:html_element => [:caption, :t_foot, :t_head], :html_collection => [:rows, :t_bodies], :bool => [:sortable])
- 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, :summary, :width])
- end
- # do nothing
- class Area < HTMLElement
-   attributes(:string => [:alt, :coords, :download, :hreflang, :ping, :rel, :shape, :target, :type], :token_list => [:rel_list])
- end
- class AreaCollection < ElementCollection
-   def element_class
-     Area
-   end
- end
- class Area < HTMLElement
-   attributes(:bool => [:no_href])
- end
- # do nothing
- class Map < HTMLElement
-   attributes(:html_collection => [:areas, :images], :string => [:name])
- end
- class MapCollection < ElementCollection
-   def element_class
-     Map
-   end
- end
- class Canvas < HTMLElement
-   attributes(:int => [:height, :width])
- end
- class CanvasCollection < ElementCollection
-   def element_class
-     Canvas
-   end
- end
- class Media < HTMLElement
-   attributes(:list => [:audio_tracks, :text_tracks, :video_tracks], :bool => [:autoplay, :controls, :default_muted, :ended, :loop, :muted, :paused, :seeking], :string => [:buffered, :controller, :cross_origin, :current_src, :error, :media_group, :played, :preload, :seekable, :src], :float => [:current_time, :default_playback_rate, :duration, :playback_rate, :volume], :int => [:network_state, :ready_state])
- 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(:int => [:height, :video_height, :video_width, :width], :string => [:poster])
- end
- class VideoCollection < ElementCollection
-   def element_class
-     Video
-   end
- end
- class Track < HTMLElement
-   attributes(:bool => [:default], :string => [:kind, :label, :src, :srclang, :track], :int => [:ready_state])
- end
- class TrackCollection < ElementCollection
-   def element_class
-     Track
-   end
- end
- class Source < HTMLElement
-   attributes(:string => [:media, :src, :type])
- 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(:document => [:content_document], :string => [:content_window, :data, :height, :name, :type, :use_map, :validation_message, :validity, :width], :html_element => [:form], :bool => [:type_must_match, :will_validate])
- end
- class ObjectCollection < ElementCollection
-   def element_class
-     Object
-   end
- end
- class Object < HTMLElement
-   attributes(:string => [:align, :archive, :border, :code, :code_base, :code_type, :standby], :bool => [:declare], :int => [:hspace, :vspace])
- end
- # do nothing
- class Embed < HTMLElement
-   attributes(:string => [:height, :src, :type, :width])
- end
- class EmbedCollection < ElementCollection
-   def element_class
-     Embed
-   end
- end
- class Embed < HTMLElement
-   attributes(:string => [:align, :name])
- end
- # do nothing
- class IFrame < HTMLElement
-   attributes(:bool => [:allow_fullscreen, :seamless], :document => [:content_document], :string => [:content_window, :height, :name, :src, :srcdoc, :width], :token_list => [:sandbox])
- 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, :cross_origin, :src, :srcset, :use_map], :bool => [:complete, :map], :int => [:height, :natural_height, :natural_width, :width])
- end
- class ImageCollection < ElementCollection
-   def element_class
-     Image
-   end
- end
- class Image < HTMLElement
-   attributes(:string => [:align, :border, :long_desc, :lowsrc, :name], :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 Time < HTMLElement
-   attributes(:string => [:date_time])
- end
- class TimeCollection < ElementCollection
-   def element_class
-     Time
-   end
- end
- class Data < HTMLElement
-   attributes(:string => [:value])
- end
- class DataCollection < ElementCollection
-   def element_class
-     Data
-   end
- end
- class Anchor < HTMLElement
-   attributes(:string => [:download, :hreflang, :ping, :rel, :target, :text, :type], :token_list => [:rel_list])
- end
- class AnchorCollection < ElementCollection
-   def element_class
-     Anchor
-   end
- end
- class Anchor < HTMLElement
-   attributes(:string => [:charset, :coords, :name, :rev, :shape])
- end
- # do nothing
- 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 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 UList < HTMLElement
-   # do nothing
- end
- class UListCollection < ElementCollection
-   def element_class
-     UList
-   end
- end
- class UList < HTMLElement
-   attributes(:bool => [:compact], :string => [:type])
- end
- # do nothing
- class OList < HTMLElement
-   attributes(:bool => [:reversed], :int => [:start], :string => [:type])
- end
- class OListCollection < ElementCollection
-   def element_class
-     OList
-   end
- end
- class OList < HTMLElement
-   attributes(:bool => [:compact])
- end
- # do nothing
- class Quote < HTMLElement
-   attributes(:string => [:cite])
- end
- class QuoteCollection < ElementCollection
-   def element_class
-     Quote
-   end
- end
- 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, :onhashchange, :onmessage, :onoffline, :ononline, :onpagehide, :onpageshow, :onpopstate, :onresize, :onstorage, :onunload])
- end
- class BodyCollection < ElementCollection
-   def element_class
-     Body
-   end
- end
- class Body < HTMLElement
-   attributes(:string => [:a_link, :background, :bg_color, :link, :text, :v_link])
- end
- # do nothing
- class Template < HTMLElement
-   attributes(:document => [:content])
- end
- class TemplateCollection < ElementCollection
-   def element_class
-     Template
-   end
- end
- class Script < HTMLElement
-   attributes(:bool => [:async, :defer], :string => [:charset, :cross_origin, :src, :text, :type])
- 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(:bool => [:disabled, :scoped], :string => [:media, :type])
- end
- class StyleCollection < ElementCollection
-   def element_class
-     Style
-   end
- end
- class Meta < HTMLElement
-   attributes(:string => [:content, :http_equiv, :name])
- 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 Title < HTMLElement
-   attributes(:string => [:text])
- end
- class TitleCollection < ElementCollection
-   def element_class
-     Title
-   end
- end
- class Head < HTMLElement
-   # do nothing
- end
- class HeadCollection < ElementCollection
-   def element_class
-     Head
-   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 Unknown < HTMLElement
-   # do nothing
- end
- class UnknownCollection < ElementCollection
-   def element_class
-     Unknown
-   end
- 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
 
- module Container
-   #
-   # @return [Anchor]
-   #
+      Watir.tag_to_class[:cite] = HTMLElement
 
-   def a(*args)
-     Anchor.new(self, extract_selector(args).merge(:tag_name => "a"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [AnchorCollection]
-   #
+      def code(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "code"))
+      end
 
-   def as(*args)
-     AnchorCollection.new(self, extract_selector(args).merge(:tag_name => "a"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:a] = Anchor
-   #
-   # @return [HTMLElement]
-   #
+      def codes(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "code"))
+      end
 
-   def abbr(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "abbr"))
-   end
+      Watir.tag_to_class[:code] = HTMLElement
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [TableCol]
+      #
 
-   def abbrs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "abbr"))
-   end
+      def col(*args)
+        TableCol.new(self, extract_selector(args).merge(:tag_name => "col"))
+      end
 
-   Watir.tag_to_class[:abbr] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [TableColCollection]
+      #
 
-   def address(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "address"))
-   end
+      def cols(*args)
+        TableColCollection.new(self, extract_selector(args).merge(:tag_name => "col"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:col] = TableCol
 
-   def addresses(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "address"))
-   end
+      #
+      # @return [TableCol]
+      #
 
-   Watir.tag_to_class[:address] = HTMLElement
-   #
-   # @return [Area]
-   #
+      def colgroup(*args)
+        TableCol.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
+      end
 
-   def area(*args)
-     Area.new(self, extract_selector(args).merge(:tag_name => "area"))
-   end
+      #
+      # @return [TableColCollection]
+      #
 
-   #
-   # @return [AreaCollection]
-   #
+      def colgroups(*args)
+        TableColCollection.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
+      end
 
-   def areas(*args)
-     AreaCollection.new(self, extract_selector(args).merge(:tag_name => "area"))
-   end
+      Watir.tag_to_class[:colgroup] = TableCol
 
-   Watir.tag_to_class[:area] = Area
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [Data]
+      #
 
-   def article(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "article"))
-   end
+      def data(*args)
+        Data.new(self, extract_selector(args).merge(:tag_name => "data"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [DataCollection]
+      #
 
-   def articles(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "article"))
-   end
+      def datas(*args)
+        DataCollection.new(self, extract_selector(args).merge(:tag_name => "data"))
+      end
 
-   Watir.tag_to_class[:article] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:data] = Data
 
-   def aside(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "aside"))
-   end
+      #
+      # @return [DataList]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def datalist(*args)
+        DataList.new(self, extract_selector(args).merge(:tag_name => "datalist"))
+      end
 
-   def asides(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "aside"))
-   end
+      #
+      # @return [DataListCollection]
+      #
 
-   Watir.tag_to_class[:aside] = HTMLElement
-   #
-   # @return [Audio]
-   #
+      def datalists(*args)
+        DataListCollection.new(self, extract_selector(args).merge(:tag_name => "datalist"))
+      end
 
-   def audio(*args)
-     Audio.new(self, extract_selector(args).merge(:tag_name => "audio"))
-   end
+      Watir.tag_to_class[:datalist] = DataList
 
-   #
-   # @return [AudioCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def audios(*args)
-     AudioCollection.new(self, extract_selector(args).merge(:tag_name => "audio"))
-   end
+      def dd(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dd"))
+      end
 
-   Watir.tag_to_class[:audio] = Audio
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def b(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "b"))
-   end
+      def dds(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dd"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:dd] = HTMLElement
 
-   def bs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "b"))
-   end
+      #
+      # @return [Mod]
+      #
 
-   Watir.tag_to_class[:b] = HTMLElement
-   #
-   # @return [Base]
-   #
+      def del(*args)
+        Mod.new(self, extract_selector(args).merge(:tag_name => "del"))
+      end
 
-   def base(*args)
-     Base.new(self, extract_selector(args).merge(:tag_name => "base"))
-   end
+      #
+      # @return [ModCollection]
+      #
 
-   #
-   # @return [BaseCollection]
-   #
+      def dels(*args)
+        ModCollection.new(self, extract_selector(args).merge(:tag_name => "del"))
+      end
 
-   def bases(*args)
-     BaseCollection.new(self, extract_selector(args).merge(:tag_name => "base"))
-   end
+      Watir.tag_to_class[:del] = Mod
 
-   Watir.tag_to_class[:base] = Base
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [Details]
+      #
 
-   def bdi(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdi"))
-   end
+      def details(*args)
+        Details.new(self, extract_selector(args).merge(:tag_name => "details"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [DetailsCollection]
+      #
 
-   def bdis(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "bdi"))
-   end
+      def detailses(*args)
+        DetailsCollection.new(self, extract_selector(args).merge(:tag_name => "details"))
+      end
 
-   Watir.tag_to_class[:bdi] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:details] = Details
 
-   def bdo(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "bdo"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def dfn(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dfn"))
+      end
 
-   def bdos(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "bdo"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:bdo] = HTMLElement
-   #
-   # @return [Quote]
-   #
+      def dfns(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dfn"))
+      end
 
-   def blockquote(*args)
-     Quote.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
-   end
+      Watir.tag_to_class[:dfn] = HTMLElement
 
-   #
-   # @return [QuoteCollection]
-   #
+      #
+      # @return [Dialog]
+      #
 
-   def blockquotes(*args)
-     QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "blockquote"))
-   end
+      def dialog(*args)
+        Dialog.new(self, extract_selector(args).merge(:tag_name => "dialog"))
+      end
 
-   Watir.tag_to_class[:blockquote] = Quote
-   #
-   # @return [Body]
-   #
+      #
+      # @return [DialogCollection]
+      #
 
-   def body(*args)
-     Body.new(self, extract_selector(args).merge(:tag_name => "body"))
-   end
+      def dialogs(*args)
+        DialogCollection.new(self, extract_selector(args).merge(:tag_name => "dialog"))
+      end
 
-   #
-   # @return [BodyCollection]
-   #
+      Watir.tag_to_class[:dialog] = Dialog
 
-   def bodys(*args)
-     BodyCollection.new(self, extract_selector(args).merge(:tag_name => "body"))
-   end
+      #
+      # @return [Div]
+      #
 
-   Watir.tag_to_class[:body] = Body
-   #
-   # @return [BR]
-   #
+      def div(*args)
+        Div.new(self, extract_selector(args).merge(:tag_name => "div"))
+      end
 
-   def br(*args)
-     BR.new(self, extract_selector(args).merge(:tag_name => "br"))
-   end
+      #
+      # @return [DivCollection]
+      #
 
-   #
-   # @return [BRCollection]
-   #
+      def divs(*args)
+        DivCollection.new(self, extract_selector(args).merge(:tag_name => "div"))
+      end
 
-   def brs(*args)
-     BRCollection.new(self, extract_selector(args).merge(:tag_name => "br"))
-   end
+      Watir.tag_to_class[:div] = Div
 
-   Watir.tag_to_class[:br] = BR
-   #
-   # @return [Button]
-   #
+      #
+      # @return [DList]
+      #
 
-   def button(*args)
-     Button.new(self, extract_selector(args).merge(:tag_name => "button"))
-   end
+      def dl(*args)
+        DList.new(self, extract_selector(args).merge(:tag_name => "dl"))
+      end
 
-   #
-   # @return [ButtonCollection]
-   #
+      #
+      # @return [DListCollection]
+      #
 
-   def buttons(*args)
-     ButtonCollection.new(self, extract_selector(args).merge(:tag_name => "button"))
-   end
+      def dls(*args)
+        DListCollection.new(self, extract_selector(args).merge(:tag_name => "dl"))
+      end
 
-   Watir.tag_to_class[:button] = Button
-   #
-   # @return [Canvas]
-   #
+      Watir.tag_to_class[:dl] = DList
 
-   def canvas(*args)
-     Canvas.new(self, extract_selector(args).merge(:tag_name => "canvas"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [CanvasCollection]
-   #
+      def dt(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dt"))
+      end
 
-   def canvases(*args)
-     CanvasCollection.new(self, extract_selector(args).merge(:tag_name => "canvas"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:canvas] = Canvas
-   #
-   # @return [TableCaption]
-   #
+      def dts(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dt"))
+      end
 
-   def caption(*args)
-     TableCaption.new(self, extract_selector(args).merge(:tag_name => "caption"))
-   end
+      Watir.tag_to_class[:dt] = HTMLElement
 
-   #
-   # @return [TableCaptionCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def captions(*args)
-     TableCaptionCollection.new(self, extract_selector(args).merge(:tag_name => "caption"))
-   end
+      def em(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "em"))
+      end
 
-   Watir.tag_to_class[:caption] = TableCaption
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def cite(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "cite"))
-   end
+      def ems(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "em"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:em] = HTMLElement
 
-   def cites(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "cite"))
-   end
+      #
+      # @return [Embed]
+      #
 
-   Watir.tag_to_class[:cite] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def embed(*args)
+        Embed.new(self, extract_selector(args).merge(:tag_name => "embed"))
+      end
 
-   def code(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "code"))
-   end
+      #
+      # @return [EmbedCollection]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def embeds(*args)
+        EmbedCollection.new(self, extract_selector(args).merge(:tag_name => "embed"))
+      end
 
-   def codes(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "code"))
-   end
+      Watir.tag_to_class[:embed] = Embed
 
-   Watir.tag_to_class[:code] = HTMLElement
-   #
-   # @return [TableCol]
-   #
+      #
+      # @return [FieldSet]
+      #
 
-   def col(*args)
-     TableCol.new(self, extract_selector(args).merge(:tag_name => "col"))
-   end
+      def fieldset(*args)
+        FieldSet.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
+      end
 
-   #
-   # @return [TableColCollection]
-   #
+      #
+      # @return [FieldSetCollection]
+      #
 
-   def cols(*args)
-     TableColCollection.new(self, extract_selector(args).merge(:tag_name => "col"))
-   end
+      def fieldsets(*args)
+        FieldSetCollection.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
+      end
 
-   Watir.tag_to_class[:col] = TableCol
-   #
-   # @return [TableCol]
-   #
+      Watir.tag_to_class[:fieldset] = FieldSet
 
-   def colgroup(*args)
-     TableCol.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [TableColCollection]
-   #
+      def figcaption(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
+      end
 
-   def colgroups(*args)
-     TableColCollection.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:colgroup] = TableCol
-   #
-   # @return [Data]
-   #
+      def figcaptions(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
+      end
 
-   def data(*args)
-     Data.new(self, extract_selector(args).merge(:tag_name => "data"))
-   end
+      Watir.tag_to_class[:figcaption] = HTMLElement
 
-   #
-   # @return [DataCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def datas(*args)
-     DataCollection.new(self, extract_selector(args).merge(:tag_name => "data"))
-   end
+      def figure(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figure"))
+      end
 
-   Watir.tag_to_class[:data] = Data
-   #
-   # @return [DataList]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def datalist(*args)
-     DataList.new(self, extract_selector(args).merge(:tag_name => "datalist"))
-   end
+      def figures(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figure"))
+      end
 
-   #
-   # @return [DataListCollection]
-   #
+      Watir.tag_to_class[:figure] = HTMLElement
 
-   def datalists(*args)
-     DataListCollection.new(self, extract_selector(args).merge(:tag_name => "datalist"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   Watir.tag_to_class[:datalist] = DataList
-   #
-   # @return [HTMLElement]
-   #
+      def footer(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "footer"))
+      end
 
-   def dd(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dd"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def footers(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "footer"))
+      end
 
-   def dds(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dd"))
-   end
+      Watir.tag_to_class[:footer] = HTMLElement
 
-   Watir.tag_to_class[:dd] = HTMLElement
-   #
-   # @return [Mod]
-   #
+      #
+      # @return [Form]
+      #
 
-   def del(*args)
-     Mod.new(self, extract_selector(args).merge(:tag_name => "del"))
-   end
+      def form(*args)
+        Form.new(self, extract_selector(args).merge(:tag_name => "form"))
+      end
 
-   #
-   # @return [ModCollection]
-   #
+      #
+      # @return [FormCollection]
+      #
 
-   def dels(*args)
-     ModCollection.new(self, extract_selector(args).merge(:tag_name => "del"))
-   end
+      def forms(*args)
+        FormCollection.new(self, extract_selector(args).merge(:tag_name => "form"))
+      end
 
-   Watir.tag_to_class[:del] = Mod
-   #
-   # @return [Details]
-   #
+      Watir.tag_to_class[:form] = Form
 
-   def details(*args)
-     Details.new(self, extract_selector(args).merge(:tag_name => "details"))
-   end
+      #
+      # @return [FrameSet]
+      #
 
-   #
-   # @return [DetailsCollection]
-   #
+      def frameset(*args)
+        FrameSet.new(self, extract_selector(args).merge(:tag_name => "frameset"))
+      end
 
-   def detailses(*args)
-     DetailsCollection.new(self, extract_selector(args).merge(:tag_name => "details"))
-   end
+      #
+      # @return [FrameSetCollection]
+      #
 
-   Watir.tag_to_class[:details] = Details
-   #
-   # @return [HTMLElement]
-   #
+      def framesets(*args)
+        FrameSetCollection.new(self, extract_selector(args).merge(:tag_name => "frameset"))
+      end
 
-   def dfn(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dfn"))
-   end
+      Watir.tag_to_class[:frameset] = FrameSet
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [Heading]
+      #
 
-   def dfns(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dfn"))
-   end
+      def h1(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h1"))
+      end
 
-   Watir.tag_to_class[:dfn] = HTMLElement
-   #
-   # @return [Dialog]
-   #
+      #
+      # @return [HeadingCollection]
+      #
 
-   def dialog(*args)
-     Dialog.new(self, extract_selector(args).merge(:tag_name => "dialog"))
-   end
+      def h1s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h1"))
+      end
 
-   #
-   # @return [DialogCollection]
-   #
+      Watir.tag_to_class[:h1] = Heading
 
-   def dialogs(*args)
-     DialogCollection.new(self, extract_selector(args).merge(:tag_name => "dialog"))
-   end
+      #
+      # @return [Heading]
+      #
 
-   Watir.tag_to_class[:dialog] = Dialog
-   #
-   # @return [Div]
-   #
+      def h2(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h2"))
+      end
 
-   def div(*args)
-     Div.new(self, extract_selector(args).merge(:tag_name => "div"))
-   end
+      #
+      # @return [HeadingCollection]
+      #
 
-   #
-   # @return [DivCollection]
-   #
+      def h2s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h2"))
+      end
 
-   def divs(*args)
-     DivCollection.new(self, extract_selector(args).merge(:tag_name => "div"))
-   end
+      Watir.tag_to_class[:h2] = Heading
 
-   Watir.tag_to_class[:div] = Div
-   #
-   # @return [DList]
-   #
+      #
+      # @return [Heading]
+      #
 
-   def dl(*args)
-     DList.new(self, extract_selector(args).merge(:tag_name => "dl"))
-   end
+      def h3(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h3"))
+      end
 
-   #
-   # @return [DListCollection]
-   #
+      #
+      # @return [HeadingCollection]
+      #
 
-   def dls(*args)
-     DListCollection.new(self, extract_selector(args).merge(:tag_name => "dl"))
-   end
+      def h3s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h3"))
+      end
 
-   Watir.tag_to_class[:dl] = DList
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:h3] = Heading
 
-   def dt(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dt"))
-   end
+      #
+      # @return [Heading]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def h4(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h4"))
+      end
 
-   def dts(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dt"))
-   end
+      #
+      # @return [HeadingCollection]
+      #
 
-   Watir.tag_to_class[:dt] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def h4s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h4"))
+      end
 
-   def em(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "em"))
-   end
+      Watir.tag_to_class[:h4] = Heading
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [Heading]
+      #
 
-   def ems(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "em"))
-   end
+      def h5(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h5"))
+      end
 
-   Watir.tag_to_class[:em] = HTMLElement
-   #
-   # @return [Embed]
-   #
+      #
+      # @return [HeadingCollection]
+      #
 
-   def embed(*args)
-     Embed.new(self, extract_selector(args).merge(:tag_name => "embed"))
-   end
+      def h5s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h5"))
+      end
 
-   #
-   # @return [EmbedCollection]
-   #
+      Watir.tag_to_class[:h5] = Heading
 
-   def embeds(*args)
-     EmbedCollection.new(self, extract_selector(args).merge(:tag_name => "embed"))
-   end
+      #
+      # @return [Heading]
+      #
 
-   Watir.tag_to_class[:embed] = Embed
-   #
-   # @return [FieldSet]
-   #
+      def h6(*args)
+        Heading.new(self, extract_selector(args).merge(:tag_name => "h6"))
+      end
 
-   def fieldset(*args)
-     FieldSet.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
-   end
+      #
+      # @return [HeadingCollection]
+      #
 
-   #
-   # @return [FieldSetCollection]
-   #
+      def h6s(*args)
+        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h6"))
+      end
 
-   def fieldsets(*args)
-     FieldSetCollection.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
-   end
+      Watir.tag_to_class[:h6] = Heading
 
-   Watir.tag_to_class[:fieldset] = FieldSet
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [Head]
+      #
 
-   def figcaption(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
-   end
+      def head(*args)
+        Head.new(self, extract_selector(args).merge(:tag_name => "head"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HeadCollection]
+      #
 
-   def figcaptions(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
-   end
+      def heads(*args)
+        HeadCollection.new(self, extract_selector(args).merge(:tag_name => "head"))
+      end
 
-   Watir.tag_to_class[:figcaption] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:head] = Head
 
-   def figure(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figure"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def header(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "header"))
+      end
 
-   def figures(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figure"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:figure] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def headers(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "header"))
+      end
 
-   def footer(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "footer"))
-   end
+      Watir.tag_to_class[:header] = HTMLElement
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def footers(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "footer"))
-   end
+      def hgroup(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
+      end
 
-   Watir.tag_to_class[:footer] = HTMLElement
-   #
-   # @return [Form]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def form(*args)
-     Form.new(self, extract_selector(args).merge(:tag_name => "form"))
-   end
+      def hgroups(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
+      end
 
-   #
-   # @return [FormCollection]
-   #
+      Watir.tag_to_class[:hgroup] = HTMLElement
 
-   def forms(*args)
-     FormCollection.new(self, extract_selector(args).merge(:tag_name => "form"))
-   end
+      #
+      # @return [HR]
+      #
 
-   Watir.tag_to_class[:form] = Form
-   #
-   # @return [FrameSet]
-   #
+      def hr(*args)
+        HR.new(self, extract_selector(args).merge(:tag_name => "hr"))
+      end
 
-   def frameset(*args)
-     FrameSet.new(self, extract_selector(args).merge(:tag_name => "frameset"))
-   end
+      #
+      # @return [HRCollection]
+      #
 
-   #
-   # @return [FrameSetCollection]
-   #
+      def hrs(*args)
+        HRCollection.new(self, extract_selector(args).merge(:tag_name => "hr"))
+      end
 
-   def framesets(*args)
-     FrameSetCollection.new(self, extract_selector(args).merge(:tag_name => "frameset"))
-   end
+      Watir.tag_to_class[:hr] = HR
 
-   Watir.tag_to_class[:frameset] = FrameSet
-   #
-   # @return [Heading]
-   #
+      #
+      # @return [Html]
+      #
 
-   def h1(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h1"))
-   end
+      def html(*args)
+        Html.new(self, extract_selector(args).merge(:tag_name => "html"))
+      end
 
-   #
-   # @return [HeadingCollection]
-   #
+      #
+      # @return [HtmlCollection]
+      #
 
-   def h1s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h1"))
-   end
+      def htmls(*args)
+        HtmlCollection.new(self, extract_selector(args).merge(:tag_name => "html"))
+      end
 
-   Watir.tag_to_class[:h1] = Heading
-   #
-   # @return [Heading]
-   #
+      Watir.tag_to_class[:html] = Html
 
-   def h2(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h2"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HeadingCollection]
-   #
+      def i(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "i"))
+      end
 
-   def h2s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h2"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:h2] = Heading
-   #
-   # @return [Heading]
-   #
+      def is(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "i"))
+      end
 
-   def h3(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h3"))
-   end
+      Watir.tag_to_class[:i] = HTMLElement
 
-   #
-   # @return [HeadingCollection]
-   #
+      #
+      # @return [IFrame]
+      #
 
-   def h3s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h3"))
-   end
+      def iframe(*args)
+        IFrame.new(self, extract_selector(args).merge(:tag_name => "iframe"))
+      end
 
-   Watir.tag_to_class[:h3] = Heading
-   #
-   # @return [Heading]
-   #
+      #
+      # @return [IFrameCollection]
+      #
 
-   def h4(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h4"))
-   end
+      def iframes(*args)
+        IFrameCollection.new(self, extract_selector(args).merge(:tag_name => "iframe"))
+      end
 
-   #
-   # @return [HeadingCollection]
-   #
+      Watir.tag_to_class[:iframe] = IFrame
 
-   def h4s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h4"))
-   end
+      #
+      # @return [Image]
+      #
 
-   Watir.tag_to_class[:h4] = Heading
-   #
-   # @return [Heading]
-   #
+      def img(*args)
+        Image.new(self, extract_selector(args).merge(:tag_name => "img"))
+      end
 
-   def h5(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h5"))
-   end
+      #
+      # @return [ImageCollection]
+      #
 
-   #
-   # @return [HeadingCollection]
-   #
+      def imgs(*args)
+        ImageCollection.new(self, extract_selector(args).merge(:tag_name => "img"))
+      end
 
-   def h5s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h5"))
-   end
+      Watir.tag_to_class[:img] = Image
 
-   Watir.tag_to_class[:h5] = Heading
-   #
-   # @return [Heading]
-   #
+      #
+      # @return [Input]
+      #
 
-   def h6(*args)
-     Heading.new(self, extract_selector(args).merge(:tag_name => "h6"))
-   end
+      def input(*args)
+        Input.new(self, extract_selector(args).merge(:tag_name => "input"))
+      end
 
-   #
-   # @return [HeadingCollection]
-   #
+      #
+      # @return [InputCollection]
+      #
 
-   def h6s(*args)
-     HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h6"))
-   end
+      def inputs(*args)
+        InputCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
+      end
 
-   Watir.tag_to_class[:h6] = Heading
-   #
-   # @return [Head]
-   #
+      Watir.tag_to_class[:input] = Input
 
-   def head(*args)
-     Head.new(self, extract_selector(args).merge(:tag_name => "head"))
-   end
+      #
+      # @return [Mod]
+      #
 
-   #
-   # @return [HeadCollection]
-   #
+      def ins(*args)
+        Mod.new(self, extract_selector(args).merge(:tag_name => "ins"))
+      end
 
-   def heads(*args)
-     HeadCollection.new(self, extract_selector(args).merge(:tag_name => "head"))
-   end
+      #
+      # @return [ModCollection]
+      #
 
-   Watir.tag_to_class[:head] = Head
-   #
-   # @return [HTMLElement]
-   #
+      def inses(*args)
+        ModCollection.new(self, extract_selector(args).merge(:tag_name => "ins"))
+      end
 
-   def header(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "header"))
-   end
+      Watir.tag_to_class[:ins] = Mod
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def headers(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "header"))
-   end
+      def kbd(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "kbd"))
+      end
 
-   Watir.tag_to_class[:header] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def hgroup(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
-   end
+      def kbds(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "kbd"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:kbd] = HTMLElement
 
-   def hgroups(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
-   end
+      #
+      # @return [Keygen]
+      #
 
-   Watir.tag_to_class[:hgroup] = HTMLElement
-   #
-   # @return [HR]
-   #
+      def keygen(*args)
+        Keygen.new(self, extract_selector(args).merge(:tag_name => "keygen"))
+      end
 
-   def hr(*args)
-     HR.new(self, extract_selector(args).merge(:tag_name => "hr"))
-   end
+      #
+      # @return [KeygenCollection]
+      #
 
-   #
-   # @return [HRCollection]
-   #
+      def keygens(*args)
+        KeygenCollection.new(self, extract_selector(args).merge(:tag_name => "keygen"))
+      end
 
-   def hrs(*args)
-     HRCollection.new(self, extract_selector(args).merge(:tag_name => "hr"))
-   end
+      Watir.tag_to_class[:keygen] = Keygen
 
-   Watir.tag_to_class[:hr] = HR
-   #
-   # @return [Html]
-   #
+      #
+      # @return [Label]
+      #
 
-   def html(*args)
-     Html.new(self, extract_selector(args).merge(:tag_name => "html"))
-   end
+      def label(*args)
+        Label.new(self, extract_selector(args).merge(:tag_name => "label"))
+      end
 
-   #
-   # @return [HtmlCollection]
-   #
+      #
+      # @return [LabelCollection]
+      #
 
-   def htmls(*args)
-     HtmlCollection.new(self, extract_selector(args).merge(:tag_name => "html"))
-   end
+      def labels(*args)
+        LabelCollection.new(self, extract_selector(args).merge(:tag_name => "label"))
+      end
 
-   Watir.tag_to_class[:html] = Html
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:label] = Label
 
-   def i(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "i"))
-   end
+      #
+      # @return [Legend]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def legend(*args)
+        Legend.new(self, extract_selector(args).merge(:tag_name => "legend"))
+      end
 
-   def is(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "i"))
-   end
+      #
+      # @return [LegendCollection]
+      #
 
-   Watir.tag_to_class[:i] = HTMLElement
-   #
-   # @return [IFrame]
-   #
+      def legends(*args)
+        LegendCollection.new(self, extract_selector(args).merge(:tag_name => "legend"))
+      end
 
-   def iframe(*args)
-     IFrame.new(self, extract_selector(args).merge(:tag_name => "iframe"))
-   end
+      Watir.tag_to_class[:legend] = Legend
 
-   #
-   # @return [IFrameCollection]
-   #
+      #
+      # @return [LI]
+      #
 
-   def iframes(*args)
-     IFrameCollection.new(self, extract_selector(args).merge(:tag_name => "iframe"))
-   end
+      def li(*args)
+        LI.new(self, extract_selector(args).merge(:tag_name => "li"))
+      end
 
-   Watir.tag_to_class[:iframe] = IFrame
-   #
-   # @return [Image]
-   #
+      #
+      # @return [LICollection]
+      #
 
-   def img(*args)
-     Image.new(self, extract_selector(args).merge(:tag_name => "img"))
-   end
+      def lis(*args)
+        LICollection.new(self, extract_selector(args).merge(:tag_name => "li"))
+      end
 
-   #
-   # @return [ImageCollection]
-   #
+      Watir.tag_to_class[:li] = LI
 
-   def imgs(*args)
-     ImageCollection.new(self, extract_selector(args).merge(:tag_name => "img"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   Watir.tag_to_class[:img] = Image
-   #
-   # @return [Input]
-   #
+      def main(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "main"))
+      end
 
-   def input(*args)
-     Input.new(self, extract_selector(args).merge(:tag_name => "input"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   #
-   # @return [InputCollection]
-   #
+      def mains(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "main"))
+      end
 
-   def inputs(*args)
-     InputCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
-   end
+      Watir.tag_to_class[:main] = HTMLElement
 
-   Watir.tag_to_class[:input] = Input
-   #
-   # @return [Mod]
-   #
+      #
+      # @return [Map]
+      #
 
-   def ins(*args)
-     Mod.new(self, extract_selector(args).merge(:tag_name => "ins"))
-   end
+      def map(*args)
+        Map.new(self, extract_selector(args).merge(:tag_name => "map"))
+      end
 
-   #
-   # @return [ModCollection]
-   #
+      #
+      # @return [MapCollection]
+      #
 
-   def inses(*args)
-     ModCollection.new(self, extract_selector(args).merge(:tag_name => "ins"))
-   end
+      def maps(*args)
+        MapCollection.new(self, extract_selector(args).merge(:tag_name => "map"))
+      end
 
-   Watir.tag_to_class[:ins] = Mod
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:map] = Map
 
-   def kbd(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "kbd"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def mark(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "mark"))
+      end
 
-   def kbds(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "kbd"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:kbd] = HTMLElement
-   #
-   # @return [Keygen]
-   #
+      def marks(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "mark"))
+      end
 
-   def keygen(*args)
-     Keygen.new(self, extract_selector(args).merge(:tag_name => "keygen"))
-   end
+      Watir.tag_to_class[:mark] = HTMLElement
 
-   #
-   # @return [KeygenCollection]
-   #
+      #
+      # @return [Menu]
+      #
 
-   def keygens(*args)
-     KeygenCollection.new(self, extract_selector(args).merge(:tag_name => "keygen"))
-   end
+      def menu(*args)
+        Menu.new(self, extract_selector(args).merge(:tag_name => "menu"))
+      end
 
-   Watir.tag_to_class[:keygen] = Keygen
-   #
-   # @return [Label]
-   #
+      #
+      # @return [MenuCollection]
+      #
 
-   def label(*args)
-     Label.new(self, extract_selector(args).merge(:tag_name => "label"))
-   end
+      def menus(*args)
+        MenuCollection.new(self, extract_selector(args).merge(:tag_name => "menu"))
+      end
 
-   #
-   # @return [LabelCollection]
-   #
+      Watir.tag_to_class[:menu] = Menu
 
-   def labels(*args)
-     LabelCollection.new(self, extract_selector(args).merge(:tag_name => "label"))
-   end
+      #
+      # @return [MenuItem]
+      #
 
-   Watir.tag_to_class[:label] = Label
-   #
-   # @return [Legend]
-   #
+      def menuitem(*args)
+        MenuItem.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
+      end
 
-   def legend(*args)
-     Legend.new(self, extract_selector(args).merge(:tag_name => "legend"))
-   end
+      #
+      # @return [MenuItemCollection]
+      #
 
-   #
-   # @return [LegendCollection]
-   #
+      def menuitems(*args)
+        MenuItemCollection.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
+      end
 
-   def legends(*args)
-     LegendCollection.new(self, extract_selector(args).merge(:tag_name => "legend"))
-   end
+      Watir.tag_to_class[:menuitem] = MenuItem
 
-   Watir.tag_to_class[:legend] = Legend
-   #
-   # @return [LI]
-   #
+      #
+      # @return [Meta]
+      #
 
-   def li(*args)
-     LI.new(self, extract_selector(args).merge(:tag_name => "li"))
-   end
+      def meta(*args)
+        Meta.new(self, extract_selector(args).merge(:tag_name => "meta"))
+      end
 
-   #
-   # @return [LICollection]
-   #
+      #
+      # @return [MetaCollection]
+      #
 
-   def lis(*args)
-     LICollection.new(self, extract_selector(args).merge(:tag_name => "li"))
-   end
+      def metas(*args)
+        MetaCollection.new(self, extract_selector(args).merge(:tag_name => "meta"))
+      end
 
-   Watir.tag_to_class[:li] = LI
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:meta] = Meta
 
-   def main(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "main"))
-   end
+      #
+      # @return [Meter]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def meter(*args)
+        Meter.new(self, extract_selector(args).merge(:tag_name => "meter"))
+      end
 
-   def mains(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "main"))
-   end
+      #
+      # @return [MeterCollection]
+      #
 
-   Watir.tag_to_class[:main] = HTMLElement
-   #
-   # @return [Map]
-   #
+      def meters(*args)
+        MeterCollection.new(self, extract_selector(args).merge(:tag_name => "meter"))
+      end
 
-   def map(*args)
-     Map.new(self, extract_selector(args).merge(:tag_name => "map"))
-   end
+      Watir.tag_to_class[:meter] = Meter
 
-   #
-   # @return [MapCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def maps(*args)
-     MapCollection.new(self, extract_selector(args).merge(:tag_name => "map"))
-   end
+      def nav(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "nav"))
+      end
 
-   Watir.tag_to_class[:map] = Map
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def mark(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "mark"))
-   end
+      def navs(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "nav"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:nav] = HTMLElement
 
-   def marks(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "mark"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   Watir.tag_to_class[:mark] = HTMLElement
-   #
-   # @return [Menu]
-   #
+      def noscript(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "noscript"))
+      end
 
-   def menu(*args)
-     Menu.new(self, extract_selector(args).merge(:tag_name => "menu"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   #
-   # @return [MenuCollection]
-   #
+      def noscripts(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "noscript"))
+      end
 
-   def menus(*args)
-     MenuCollection.new(self, extract_selector(args).merge(:tag_name => "menu"))
-   end
+      Watir.tag_to_class[:noscript] = HTMLElement
 
-   Watir.tag_to_class[:menu] = Menu
-   #
-   # @return [MenuItem]
-   #
+      #
+      # @return [Object]
+      #
 
-   def menuitem(*args)
-     MenuItem.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
-   end
+      def object(*args)
+        Object.new(self, extract_selector(args).merge(:tag_name => "object"))
+      end
 
-   #
-   # @return [MenuItemCollection]
-   #
+      #
+      # @return [ObjectCollection]
+      #
 
-   def menuitems(*args)
-     MenuItemCollection.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
-   end
+      def objects(*args)
+        ObjectCollection.new(self, extract_selector(args).merge(:tag_name => "object"))
+      end
 
-   Watir.tag_to_class[:menuitem] = MenuItem
-   #
-   # @return [Meta]
-   #
+      Watir.tag_to_class[:object] = Object
 
-   def meta(*args)
-     Meta.new(self, extract_selector(args).merge(:tag_name => "meta"))
-   end
+      #
+      # @return [OList]
+      #
 
-   #
-   # @return [MetaCollection]
-   #
+      def ol(*args)
+        OList.new(self, extract_selector(args).merge(:tag_name => "ol"))
+      end
 
-   def metas(*args)
-     MetaCollection.new(self, extract_selector(args).merge(:tag_name => "meta"))
-   end
+      #
+      # @return [OListCollection]
+      #
 
-   Watir.tag_to_class[:meta] = Meta
-   #
-   # @return [Meter]
-   #
+      def ols(*args)
+        OListCollection.new(self, extract_selector(args).merge(:tag_name => "ol"))
+      end
 
-   def meter(*args)
-     Meter.new(self, extract_selector(args).merge(:tag_name => "meter"))
-   end
+      Watir.tag_to_class[:ol] = OList
 
-   #
-   # @return [MeterCollection]
-   #
+      #
+      # @return [OptGroup]
+      #
 
-   def meters(*args)
-     MeterCollection.new(self, extract_selector(args).merge(:tag_name => "meter"))
-   end
+      def optgroup(*args)
+        OptGroup.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
+      end
 
-   Watir.tag_to_class[:meter] = Meter
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [OptGroupCollection]
+      #
 
-   def nav(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "nav"))
-   end
+      def optgroups(*args)
+        OptGroupCollection.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:optgroup] = OptGroup
 
-   def navs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "nav"))
-   end
+      #
+      # @return [Option]
+      #
 
-   Watir.tag_to_class[:nav] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def option(*args)
+        Option.new(self, extract_selector(args).merge(:tag_name => "option"))
+      end
 
-   def noscript(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "noscript"))
-   end
+      #
+      # @return [OptionCollection]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def options(*args)
+        OptionCollection.new(self, extract_selector(args).merge(:tag_name => "option"))
+      end
 
-   def noscripts(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "noscript"))
-   end
+      Watir.tag_to_class[:option] = Option
 
-   Watir.tag_to_class[:noscript] = HTMLElement
-   #
-   # @return [Object]
-   #
+      #
+      # @return [Output]
+      #
 
-   def object(*args)
-     Object.new(self, extract_selector(args).merge(:tag_name => "object"))
-   end
+      def output(*args)
+        Output.new(self, extract_selector(args).merge(:tag_name => "output"))
+      end
 
-   #
-   # @return [ObjectCollection]
-   #
+      #
+      # @return [OutputCollection]
+      #
 
-   def objects(*args)
-     ObjectCollection.new(self, extract_selector(args).merge(:tag_name => "object"))
-   end
+      def outputs(*args)
+        OutputCollection.new(self, extract_selector(args).merge(:tag_name => "output"))
+      end
 
-   Watir.tag_to_class[:object] = Object
-   #
-   # @return [OList]
-   #
+      Watir.tag_to_class[:output] = Output
 
-   def ol(*args)
-     OList.new(self, extract_selector(args).merge(:tag_name => "ol"))
-   end
+      #
+      # @return [Paragraph]
+      #
 
-   #
-   # @return [OListCollection]
-   #
+      def p(*args)
+        Paragraph.new(self, extract_selector(args).merge(:tag_name => "p"))
+      end
 
-   def ols(*args)
-     OListCollection.new(self, extract_selector(args).merge(:tag_name => "ol"))
-   end
+      #
+      # @return [ParagraphCollection]
+      #
 
-   Watir.tag_to_class[:ol] = OList
-   #
-   # @return [OptGroup]
-   #
+      def ps(*args)
+        ParagraphCollection.new(self, extract_selector(args).merge(:tag_name => "p"))
+      end
 
-   def optgroup(*args)
-     OptGroup.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
-   end
+      Watir.tag_to_class[:p] = Paragraph
 
-   #
-   # @return [OptGroupCollection]
-   #
+      #
+      # @return [Param]
+      #
 
-   def optgroups(*args)
-     OptGroupCollection.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
-   end
+      def param(*args)
+        Param.new(self, extract_selector(args).merge(:tag_name => "param"))
+      end
 
-   Watir.tag_to_class[:optgroup] = OptGroup
-   #
-   # @return [Option]
-   #
+      #
+      # @return [ParamCollection]
+      #
 
-   def option(*args)
-     Option.new(self, extract_selector(args).merge(:tag_name => "option"))
-   end
+      def params(*args)
+        ParamCollection.new(self, extract_selector(args).merge(:tag_name => "param"))
+      end
 
-   #
-   # @return [OptionCollection]
-   #
+      Watir.tag_to_class[:param] = Param
 
-   def options(*args)
-     OptionCollection.new(self, extract_selector(args).merge(:tag_name => "option"))
-   end
+      #
+      # @return [Pre]
+      #
 
-   Watir.tag_to_class[:option] = Option
-   #
-   # @return [Output]
-   #
+      def pre(*args)
+        Pre.new(self, extract_selector(args).merge(:tag_name => "pre"))
+      end
 
-   def output(*args)
-     Output.new(self, extract_selector(args).merge(:tag_name => "output"))
-   end
+      #
+      # @return [PreCollection]
+      #
 
-   #
-   # @return [OutputCollection]
-   #
+      def pres(*args)
+        PreCollection.new(self, extract_selector(args).merge(:tag_name => "pre"))
+      end
 
-   def outputs(*args)
-     OutputCollection.new(self, extract_selector(args).merge(:tag_name => "output"))
-   end
+      Watir.tag_to_class[:pre] = Pre
 
-   Watir.tag_to_class[:output] = Output
-   #
-   # @return [Paragraph]
-   #
+      #
+      # @return [Progress]
+      #
 
-   def p(*args)
-     Paragraph.new(self, extract_selector(args).merge(:tag_name => "p"))
-   end
+      def progress(*args)
+        Progress.new(self, extract_selector(args).merge(:tag_name => "progress"))
+      end
 
-   #
-   # @return [ParagraphCollection]
-   #
+      #
+      # @return [ProgressCollection]
+      #
 
-   def ps(*args)
-     ParagraphCollection.new(self, extract_selector(args).merge(:tag_name => "p"))
-   end
+      def progresses(*args)
+        ProgressCollection.new(self, extract_selector(args).merge(:tag_name => "progress"))
+      end
 
-   Watir.tag_to_class[:p] = Paragraph
-   #
-   # @return [Param]
-   #
+      Watir.tag_to_class[:progress] = Progress
 
-   def param(*args)
-     Param.new(self, extract_selector(args).merge(:tag_name => "param"))
-   end
+      #
+      # @return [Quote]
+      #
 
-   #
-   # @return [ParamCollection]
-   #
+      def q(*args)
+        Quote.new(self, extract_selector(args).merge(:tag_name => "q"))
+      end
 
-   def params(*args)
-     ParamCollection.new(self, extract_selector(args).merge(:tag_name => "param"))
-   end
+      #
+      # @return [QuoteCollection]
+      #
 
-   Watir.tag_to_class[:param] = Param
-   #
-   # @return [Pre]
-   #
+      def qs(*args)
+        QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "q"))
+      end
 
-   def pre(*args)
-     Pre.new(self, extract_selector(args).merge(:tag_name => "pre"))
-   end
+      Watir.tag_to_class[:q] = Quote
 
-   #
-   # @return [PreCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def pres(*args)
-     PreCollection.new(self, extract_selector(args).merge(:tag_name => "pre"))
-   end
+      def rp(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rp"))
+      end
 
-   Watir.tag_to_class[:pre] = Pre
-   #
-   # @return [Progress]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def progress(*args)
-     Progress.new(self, extract_selector(args).merge(:tag_name => "progress"))
-   end
+      def rps(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rp"))
+      end
 
-   #
-   # @return [ProgressCollection]
-   #
+      Watir.tag_to_class[:rp] = HTMLElement
 
-   def progresses(*args)
-     ProgressCollection.new(self, extract_selector(args).merge(:tag_name => "progress"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   Watir.tag_to_class[:progress] = Progress
-   #
-   # @return [Quote]
-   #
+      def rt(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rt"))
+      end
 
-   def q(*args)
-     Quote.new(self, extract_selector(args).merge(:tag_name => "q"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   #
-   # @return [QuoteCollection]
-   #
+      def rts(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rt"))
+      end
 
-   def qs(*args)
-     QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "q"))
-   end
+      Watir.tag_to_class[:rt] = HTMLElement
 
-   Watir.tag_to_class[:q] = Quote
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def rp(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rp"))
-   end
+      def ruby(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "ruby"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def rps(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rp"))
-   end
+      def rubies(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "ruby"))
+      end
 
-   Watir.tag_to_class[:rp] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:ruby] = HTMLElement
 
-   def rt(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rt"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def s(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "s"))
+      end
 
-   def rts(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rt"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:rt] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def ss(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "s"))
+      end
 
-   def ruby(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "ruby"))
-   end
+      Watir.tag_to_class[:s] = HTMLElement
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def rubies(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "ruby"))
-   end
+      def samp(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "samp"))
+      end
 
-   Watir.tag_to_class[:ruby] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def s(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "s"))
-   end
+      def samps(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "samp"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:samp] = HTMLElement
 
-   def ss(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "s"))
-   end
+      #
+      # @return [Script]
+      #
 
-   Watir.tag_to_class[:s] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def script(*args)
+        Script.new(self, extract_selector(args).merge(:tag_name => "script"))
+      end
 
-   def samp(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "samp"))
-   end
+      #
+      # @return [ScriptCollection]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def scripts(*args)
+        ScriptCollection.new(self, extract_selector(args).merge(:tag_name => "script"))
+      end
 
-   def samps(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "samp"))
-   end
+      Watir.tag_to_class[:script] = Script
 
-   Watir.tag_to_class[:samp] = HTMLElement
-   #
-   # @return [Script]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def script(*args)
-     Script.new(self, extract_selector(args).merge(:tag_name => "script"))
-   end
+      def section(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "section"))
+      end
 
-   #
-   # @return [ScriptCollection]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def scripts(*args)
-     ScriptCollection.new(self, extract_selector(args).merge(:tag_name => "script"))
-   end
+      def sections(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "section"))
+      end
 
-   Watir.tag_to_class[:script] = Script
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:section] = HTMLElement
 
-   def section(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "section"))
-   end
+      #
+      # @return [Select]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def select(*args)
+        Select.new(self, extract_selector(args).merge(:tag_name => "select"))
+      end
 
-   def sections(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "section"))
-   end
+      #
+      # @return [SelectCollection]
+      #
 
-   Watir.tag_to_class[:section] = HTMLElement
-   #
-   # @return [Select]
-   #
+      def selects(*args)
+        SelectCollection.new(self, extract_selector(args).merge(:tag_name => "select"))
+      end
 
-   def select(*args)
-     Select.new(self, extract_selector(args).merge(:tag_name => "select"))
-   end
+      Watir.tag_to_class[:select] = Select
 
-   #
-   # @return [SelectCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def selects(*args)
-     SelectCollection.new(self, extract_selector(args).merge(:tag_name => "select"))
-   end
+      def small(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "small"))
+      end
 
-   Watir.tag_to_class[:select] = Select
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def small(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "small"))
-   end
+      def smalls(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "small"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:small] = HTMLElement
 
-   def smalls(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "small"))
-   end
+      #
+      # @return [Source]
+      #
 
-   Watir.tag_to_class[:small] = HTMLElement
-   #
-   # @return [Source]
-   #
+      def source(*args)
+        Source.new(self, extract_selector(args).merge(:tag_name => "source"))
+      end
 
-   def source(*args)
-     Source.new(self, extract_selector(args).merge(:tag_name => "source"))
-   end
+      #
+      # @return [SourceCollection]
+      #
 
-   #
-   # @return [SourceCollection]
-   #
+      def sources(*args)
+        SourceCollection.new(self, extract_selector(args).merge(:tag_name => "source"))
+      end
 
-   def sources(*args)
-     SourceCollection.new(self, extract_selector(args).merge(:tag_name => "source"))
-   end
+      Watir.tag_to_class[:source] = Source
 
-   Watir.tag_to_class[:source] = Source
-   #
-   # @return [Span]
-   #
+      #
+      # @return [Span]
+      #
 
-   def span(*args)
-     Span.new(self, extract_selector(args).merge(:tag_name => "span"))
-   end
+      def span(*args)
+        Span.new(self, extract_selector(args).merge(:tag_name => "span"))
+      end
 
-   #
-   # @return [SpanCollection]
-   #
+      #
+      # @return [SpanCollection]
+      #
 
-   def spans(*args)
-     SpanCollection.new(self, extract_selector(args).merge(:tag_name => "span"))
-   end
+      def spans(*args)
+        SpanCollection.new(self, extract_selector(args).merge(:tag_name => "span"))
+      end
 
-   Watir.tag_to_class[:span] = Span
-   #
-   # @return [HTMLElement]
-   #
+      Watir.tag_to_class[:span] = Span
 
-   def strong(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "strong"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def strong(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "strong"))
+      end
 
-   def strongs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "strong"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:strong] = HTMLElement
-   #
-   # @return [Style]
-   #
+      def strongs(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "strong"))
+      end
 
-   def style(*args)
-     Style.new(self, extract_selector(args).merge(:tag_name => "style"))
-   end
+      Watir.tag_to_class[:strong] = HTMLElement
 
-   #
-   # @return [StyleCollection]
-   #
+      #
+      # @return [Style]
+      #
 
-   def styles(*args)
-     StyleCollection.new(self, extract_selector(args).merge(:tag_name => "style"))
-   end
+      def style(*args)
+        Style.new(self, extract_selector(args).merge(:tag_name => "style"))
+      end
 
-   Watir.tag_to_class[:style] = Style
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [StyleCollection]
+      #
 
-   def sub(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sub"))
-   end
+      def styles(*args)
+        StyleCollection.new(self, extract_selector(args).merge(:tag_name => "style"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:style] = Style
 
-   def subs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sub"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   Watir.tag_to_class[:sub] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      def sub(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sub"))
+      end
 
-   def summary(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "summary"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      def subs(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sub"))
+      end
 
-   def summaries(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "summary"))
-   end
+      Watir.tag_to_class[:sub] = HTMLElement
 
-   Watir.tag_to_class[:summary] = HTMLElement
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def sup(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sup"))
-   end
+      def summary(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "summary"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   def sups(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sup"))
-   end
+      def summaries(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "summary"))
+      end
 
-   Watir.tag_to_class[:sup] = HTMLElement
-   #
-   # @return [Table]
-   #
+      Watir.tag_to_class[:summary] = HTMLElement
 
-   def table(*args)
-     Table.new(self, extract_selector(args).merge(:tag_name => "table"))
-   end
+      #
+      # @return [HTMLElement]
+      #
 
-   #
-   # @return [TableCollection]
-   #
+      def sup(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sup"))
+      end
 
-   def tables(*args)
-     TableCollection.new(self, extract_selector(args).merge(:tag_name => "table"))
-   end
+      #
+      # @return [HTMLElementCollection]
+      #
 
-   Watir.tag_to_class[:table] = Table
-   #
-   # @return [TableSection]
-   #
+      def sups(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sup"))
+      end
 
-   def tbody(*args)
-     TableSection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
-   end
+      Watir.tag_to_class[:sup] = HTMLElement
 
-   #
-   # @return [TableSectionCollection]
-   #
+      #
+      # @return [Table]
+      #
 
-   def tbodys(*args)
-     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
-   end
+      def table(*args)
+        Table.new(self, extract_selector(args).merge(:tag_name => "table"))
+      end
 
-   Watir.tag_to_class[:tbody] = TableSection
-   #
-   # @return [TableDataCell]
-   #
+      #
+      # @return [TableCollection]
+      #
 
-   def td(*args)
-     TableDataCell.new(self, extract_selector(args).merge(:tag_name => "td"))
-   end
+      def tables(*args)
+        TableCollection.new(self, extract_selector(args).merge(:tag_name => "table"))
+      end
 
-   #
-   # @return [TableDataCellCollection]
-   #
+      Watir.tag_to_class[:table] = Table
 
-   def tds(*args)
-     TableDataCellCollection.new(self, extract_selector(args).merge(:tag_name => "td"))
-   end
+      #
+      # @return [TableSection]
+      #
 
-   Watir.tag_to_class[:td] = TableDataCell
-   #
-   # @return [Template]
-   #
+      def tbody(*args)
+        TableSection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
+      end
 
-   def template(*args)
-     Template.new(self, extract_selector(args).merge(:tag_name => "template"))
-   end
+      #
+      # @return [TableSectionCollection]
+      #
 
-   #
-   # @return [TemplateCollection]
-   #
+      def tbodys(*args)
+        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
+      end
 
-   def templates(*args)
-     TemplateCollection.new(self, extract_selector(args).merge(:tag_name => "template"))
-   end
+      Watir.tag_to_class[:tbody] = TableSection
 
-   Watir.tag_to_class[:template] = Template
-   #
-   # @return [TextArea]
-   #
+      #
+      # @return [TableDataCell]
+      #
 
-   def textarea(*args)
-     TextArea.new(self, extract_selector(args).merge(:tag_name => "textarea"))
-   end
+      def td(*args)
+        TableDataCell.new(self, extract_selector(args).merge(:tag_name => "td"))
+      end
 
-   #
-   # @return [TextAreaCollection]
-   #
+      #
+      # @return [TableDataCellCollection]
+      #
 
-   def textareas(*args)
-     TextAreaCollection.new(self, extract_selector(args).merge(:tag_name => "textarea"))
-   end
+      def tds(*args)
+        TableDataCellCollection.new(self, extract_selector(args).merge(:tag_name => "td"))
+      end
 
-   Watir.tag_to_class[:textarea] = TextArea
-   #
-   # @return [TableSection]
-   #
+      Watir.tag_to_class[:td] = TableDataCell
 
-   def tfoot(*args)
-     TableSection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
-   end
+      #
+      # @return [Template]
+      #
 
-   #
-   # @return [TableSectionCollection]
-   #
+      def template(*args)
+        Template.new(self, extract_selector(args).merge(:tag_name => "template"))
+      end
 
-   def tfoots(*args)
-     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
-   end
+      #
+      # @return [TemplateCollection]
+      #
 
-   Watir.tag_to_class[:tfoot] = TableSection
-   #
-   # @return [TableHeaderCell]
-   #
+      def templates(*args)
+        TemplateCollection.new(self, extract_selector(args).merge(:tag_name => "template"))
+      end
 
-   def th(*args)
-     TableHeaderCell.new(self, extract_selector(args).merge(:tag_name => "th"))
-   end
+      Watir.tag_to_class[:template] = Template
 
-   #
-   # @return [TableHeaderCellCollection]
-   #
+      #
+      # @return [TextArea]
+      #
 
-   def ths(*args)
-     TableHeaderCellCollection.new(self, extract_selector(args).merge(:tag_name => "th"))
-   end
+      def textarea(*args)
+        TextArea.new(self, extract_selector(args).merge(:tag_name => "textarea"))
+      end
 
-   Watir.tag_to_class[:th] = TableHeaderCell
-   #
-   # @return [TableSection]
-   #
+      #
+      # @return [TextAreaCollection]
+      #
 
-   def thead(*args)
-     TableSection.new(self, extract_selector(args).merge(:tag_name => "thead"))
-   end
+      def textareas(*args)
+        TextAreaCollection.new(self, extract_selector(args).merge(:tag_name => "textarea"))
+      end
 
-   #
-   # @return [TableSectionCollection]
-   #
+      Watir.tag_to_class[:textarea] = TextArea
 
-   def theads(*args)
-     TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "thead"))
-   end
+      #
+      # @return [TableSection]
+      #
 
-   Watir.tag_to_class[:thead] = TableSection
-   #
-   # @return [Time]
-   #
+      def tfoot(*args)
+        TableSection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
+      end
 
-   def time(*args)
-     Time.new(self, extract_selector(args).merge(:tag_name => "time"))
-   end
+      #
+      # @return [TableSectionCollection]
+      #
 
-   #
-   # @return [TimeCollection]
-   #
+      def tfoots(*args)
+        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
+      end
 
-   def times(*args)
-     TimeCollection.new(self, extract_selector(args).merge(:tag_name => "time"))
-   end
+      Watir.tag_to_class[:tfoot] = TableSection
 
-   Watir.tag_to_class[:time] = Time
-   #
-   # @return [Title]
-   #
+      #
+      # @return [TableHeaderCell]
+      #
 
-   def title(*args)
-     Title.new(self, extract_selector(args).merge(:tag_name => "title"))
-   end
+      def th(*args)
+        TableHeaderCell.new(self, extract_selector(args).merge(:tag_name => "th"))
+      end
 
-   #
-   # @return [TitleCollection]
-   #
+      #
+      # @return [TableHeaderCellCollection]
+      #
 
-   def titles(*args)
-     TitleCollection.new(self, extract_selector(args).merge(:tag_name => "title"))
-   end
+      def ths(*args)
+        TableHeaderCellCollection.new(self, extract_selector(args).merge(:tag_name => "th"))
+      end
 
-   Watir.tag_to_class[:title] = Title
-   #
-   # @return [TableRow]
-   #
+      Watir.tag_to_class[:th] = TableHeaderCell
 
-   def tr(*args)
-     TableRow.new(self, extract_selector(args).merge(:tag_name => "tr"))
-   end
+      #
+      # @return [TableSection]
+      #
 
-   #
-   # @return [TableRowCollection]
-   #
+      def thead(*args)
+        TableSection.new(self, extract_selector(args).merge(:tag_name => "thead"))
+      end
 
-   def trs(*args)
-     TableRowCollection.new(self, extract_selector(args).merge(:tag_name => "tr"))
-   end
+      #
+      # @return [TableSectionCollection]
+      #
 
-   Watir.tag_to_class[:tr] = TableRow
-   #
-   # @return [Track]
-   #
+      def theads(*args)
+        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "thead"))
+      end
 
-   def track(*args)
-     Track.new(self, extract_selector(args).merge(:tag_name => "track"))
-   end
+      Watir.tag_to_class[:thead] = TableSection
 
-   #
-   # @return [TrackCollection]
-   #
+      #
+      # @return [Time]
+      #
 
-   def tracks(*args)
-     TrackCollection.new(self, extract_selector(args).merge(:tag_name => "track"))
-   end
+      def time(*args)
+        Time.new(self, extract_selector(args).merge(:tag_name => "time"))
+      end
 
-   Watir.tag_to_class[:track] = Track
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [TimeCollection]
+      #
 
-   def u(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "u"))
-   end
+      def times(*args)
+        TimeCollection.new(self, extract_selector(args).merge(:tag_name => "time"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      Watir.tag_to_class[:time] = Time
 
-   def us(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "u"))
-   end
+      #
+      # @return [Title]
+      #
 
-   Watir.tag_to_class[:u] = HTMLElement
-   #
-   # @return [UList]
-   #
+      def title(*args)
+        Title.new(self, extract_selector(args).merge(:tag_name => "title"))
+      end
 
-   def ul(*args)
-     UList.new(self, extract_selector(args).merge(:tag_name => "ul"))
-   end
+      #
+      # @return [TitleCollection]
+      #
 
-   #
-   # @return [UListCollection]
-   #
+      def titles(*args)
+        TitleCollection.new(self, extract_selector(args).merge(:tag_name => "title"))
+      end
 
-   def uls(*args)
-     UListCollection.new(self, extract_selector(args).merge(:tag_name => "ul"))
-   end
+      Watir.tag_to_class[:title] = Title
 
-   Watir.tag_to_class[:ul] = UList
-   #
-   # @return [HTMLElement]
-   #
+      #
+      # @return [TableRow]
+      #
 
-   def var(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "var"))
-   end
+      def tr(*args)
+        TableRow.new(self, extract_selector(args).merge(:tag_name => "tr"))
+      end
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [TableRowCollection]
+      #
 
-   def vars(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "var"))
-   end
+      def trs(*args)
+        TableRowCollection.new(self, extract_selector(args).merge(:tag_name => "tr"))
+      end
 
-   Watir.tag_to_class[:var] = HTMLElement
-   #
-   # @return [Video]
-   #
+      Watir.tag_to_class[:tr] = TableRow
 
-   def video(*args)
-     Video.new(self, extract_selector(args).merge(:tag_name => "video"))
-   end
+      #
+      # @return [Track]
+      #
 
-   #
-   # @return [VideoCollection]
-   #
+      def track(*args)
+        Track.new(self, extract_selector(args).merge(:tag_name => "track"))
+      end
 
-   def videos(*args)
-     VideoCollection.new(self, extract_selector(args).merge(:tag_name => "video"))
-   end
+      #
+      # @return [TrackCollection]
+      #
 
-   Watir.tag_to_class[:video] = Video
-   #
-   # @return [HTMLElement]
-   #
+      def tracks(*args)
+        TrackCollection.new(self, extract_selector(args).merge(:tag_name => "track"))
+      end
 
-   def wbr(*args)
-     HTMLElement.new(self, extract_selector(args).merge(:tag_name => "wbr"))
-   end
+      Watir.tag_to_class[:track] = Track
 
-   #
-   # @return [HTMLElementCollection]
-   #
+      #
+      # @return [HTMLElement]
+      #
 
-   def wbrs(*args)
-     HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "wbr"))
-   end
+      def u(*args)
+        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "u"))
+      end
 
-   Watir.tag_to_class[:wbr] = HTMLElement
- end # Container
+      #
+      # @return [HTMLElementCollection]
+      #
+
+      def us(*args)
+        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "u"))
+      end
+
+      Watir.tag_to_class[:u] = HTMLElement
+
+      #
+      # @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