watir-webdriver 0.7.0 → 0.8.0

data/spec/element_spec.rb

@@ -4,7 +4,7 @@ describe Watir::Element do
 
   describe '#present?' do
     before do
-      browser.goto(WatirSpec.url_for("wait.html", :needs_server => true))
+      browser.goto(WatirSpec.url_for("wait.html", needs_server: true))
     end
 
     it 'returns true if the element exists and is visible' do
@@ -20,7 +20,7 @@ describe Watir::Element do
     end
 
     it "returns false if the element is stale" do
-      wd_element = browser.div(:id => "foo").wd
+      wd_element = browser.div(id: "foo").wd
 
       # simulate element going stale during lookup
       allow(browser.driver).to receive(:find_element).with(:id, 'foo') { wd_element }
@@ -33,7 +33,7 @@ describe Watir::Element do
 
   describe "#reset!" do
     it "successfully relocates collection elements after a reset!" do
-      browser.goto(WatirSpec.url_for("wait.html", :needs_server => true))
+      browser.goto(WatirSpec.url_for("wait.html", needs_server: true))
       element = browser.div(:id, 'foo')
       expect(element).to exist
       browser.refresh
@@ -45,12 +45,12 @@ describe Watir::Element do
 
   describe "#exists?" do
     before do
-      browser.goto WatirSpec.url_for('removed_element.html', :needs_server => true)
+      browser.goto WatirSpec.url_for('removed_element.html', needs_server: true)
     end
 
     it "does not propagate StaleElementReferenceErrors" do
-      button = browser.button(:id => "remove-button")
-      element = browser.div(:id => "text")
+      button = browser.button(id: "remove-button")
+      element = browser.div(id: "text")
 
       expect(element).to exist
       button.click
@@ -58,8 +58,8 @@ describe Watir::Element do
     end
 
     it "returns false when an element from a collection becomes stale" do
-      button = browser.button(:id => "remove-button")
-      text = browser.divs(:id => "text").first
+      button = browser.button(id: "remove-button")
+      text = browser.divs(id: "text").first
 
       expect(text).to exist
       button.click
@@ -67,7 +67,7 @@ describe Watir::Element do
     end
 
     it "returns false when an element becomes stale" do
-      wd_element = browser.div(:id => "text").wd
+      wd_element = browser.div(id: "text").wd
 
       # simulate element going stale during lookup
       allow(browser.driver).to receive(:find_element).with(:id, 'text') { wd_element }
@@ -75,14 +75,27 @@ describe Watir::Element do
 
       expect(browser.div(:id, 'text')).to_not exist
     end
+
+    it "returns appropriate value when an ancestor element becomes stale" do
+      stale_element = browser.div(id: 'top').div(id: 'middle').div(id: 'bottom')
+      expect(stale_element.present?).to be true # look up and store @element for each element in hierarchy
+
+      grandparent = stale_element.instance_variable_get('@parent').instance_variable_get('@parent').instance_variable_get('@element')
+
+      # simulate element going stale during lookup
+      allow(grandparent).to receive('enabled?') { raise Selenium::WebDriver::Error::ObsoleteElementError }
+
+      browser.refresh
+      expect(stale_element.present?).to be Watir.always_locate?
+    end
   end
 
   describe "#element_call" do
 
     it 'handles exceptions when taking an action on an element that goes stale during execution' do
-      browser.goto WatirSpec.url_for('removed_element.html', :needs_server => true)
+      browser.goto WatirSpec.url_for('removed_element.html', needs_server: true)
 
-      watir_element = browser.div(:id => "text")
+      watir_element = browser.div(id: "text")
 
         # simulate element going stale after assert_exists and before action taken
       allow(watir_element).to receive(:text) do
@@ -101,12 +114,12 @@ describe Watir::Element do
   end
 
   describe "#hover" do
-    not_compliant_on [:webdriver, :firefox, :synthesized_events],
-                     [:webdriver, :internet_explorer],
-                     [:webdriver, :iphone],
-                     [:webdriver, :safari] do
+    not_compliant_on %i(webdriver firefox synthesized_events),
+                     %i(webdriver internet_explorer),
+                     %i(webdriver iphone),
+                     %i(webdriver safari) do
       it "should hover over the element" do
-        browser.goto WatirSpec.url_for('hover.html', :needs_server => true)
+        browser.goto WatirSpec.url_for('hover.html', needs_server: true)
         link = browser.a
 
         expect(link.style("font-size")).to eq "10px"

data/spec/html/clicks.html

@@ -12,5 +12,8 @@
   <body>
     <div id="click-logger">click me</div>
     <div id="log"></div>
+    <div>
+      <div onclick="this.innerHTML = 'You Clicked It!'" style="color: red; text-decoration: underline; cursor: pointer;">Can You Click This?</div>
+    </div>
   </body>
 </html>

data/spec/html/removed_element.html

@@ -13,5 +13,12 @@
   <body>
     <button id='remove-button' onclick="removeText()">Remove text</button>
     <div id="text">Text</div>
+
+    <div id='top'>Top Element>
+      <div id='middle'>Middle Element>
+        <div id='bottom'>Bottom Element</div>
+      </div>
+    </div>
+
   </body>
 </html>

data/spec/implementation.rb

@@ -35,7 +35,7 @@ class ImplementationConfig
 
     if ENV['SELECTOR_STATS']
       listener = SelectorListener.new
-      args.last.merge!(:listener => listener)
+      args.last.merge!(listener: listener)
       at_exit { listener.report }
     end
 
@@ -102,13 +102,13 @@ class ImplementationConfig
     profile = Selenium::WebDriver::Firefox::Profile.new
     profile.native_events = native_events?
 
-    [:firefox, {:profile => profile}]
+    [:firefox, {profile: profile}]
   end
 
   def chrome_args
     opts = {
-      :args          => ["--disable-translate"],
-      :native_events => native_events?
+      args: ["--disable-translate"],
+      native_events: native_events?
     }
 
     if url = ENV['WATIR_WEBDRIVER_CHROME_SERVER']
@@ -131,7 +131,7 @@ class ImplementationConfig
   end
 
   def remote_args
-    [:remote, {:url => ENV["WATIR_WEBDRIVER_REMOTE_URL"] || "http://127.0.0.1:8080"}]
+    [:remote, {url: ENV["WATIR_WEBDRIVER_REMOTE_URL"] || "http://127.0.0.1:8080"}]
   end
 
   def add_html_routes

data/spec/input_spec.rb

@@ -8,7 +8,7 @@ describe Watir::Input do
 
   describe "#type" do
     it "returns an email type" do
-      expect(browser.input(:name => "html5_email").type).to eq 'email'
+      expect(browser.input(name: "html5_email").type).to eq 'email'
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
@@ -20,7 +19,7 @@ if ENV['PREFER_CSS']
   Watir.prefer_css = true
 end
 
-WEBDRIVER_SELECTORS = [:class, :class_name, :css, :id, :tag_name, :xpath]
+WEBDRIVER_SELECTORS = %i(class class_name css id tag_name xpath)
 
 if ENV['TRAVIS']
   ENV['DISPLAY'] = ":99.0"

data/spec/special_chars_spec.rb

@@ -3,11 +3,11 @@ require File.expand_path('watirspec/spec_helper', File.dirname(__FILE__))
 describe Watir::Browser do
 
   before do
-    browser.goto WatirSpec.url_for("special_chars.html", :needs_server => true)
+    browser.goto WatirSpec.url_for("special_chars.html", needs_server: true)
   end
 
   it "finds elements with single quotes" do
-    expect(browser.div(:text => "single 'quotes'")).to exist
+    expect(browser.div(text: "single 'quotes'")).to exist
   end
 
 end

data/support/doctest_helper.rb

@@ -24,18 +24,18 @@ YARD::Doctest.configure do |doctest|
   %w[text ok close exists?].each do |name|
     doctest.before("Watir::Alert##{name}") do
       browser.goto WatirSpec.url_for('alerts.html')
-      browser.button(:id => 'alert').click
+      browser.button(id: 'alert').click
     end
   end
 
   doctest.before('Watir::Alert#set') do
     browser.goto WatirSpec.url_for('alerts.html')
-    browser.button(:id => 'prompt').click
+    browser.button(id: 'prompt').click
   end
 
   doctest.before('Watir::CheckBox#set') do
     browser.goto WatirSpec.url_for('forms_with_input_elements.html')
-    checkbox = browser.checkbox(:id => 'new_user_interests_cars')
+    checkbox = browser.checkbox(id: 'new_user_interests_cars')
   end
 
   %w[Watir::Browser#execute_script Watir::Element#drag_and_drop].each do |name|
@@ -57,7 +57,7 @@ YARD::Doctest.configure do |doctest|
   %w[Watir::HasWindow Watir::Window#== Watir::Window#use].each do |name|
     doctest.before(name) do
       browser.goto WatirSpec.url_for('window_switching.html')
-      browser.a(:id => 'open').click
+      browser.a(id: 'open').click
     end
   end
 

data/support/version_differ.rb

@@ -7,7 +7,7 @@ class VersionDiffer
   def update(path)
     old = File.read(path)
     File.open(path, "w") do |file|
-      show_latest(file)
+      print_latest(file)
       file << old
     end
   end
@@ -56,4 +56,4 @@ class VersionDiffer
     str.string
   end
 
-end
+end

data/watir-webdriver.gemspec

@@ -20,10 +20,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "selenium-webdriver", '>= 2.45'
+  s.add_dependency "selenium-webdriver", ">= 2.46.2"
 
   s.add_development_dependency "rspec", "~> 2.6"
-  s.add_development_dependency "yard", "~> 0.8.2.1"
+  s.add_development_dependency "yard", "> 0.8.2.1"
   s.add_development_dependency "webidl", ">= 0.1.5"
   s.add_development_dependency "sinatra", "~> 1.0"
   s.add_development_dependency "rake", "~> 0.9.2"
@@ -32,5 +32,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "activesupport", "~> 3.0" # for pluralization during code generation
   s.add_development_dependency "pry"
   s.add_development_dependency "coveralls"
-  s.add_development_dependency "yard-doctest"
+  s.add_development_dependency "yard-doctest", "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: watir-webdriver
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jari Bakken
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.45'
+        version: 2.46.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.45'
+        version: 2.46.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -42,14 +42,14 @@ dependencies:
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: 0.8.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
         version: 0.8.2.1
 - !ruby/object:Gem::Dependency
@@ -168,16 +168,16 @@ dependencies:
   name: yard-doctest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.4
 description: WebDriver-backed Watir
 email:
 - jari.bakken@gmail.com
@@ -219,8 +219,8 @@ files:
 - lib/watir-webdriver/elements/file_field.rb
 - lib/watir-webdriver/elements/font.rb
 - lib/watir-webdriver/elements/form.rb
-- lib/watir-webdriver/elements/generated.rb
 - lib/watir-webdriver/elements/hidden.rb
+- lib/watir-webdriver/elements/html_elements.rb
 - lib/watir-webdriver/elements/iframe.rb
 - lib/watir-webdriver/elements/image.rb
 - lib/watir-webdriver/elements/input.rb
@@ -228,6 +228,7 @@ files:
 - lib/watir-webdriver/elements/option.rb
 - lib/watir-webdriver/elements/radio.rb
 - lib/watir-webdriver/elements/select.rb
+- lib/watir-webdriver/elements/svg_elements.rb
 - lib/watir-webdriver/elements/table.rb
 - lib/watir-webdriver/elements/table_cell.rb
 - lib/watir-webdriver/elements/table_row.rb
@@ -238,13 +239,22 @@ files:
 - lib/watir-webdriver/extensions/alerts.rb
 - lib/watir-webdriver/extensions/nokogiri.rb
 - lib/watir-webdriver/extensions/select_text.rb
+- lib/watir-webdriver/generator.rb
+- lib/watir-webdriver/generator/base.rb
+- lib/watir-webdriver/generator/base/generator.rb
+- lib/watir-webdriver/generator/base/idl_sorter.rb
+- lib/watir-webdriver/generator/base/spec_extractor.rb
+- lib/watir-webdriver/generator/base/util.rb
+- lib/watir-webdriver/generator/base/visitor.rb
+- lib/watir-webdriver/generator/html.rb
+- lib/watir-webdriver/generator/html/generator.rb
+- lib/watir-webdriver/generator/html/spec_extractor.rb
+- lib/watir-webdriver/generator/html/visitor.rb
+- lib/watir-webdriver/generator/svg.rb
+- lib/watir-webdriver/generator/svg/generator.rb
+- lib/watir-webdriver/generator/svg/spec_extractor.rb
+- lib/watir-webdriver/generator/svg/visitor.rb
 - lib/watir-webdriver/has_window.rb
-- lib/watir-webdriver/html.rb
-- lib/watir-webdriver/html/generator.rb
-- lib/watir-webdriver/html/idl_sorter.rb
-- lib/watir-webdriver/html/spec_extractor.rb
-- lib/watir-webdriver/html/util.rb
-- lib/watir-webdriver/html/visitor.rb
 - lib/watir-webdriver/locators/button_locator.rb
 - lib/watir-webdriver/locators/child_cell_locator.rb
 - lib/watir-webdriver/locators/child_row_locator.rb

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

@@ -1,3106 +0,0 @@
-# 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, :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)
-    attribute(String, :content_editable, :contentEditable)
-    attribute("Boolean", :content_editable?, :isContentEditable)
-  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, :src_object, :srcObject)
-    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 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, :sizes, :sizes)
-    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, :current_src, :currentSrc)
-    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 Source < HTMLElement
-    attribute(String, :srcset, :srcset)
-    attribute(String, :sizes, :sizes)
-    attribute(String, :media, :media)
-    attribute(String, :src, :src)
-    attribute(String, :type, :type)
-  end
-  class SourceCollection < ElementCollection
-    def element_class
-      Source
-    end
-  end
-  class Picture < HTMLElement
-  end
-  class PictureCollection < ElementCollection
-    def element_class
-      Picture
-    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
-
-      #
-      # @return [CanvasCollection]
-      #
-
-      def canvases(*args)
-        CanvasCollection.new(self, extract_selector(args).merge(:tag_name => "canvas"))
-      end
-
-      Watir.tag_to_class[:canvas] = Canvas
-
-      #
-      # @return [TableCaption]
-      #
-
-      def caption(*args)
-        TableCaption.new(self, extract_selector(args).merge(:tag_name => "caption"))
-      end
-
-      #
-      # @return [TableCaptionCollection]
-      #
-
-      def captions(*args)
-        TableCaptionCollection.new(self, extract_selector(args).merge(:tag_name => "caption"))
-      end
-
-      Watir.tag_to_class[:caption] = TableCaption
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def cite(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "cite"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def cites(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "cite"))
-      end
-
-      Watir.tag_to_class[:cite] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def code(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "code"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def codes(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "code"))
-      end
-
-      Watir.tag_to_class[:code] = HTMLElement
-
-      #
-      # @return [TableCol]
-      #
-
-      def col(*args)
-        TableCol.new(self, extract_selector(args).merge(:tag_name => "col"))
-      end
-
-      #
-      # @return [TableColCollection]
-      #
-
-      def cols(*args)
-        TableColCollection.new(self, extract_selector(args).merge(:tag_name => "col"))
-      end
-
-      Watir.tag_to_class[:col] = TableCol
-
-      #
-      # @return [TableCol]
-      #
-
-      def colgroup(*args)
-        TableCol.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
-      end
-
-      #
-      # @return [TableColCollection]
-      #
-
-      def colgroups(*args)
-        TableColCollection.new(self, extract_selector(args).merge(:tag_name => "colgroup"))
-      end
-
-      Watir.tag_to_class[:colgroup] = TableCol
-
-      #
-      # @return [Data]
-      #
-
-      def data(*args)
-        Data.new(self, extract_selector(args).merge(:tag_name => "data"))
-      end
-
-      #
-      # @return [DataCollection]
-      #
-
-      def datas(*args)
-        DataCollection.new(self, extract_selector(args).merge(:tag_name => "data"))
-      end
-
-      Watir.tag_to_class[:data] = Data
-
-      #
-      # @return [DataList]
-      #
-
-      def datalist(*args)
-        DataList.new(self, extract_selector(args).merge(:tag_name => "datalist"))
-      end
-
-      #
-      # @return [DataListCollection]
-      #
-
-      def datalists(*args)
-        DataListCollection.new(self, extract_selector(args).merge(:tag_name => "datalist"))
-      end
-
-      Watir.tag_to_class[:datalist] = DataList
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def dd(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dd"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def dds(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dd"))
-      end
-
-      Watir.tag_to_class[:dd] = HTMLElement
-
-      #
-      # @return [Mod]
-      #
-
-      def del(*args)
-        Mod.new(self, extract_selector(args).merge(:tag_name => "del"))
-      end
-
-      #
-      # @return [ModCollection]
-      #
-
-      def dels(*args)
-        ModCollection.new(self, extract_selector(args).merge(:tag_name => "del"))
-      end
-
-      Watir.tag_to_class[:del] = Mod
-
-      #
-      # @return [Details]
-      #
-
-      def details(*args)
-        Details.new(self, extract_selector(args).merge(:tag_name => "details"))
-      end
-
-      #
-      # @return [DetailsCollection]
-      #
-
-      def detailses(*args)
-        DetailsCollection.new(self, extract_selector(args).merge(:tag_name => "details"))
-      end
-
-      Watir.tag_to_class[:details] = Details
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def dfn(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dfn"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def dfns(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dfn"))
-      end
-
-      Watir.tag_to_class[:dfn] = HTMLElement
-
-      #
-      # @return [Dialog]
-      #
-
-      def dialog(*args)
-        Dialog.new(self, extract_selector(args).merge(:tag_name => "dialog"))
-      end
-
-      #
-      # @return [DialogCollection]
-      #
-
-      def dialogs(*args)
-        DialogCollection.new(self, extract_selector(args).merge(:tag_name => "dialog"))
-      end
-
-      Watir.tag_to_class[:dialog] = Dialog
-
-      #
-      # @return [Div]
-      #
-
-      def div(*args)
-        Div.new(self, extract_selector(args).merge(:tag_name => "div"))
-      end
-
-      #
-      # @return [DivCollection]
-      #
-
-      def divs(*args)
-        DivCollection.new(self, extract_selector(args).merge(:tag_name => "div"))
-      end
-
-      Watir.tag_to_class[:div] = Div
-
-      #
-      # @return [DList]
-      #
-
-      def dl(*args)
-        DList.new(self, extract_selector(args).merge(:tag_name => "dl"))
-      end
-
-      #
-      # @return [DListCollection]
-      #
-
-      def dls(*args)
-        DListCollection.new(self, extract_selector(args).merge(:tag_name => "dl"))
-      end
-
-      Watir.tag_to_class[:dl] = DList
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def dt(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "dt"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def dts(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "dt"))
-      end
-
-      Watir.tag_to_class[:dt] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def em(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "em"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def ems(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "em"))
-      end
-
-      Watir.tag_to_class[:em] = HTMLElement
-
-      #
-      # @return [Embed]
-      #
-
-      def embed(*args)
-        Embed.new(self, extract_selector(args).merge(:tag_name => "embed"))
-      end
-
-      #
-      # @return [EmbedCollection]
-      #
-
-      def embeds(*args)
-        EmbedCollection.new(self, extract_selector(args).merge(:tag_name => "embed"))
-      end
-
-      Watir.tag_to_class[:embed] = Embed
-
-      #
-      # @return [FieldSet]
-      #
-
-      def fieldset(*args)
-        FieldSet.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
-      end
-
-      #
-      # @return [FieldSetCollection]
-      #
-
-      def fieldsets(*args)
-        FieldSetCollection.new(self, extract_selector(args).merge(:tag_name => "fieldset"))
-      end
-
-      Watir.tag_to_class[:fieldset] = FieldSet
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def figcaption(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def figcaptions(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figcaption"))
-      end
-
-      Watir.tag_to_class[:figcaption] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def figure(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "figure"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def figures(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "figure"))
-      end
-
-      Watir.tag_to_class[:figure] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def footer(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "footer"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def footers(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "footer"))
-      end
-
-      Watir.tag_to_class[:footer] = HTMLElement
-
-      #
-      # @return [Form]
-      #
-
-      def form(*args)
-        Form.new(self, extract_selector(args).merge(:tag_name => "form"))
-      end
-
-      #
-      # @return [FormCollection]
-      #
-
-      def forms(*args)
-        FormCollection.new(self, extract_selector(args).merge(:tag_name => "form"))
-      end
-
-      Watir.tag_to_class[:form] = Form
-
-      #
-      # @return [FrameSet]
-      #
-
-      def frameset(*args)
-        FrameSet.new(self, extract_selector(args).merge(:tag_name => "frameset"))
-      end
-
-      #
-      # @return [FrameSetCollection]
-      #
-
-      def framesets(*args)
-        FrameSetCollection.new(self, extract_selector(args).merge(:tag_name => "frameset"))
-      end
-
-      Watir.tag_to_class[:frameset] = FrameSet
-
-      #
-      # @return [Heading]
-      #
-
-      def h1(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h1"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h1s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h1"))
-      end
-
-      Watir.tag_to_class[:h1] = Heading
-
-      #
-      # @return [Heading]
-      #
-
-      def h2(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h2"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h2s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h2"))
-      end
-
-      Watir.tag_to_class[:h2] = Heading
-
-      #
-      # @return [Heading]
-      #
-
-      def h3(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h3"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h3s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h3"))
-      end
-
-      Watir.tag_to_class[:h3] = Heading
-
-      #
-      # @return [Heading]
-      #
-
-      def h4(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h4"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h4s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h4"))
-      end
-
-      Watir.tag_to_class[:h4] = Heading
-
-      #
-      # @return [Heading]
-      #
-
-      def h5(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h5"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h5s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h5"))
-      end
-
-      Watir.tag_to_class[:h5] = Heading
-
-      #
-      # @return [Heading]
-      #
-
-      def h6(*args)
-        Heading.new(self, extract_selector(args).merge(:tag_name => "h6"))
-      end
-
-      #
-      # @return [HeadingCollection]
-      #
-
-      def h6s(*args)
-        HeadingCollection.new(self, extract_selector(args).merge(:tag_name => "h6"))
-      end
-
-      Watir.tag_to_class[:h6] = Heading
-
-      #
-      # @return [Head]
-      #
-
-      def head(*args)
-        Head.new(self, extract_selector(args).merge(:tag_name => "head"))
-      end
-
-      #
-      # @return [HeadCollection]
-      #
-
-      def heads(*args)
-        HeadCollection.new(self, extract_selector(args).merge(:tag_name => "head"))
-      end
-
-      Watir.tag_to_class[:head] = Head
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def header(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "header"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def headers(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "header"))
-      end
-
-      Watir.tag_to_class[:header] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def hgroup(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def hgroups(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "hgroup"))
-      end
-
-      Watir.tag_to_class[:hgroup] = HTMLElement
-
-      #
-      # @return [HR]
-      #
-
-      def hr(*args)
-        HR.new(self, extract_selector(args).merge(:tag_name => "hr"))
-      end
-
-      #
-      # @return [HRCollection]
-      #
-
-      def hrs(*args)
-        HRCollection.new(self, extract_selector(args).merge(:tag_name => "hr"))
-      end
-
-      Watir.tag_to_class[:hr] = HR
-
-      #
-      # @return [Html]
-      #
-
-      def html(*args)
-        Html.new(self, extract_selector(args).merge(:tag_name => "html"))
-      end
-
-      #
-      # @return [HtmlCollection]
-      #
-
-      def htmls(*args)
-        HtmlCollection.new(self, extract_selector(args).merge(:tag_name => "html"))
-      end
-
-      Watir.tag_to_class[:html] = Html
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def i(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "i"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def is(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "i"))
-      end
-
-      Watir.tag_to_class[:i] = HTMLElement
-
-      #
-      # @return [IFrame]
-      #
-
-      def iframe(*args)
-        IFrame.new(self, extract_selector(args).merge(:tag_name => "iframe"))
-      end
-
-      #
-      # @return [IFrameCollection]
-      #
-
-      def iframes(*args)
-        IFrameCollection.new(self, extract_selector(args).merge(:tag_name => "iframe"))
-      end
-
-      Watir.tag_to_class[:iframe] = IFrame
-
-      #
-      # @return [Image]
-      #
-
-      def img(*args)
-        Image.new(self, extract_selector(args).merge(:tag_name => "img"))
-      end
-
-      #
-      # @return [ImageCollection]
-      #
-
-      def imgs(*args)
-        ImageCollection.new(self, extract_selector(args).merge(:tag_name => "img"))
-      end
-
-      Watir.tag_to_class[:img] = Image
-
-      #
-      # @return [Input]
-      #
-
-      def input(*args)
-        Input.new(self, extract_selector(args).merge(:tag_name => "input"))
-      end
-
-      #
-      # @return [InputCollection]
-      #
-
-      def inputs(*args)
-        InputCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
-      end
-
-      Watir.tag_to_class[:input] = Input
-
-      #
-      # @return [Mod]
-      #
-
-      def ins(*args)
-        Mod.new(self, extract_selector(args).merge(:tag_name => "ins"))
-      end
-
-      #
-      # @return [ModCollection]
-      #
-
-      def inses(*args)
-        ModCollection.new(self, extract_selector(args).merge(:tag_name => "ins"))
-      end
-
-      Watir.tag_to_class[:ins] = Mod
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def kbd(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "kbd"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def kbds(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "kbd"))
-      end
-
-      Watir.tag_to_class[:kbd] = HTMLElement
-
-      #
-      # @return [Keygen]
-      #
-
-      def keygen(*args)
-        Keygen.new(self, extract_selector(args).merge(:tag_name => "keygen"))
-      end
-
-      #
-      # @return [KeygenCollection]
-      #
-
-      def keygens(*args)
-        KeygenCollection.new(self, extract_selector(args).merge(:tag_name => "keygen"))
-      end
-
-      Watir.tag_to_class[:keygen] = Keygen
-
-      #
-      # @return [Label]
-      #
-
-      def label(*args)
-        Label.new(self, extract_selector(args).merge(:tag_name => "label"))
-      end
-
-      #
-      # @return [LabelCollection]
-      #
-
-      def labels(*args)
-        LabelCollection.new(self, extract_selector(args).merge(:tag_name => "label"))
-      end
-
-      Watir.tag_to_class[:label] = Label
-
-      #
-      # @return [Legend]
-      #
-
-      def legend(*args)
-        Legend.new(self, extract_selector(args).merge(:tag_name => "legend"))
-      end
-
-      #
-      # @return [LegendCollection]
-      #
-
-      def legends(*args)
-        LegendCollection.new(self, extract_selector(args).merge(:tag_name => "legend"))
-      end
-
-      Watir.tag_to_class[:legend] = Legend
-
-      #
-      # @return [LI]
-      #
-
-      def li(*args)
-        LI.new(self, extract_selector(args).merge(:tag_name => "li"))
-      end
-
-      #
-      # @return [LICollection]
-      #
-
-      def lis(*args)
-        LICollection.new(self, extract_selector(args).merge(:tag_name => "li"))
-      end
-
-      Watir.tag_to_class[:li] = LI
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def main(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "main"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def mains(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "main"))
-      end
-
-      Watir.tag_to_class[:main] = HTMLElement
-
-      #
-      # @return [Map]
-      #
-
-      def map(*args)
-        Map.new(self, extract_selector(args).merge(:tag_name => "map"))
-      end
-
-      #
-      # @return [MapCollection]
-      #
-
-      def maps(*args)
-        MapCollection.new(self, extract_selector(args).merge(:tag_name => "map"))
-      end
-
-      Watir.tag_to_class[:map] = Map
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def mark(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "mark"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def marks(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "mark"))
-      end
-
-      Watir.tag_to_class[:mark] = HTMLElement
-
-      #
-      # @return [Menu]
-      #
-
-      def menu(*args)
-        Menu.new(self, extract_selector(args).merge(:tag_name => "menu"))
-      end
-
-      #
-      # @return [MenuCollection]
-      #
-
-      def menus(*args)
-        MenuCollection.new(self, extract_selector(args).merge(:tag_name => "menu"))
-      end
-
-      Watir.tag_to_class[:menu] = Menu
-
-      #
-      # @return [MenuItem]
-      #
-
-      def menuitem(*args)
-        MenuItem.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
-      end
-
-      #
-      # @return [MenuItemCollection]
-      #
-
-      def menuitems(*args)
-        MenuItemCollection.new(self, extract_selector(args).merge(:tag_name => "menuitem"))
-      end
-
-      Watir.tag_to_class[:menuitem] = MenuItem
-
-      #
-      # @return [Meta]
-      #
-
-      def meta(*args)
-        Meta.new(self, extract_selector(args).merge(:tag_name => "meta"))
-      end
-
-      #
-      # @return [MetaCollection]
-      #
-
-      def metas(*args)
-        MetaCollection.new(self, extract_selector(args).merge(:tag_name => "meta"))
-      end
-
-      Watir.tag_to_class[:meta] = Meta
-
-      #
-      # @return [Meter]
-      #
-
-      def meter(*args)
-        Meter.new(self, extract_selector(args).merge(:tag_name => "meter"))
-      end
-
-      #
-      # @return [MeterCollection]
-      #
-
-      def meters(*args)
-        MeterCollection.new(self, extract_selector(args).merge(:tag_name => "meter"))
-      end
-
-      Watir.tag_to_class[:meter] = Meter
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def nav(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "nav"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def navs(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "nav"))
-      end
-
-      Watir.tag_to_class[:nav] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def noscript(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "noscript"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def noscripts(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "noscript"))
-      end
-
-      Watir.tag_to_class[:noscript] = HTMLElement
-
-      #
-      # @return [Object]
-      #
-
-      def object(*args)
-        Object.new(self, extract_selector(args).merge(:tag_name => "object"))
-      end
-
-      #
-      # @return [ObjectCollection]
-      #
-
-      def objects(*args)
-        ObjectCollection.new(self, extract_selector(args).merge(:tag_name => "object"))
-      end
-
-      Watir.tag_to_class[:object] = Object
-
-      #
-      # @return [OList]
-      #
-
-      def ol(*args)
-        OList.new(self, extract_selector(args).merge(:tag_name => "ol"))
-      end
-
-      #
-      # @return [OListCollection]
-      #
-
-      def ols(*args)
-        OListCollection.new(self, extract_selector(args).merge(:tag_name => "ol"))
-      end
-
-      Watir.tag_to_class[:ol] = OList
-
-      #
-      # @return [OptGroup]
-      #
-
-      def optgroup(*args)
-        OptGroup.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
-      end
-
-      #
-      # @return [OptGroupCollection]
-      #
-
-      def optgroups(*args)
-        OptGroupCollection.new(self, extract_selector(args).merge(:tag_name => "optgroup"))
-      end
-
-      Watir.tag_to_class[:optgroup] = OptGroup
-
-      #
-      # @return [Option]
-      #
-
-      def option(*args)
-        Option.new(self, extract_selector(args).merge(:tag_name => "option"))
-      end
-
-      #
-      # @return [OptionCollection]
-      #
-
-      def options(*args)
-        OptionCollection.new(self, extract_selector(args).merge(:tag_name => "option"))
-      end
-
-      Watir.tag_to_class[:option] = Option
-
-      #
-      # @return [Output]
-      #
-
-      def output(*args)
-        Output.new(self, extract_selector(args).merge(:tag_name => "output"))
-      end
-
-      #
-      # @return [OutputCollection]
-      #
-
-      def outputs(*args)
-        OutputCollection.new(self, extract_selector(args).merge(:tag_name => "output"))
-      end
-
-      Watir.tag_to_class[:output] = Output
-
-      #
-      # @return [Paragraph]
-      #
-
-      def p(*args)
-        Paragraph.new(self, extract_selector(args).merge(:tag_name => "p"))
-      end
-
-      #
-      # @return [ParagraphCollection]
-      #
-
-      def ps(*args)
-        ParagraphCollection.new(self, extract_selector(args).merge(:tag_name => "p"))
-      end
-
-      Watir.tag_to_class[:p] = Paragraph
-
-      #
-      # @return [Param]
-      #
-
-      def param(*args)
-        Param.new(self, extract_selector(args).merge(:tag_name => "param"))
-      end
-
-      #
-      # @return [ParamCollection]
-      #
-
-      def params(*args)
-        ParamCollection.new(self, extract_selector(args).merge(:tag_name => "param"))
-      end
-
-      Watir.tag_to_class[:param] = Param
-
-      #
-      # @return [Pre]
-      #
-
-      def pre(*args)
-        Pre.new(self, extract_selector(args).merge(:tag_name => "pre"))
-      end
-
-      #
-      # @return [PreCollection]
-      #
-
-      def pres(*args)
-        PreCollection.new(self, extract_selector(args).merge(:tag_name => "pre"))
-      end
-
-      Watir.tag_to_class[:pre] = Pre
-
-      #
-      # @return [Progress]
-      #
-
-      def progress(*args)
-        Progress.new(self, extract_selector(args).merge(:tag_name => "progress"))
-      end
-
-      #
-      # @return [ProgressCollection]
-      #
-
-      def progresses(*args)
-        ProgressCollection.new(self, extract_selector(args).merge(:tag_name => "progress"))
-      end
-
-      Watir.tag_to_class[:progress] = Progress
-
-      #
-      # @return [Quote]
-      #
-
-      def q(*args)
-        Quote.new(self, extract_selector(args).merge(:tag_name => "q"))
-      end
-
-      #
-      # @return [QuoteCollection]
-      #
-
-      def qs(*args)
-        QuoteCollection.new(self, extract_selector(args).merge(:tag_name => "q"))
-      end
-
-      Watir.tag_to_class[:q] = Quote
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def rp(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rp"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def rps(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rp"))
-      end
-
-      Watir.tag_to_class[:rp] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def rt(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "rt"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def rts(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "rt"))
-      end
-
-      Watir.tag_to_class[:rt] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def ruby(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "ruby"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def rubies(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "ruby"))
-      end
-
-      Watir.tag_to_class[:ruby] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def s(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "s"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def ss(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "s"))
-      end
-
-      Watir.tag_to_class[:s] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def samp(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "samp"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def samps(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "samp"))
-      end
-
-      Watir.tag_to_class[:samp] = HTMLElement
-
-      #
-      # @return [Script]
-      #
-
-      def script(*args)
-        Script.new(self, extract_selector(args).merge(:tag_name => "script"))
-      end
-
-      #
-      # @return [ScriptCollection]
-      #
-
-      def scripts(*args)
-        ScriptCollection.new(self, extract_selector(args).merge(:tag_name => "script"))
-      end
-
-      Watir.tag_to_class[:script] = Script
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def section(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "section"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def sections(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "section"))
-      end
-
-      Watir.tag_to_class[:section] = HTMLElement
-
-      #
-      # @return [Select]
-      #
-
-      def select(*args)
-        Select.new(self, extract_selector(args).merge(:tag_name => "select"))
-      end
-
-      #
-      # @return [SelectCollection]
-      #
-
-      def selects(*args)
-        SelectCollection.new(self, extract_selector(args).merge(:tag_name => "select"))
-      end
-
-      Watir.tag_to_class[:select] = Select
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def small(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "small"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def smalls(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "small"))
-      end
-
-      Watir.tag_to_class[:small] = HTMLElement
-
-      #
-      # @return [Source]
-      #
-
-      def source(*args)
-        Source.new(self, extract_selector(args).merge(:tag_name => "source"))
-      end
-
-      #
-      # @return [SourceCollection]
-      #
-
-      def sources(*args)
-        SourceCollection.new(self, extract_selector(args).merge(:tag_name => "source"))
-      end
-
-      Watir.tag_to_class[:source] = Source
-
-      #
-      # @return [Span]
-      #
-
-      def span(*args)
-        Span.new(self, extract_selector(args).merge(:tag_name => "span"))
-      end
-
-      #
-      # @return [SpanCollection]
-      #
-
-      def spans(*args)
-        SpanCollection.new(self, extract_selector(args).merge(:tag_name => "span"))
-      end
-
-      Watir.tag_to_class[:span] = Span
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def strong(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "strong"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def strongs(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "strong"))
-      end
-
-      Watir.tag_to_class[:strong] = HTMLElement
-
-      #
-      # @return [Style]
-      #
-
-      def style(*args)
-        Style.new(self, extract_selector(args).merge(:tag_name => "style"))
-      end
-
-      #
-      # @return [StyleCollection]
-      #
-
-      def styles(*args)
-        StyleCollection.new(self, extract_selector(args).merge(:tag_name => "style"))
-      end
-
-      Watir.tag_to_class[:style] = Style
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def sub(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sub"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def subs(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sub"))
-      end
-
-      Watir.tag_to_class[:sub] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def summary(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "summary"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def summaries(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "summary"))
-      end
-
-      Watir.tag_to_class[:summary] = HTMLElement
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def sup(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "sup"))
-      end
-
-      #
-      # @return [HTMLElementCollection]
-      #
-
-      def sups(*args)
-        HTMLElementCollection.new(self, extract_selector(args).merge(:tag_name => "sup"))
-      end
-
-      Watir.tag_to_class[:sup] = HTMLElement
-
-      #
-      # @return [Table]
-      #
-
-      def table(*args)
-        Table.new(self, extract_selector(args).merge(:tag_name => "table"))
-      end
-
-      #
-      # @return [TableCollection]
-      #
-
-      def tables(*args)
-        TableCollection.new(self, extract_selector(args).merge(:tag_name => "table"))
-      end
-
-      Watir.tag_to_class[:table] = Table
-
-      #
-      # @return [TableSection]
-      #
-
-      def tbody(*args)
-        TableSection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
-      end
-
-      #
-      # @return [TableSectionCollection]
-      #
-
-      def tbodys(*args)
-        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tbody"))
-      end
-
-      Watir.tag_to_class[:tbody] = TableSection
-
-      #
-      # @return [TableDataCell]
-      #
-
-      def td(*args)
-        TableDataCell.new(self, extract_selector(args).merge(:tag_name => "td"))
-      end
-
-      #
-      # @return [TableDataCellCollection]
-      #
-
-      def tds(*args)
-        TableDataCellCollection.new(self, extract_selector(args).merge(:tag_name => "td"))
-      end
-
-      Watir.tag_to_class[:td] = TableDataCell
-
-      #
-      # @return [Template]
-      #
-
-      def template(*args)
-        Template.new(self, extract_selector(args).merge(:tag_name => "template"))
-      end
-
-      #
-      # @return [TemplateCollection]
-      #
-
-      def templates(*args)
-        TemplateCollection.new(self, extract_selector(args).merge(:tag_name => "template"))
-      end
-
-      Watir.tag_to_class[:template] = Template
-
-      #
-      # @return [TextArea]
-      #
-
-      def textarea(*args)
-        TextArea.new(self, extract_selector(args).merge(:tag_name => "textarea"))
-      end
-
-      #
-      # @return [TextAreaCollection]
-      #
-
-      def textareas(*args)
-        TextAreaCollection.new(self, extract_selector(args).merge(:tag_name => "textarea"))
-      end
-
-      Watir.tag_to_class[:textarea] = TextArea
-
-      #
-      # @return [TableSection]
-      #
-
-      def tfoot(*args)
-        TableSection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
-      end
-
-      #
-      # @return [TableSectionCollection]
-      #
-
-      def tfoots(*args)
-        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "tfoot"))
-      end
-
-      Watir.tag_to_class[:tfoot] = TableSection
-
-      #
-      # @return [TableHeaderCell]
-      #
-
-      def th(*args)
-        TableHeaderCell.new(self, extract_selector(args).merge(:tag_name => "th"))
-      end
-
-      #
-      # @return [TableHeaderCellCollection]
-      #
-
-      def ths(*args)
-        TableHeaderCellCollection.new(self, extract_selector(args).merge(:tag_name => "th"))
-      end
-
-      Watir.tag_to_class[:th] = TableHeaderCell
-
-      #
-      # @return [TableSection]
-      #
-
-      def thead(*args)
-        TableSection.new(self, extract_selector(args).merge(:tag_name => "thead"))
-      end
-
-      #
-      # @return [TableSectionCollection]
-      #
-
-      def theads(*args)
-        TableSectionCollection.new(self, extract_selector(args).merge(:tag_name => "thead"))
-      end
-
-      Watir.tag_to_class[:thead] = TableSection
-
-      #
-      # @return [Time]
-      #
-
-      def time(*args)
-        Time.new(self, extract_selector(args).merge(:tag_name => "time"))
-      end
-
-      #
-      # @return [TimeCollection]
-      #
-
-      def times(*args)
-        TimeCollection.new(self, extract_selector(args).merge(:tag_name => "time"))
-      end
-
-      Watir.tag_to_class[:time] = Time
-
-      #
-      # @return [Title]
-      #
-
-      def title(*args)
-        Title.new(self, extract_selector(args).merge(:tag_name => "title"))
-      end
-
-      #
-      # @return [TitleCollection]
-      #
-
-      def titles(*args)
-        TitleCollection.new(self, extract_selector(args).merge(:tag_name => "title"))
-      end
-
-      Watir.tag_to_class[:title] = Title
-
-      #
-      # @return [TableRow]
-      #
-
-      def tr(*args)
-        TableRow.new(self, extract_selector(args).merge(:tag_name => "tr"))
-      end
-
-      #
-      # @return [TableRowCollection]
-      #
-
-      def trs(*args)
-        TableRowCollection.new(self, extract_selector(args).merge(:tag_name => "tr"))
-      end
-
-      Watir.tag_to_class[:tr] = TableRow
-
-      #
-      # @return [Track]
-      #
-
-      def track(*args)
-        Track.new(self, extract_selector(args).merge(:tag_name => "track"))
-      end
-
-      #
-      # @return [TrackCollection]
-      #
-
-      def tracks(*args)
-        TrackCollection.new(self, extract_selector(args).merge(:tag_name => "track"))
-      end
-
-      Watir.tag_to_class[:track] = Track
-
-      #
-      # @return [HTMLElement]
-      #
-
-      def u(*args)
-        HTMLElement.new(self, extract_selector(args).merge(:tag_name => "u"))
-      end
-
-      #
-      # @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