text: var html5Forms = new function () {
      var me = this;
  
      var scriptNode = null,
          scriptDir = null,
          isScriptCompressed = false,
  
          // WebKit less than 534 doesn't show validation UI - we need to check for this (from http://stackoverflow.com/questions/6030522/html5-form-validation-modernizr-safari)
          hasNativeBubbles = navigator.userAgent.indexOf('WebKit') < 0 || parseInt(navigator.userAgent.match(/AppleWebKit\/([^ ]*)/)[1].split('.')[0])  > 534,
          hasBadValidationImplementation = !hasNativeBubbles;  // making another var for this in case we have more criteria in the future.
  
  
      var globalEvent = document.addEventListener?document.createEvent("HTMLEvents"):null;
  
      function getBrowserLanguage() {
          var r = navigator.language;
          if (!r) {
              r = navigator.browserLanguage;
          }
          return r;
      }
  
  
      me.start = function () {
  
          var split = navigator.userAgent.split('Firefox/');
  
          //Firefox 3.6 gives a wierd error when using the Twitter API
          //unless you do this onload.
          if (split.length>=1 && parseFloat(split[1]) <= 3.6) {
              EventHelpers.addEvent(window, 'load', me.init);
          } else {
              me.init();
          }
      }
  
      me.init = function () {
          var scriptNodes = document.getElementsByTagName('script');
  
          for (var i=0; i<scriptNodes.length; i++) {
              scriptNode = scriptNodes[i];
  
              if (scriptNode.src.match('html5Forms(_src|-p|)\.js$')) {
                  scriptNode = scriptNode;
                  scriptDir = getScriptDir();
                  if (scriptNode.src.indexOf('html5Forms-p.js') >= 0) {
                      isScriptCompressed = true;
                  }
                  break;
              }
          }
  
          if (scriptNode) {
              if (window.yepnope) {
                  var inputSupport = Modernizr.inputtypes;
                  /* let's load the supporting scripts according to what is in data-webforms2-support */
                  var supportArray = scriptNode.getAttribute('data-webforms2-support');
                  me.forceJSValidation = (scriptNode.getAttribute('data-webforms2-force-js-validation') == 'true');
                  me.turnOffValidation = (scriptNode.getAttribute('data-webforms2-turn-off-validation') == 'true');
                  me.forceJSDatePicker = (scriptNode.getAttribute('data-webforms2-force-js-date-picker') == 'true');
                  if (!supportArray) {
                      return;
                  } else if (trim(supportArray) == 'all') {
                      supportArray="validation,number,color,date,output,range,placeholder";
                  }
  
                  supportArray = supportArray.split(',');
                  var toLoad = [];
                  var toRunAfterLoad = [];
                  var loadHTML5Widgets = false;
  
  
                  for (var i=0; i<supportArray.length; i++) {
                      var supportReq = trim(supportArray[i]);
  
                      switch(supportReq) {
  
                          case "validation":
                          case "autofocus":
                              if (me.turnOffValidation) {
                                  //me.turnOffNativeValidation();
                                  EventHelpers.addPageLoadEvent('html5Forms.turnOffNativeValidation')
                              } else {
  
                                  if (!Modernizr.input.required || hasBadValidationImplementation || me.forceJSValidation) {
  
                                      if (isScriptCompressed) {
                                          toLoad = toLoad.concat([
                                              scriptDir + '../../shared/js/weston.ruter.net/webforms2/webforms2-p.js']);
                                      } else {
                                          toLoad = toLoad.concat([
                                              scriptDir + '../../shared/js/weston.ruter.net/webforms2/webforms2_src.js']);
                                      }
  
                                      if (supportReq == 'autofocus') {
                                          loadHTML5Widgets = true;
                                      }
  
                                  }
                              }
                              break;
                          case "number":
                              if (!inputSupport.number) {
                                  toLoad = toLoad.concat([
                                      scriptDir + '../../shared/css/number.css']);
                                  loadHTML5Widgets = true;
                              }
                              break;
                          case "color":
                              if (!inputSupport.color) {
  
                                  toLoad = toLoad.concat([  scriptDir + '../../shared/js/jscolor/jscolor.js']);
  
                                  loadHTML5Widgets = true;
                              }
                              break;
  
                          case "datetime":
                          case "date":
                              var lang = scriptNode.getAttribute('data-lang');
  
  
                              /* If data-lang is not set, or is set to an unsupported language, use English by default. */
                              if (!lang ||
                                  !lang.match(/^(af|al|bg|big5|br|ca|cn|cs|da|de|du|el|en|es|fi|fr|he|hr|hu|it|jp|ko|ko|lt|lt|lv|nl|no|pl|pl|pt|ro|ru|si|sk|sp|sv|tr|zh)$/)){
  
  
                                  lang = getBrowserLanguage().split('-')[0];
                              }
  
  
  
                              if (!inputSupport.date || me.forceJSDatePicker) {
                                  toLoad = toLoad.concat([
                                      scriptDir + '../../shared/js/jscalendar-1.0/calendar-win2k-1.css',
                                      scriptDir + '../../shared/js/jscalendar-1.0/calendar.js',
                                      scriptDir + '../../shared/js/jscalendar-1.0/lang/calendar-' + lang + '.js',
                                      scriptDir + '../../shared/js/jscalendar-1.0/calendar-setup.js']);
                                  loadHTML5Widgets = true;
                              }
                              break;
  
                          case "output":
                              if(!supportsOutput()) {
  
                                  loadHTML5Widgets = true;
                              }
                              break;
  
                          case "range":
                              /* yepnope({
                                   load: ['ie6!' + scriptDir + '../../shared/css/slider.css']
                              }); */
  
                              if(!inputSupport.range) {
                                  toLoad = toLoad.concat([  scriptDir + '../../shared/css/slider.css',
                                      scriptDir + '../../shared/js/frequency-decoder.com/slider.js']);
  
  
                                  loadHTML5Widgets = true;
                                  toRunAfterLoad.push('fdSliderController.redrawAll');
  
                              }
                              break;
                          case "placeholder":
                          case "autofocus":
                              if (!Modernizr.input[supportReq]) {
                                  loadHTML5Widgets = true;
                              }
                      }
                  }
  
  
                  if (toLoad.length == 0) {
                      loadWidgets();
  
                      // allow browsers that don't need webforms2 to handle custom error messages populated
                      // in the data-errormessage attribute
                      if (document.addEventListener) {
                          document.addEventListener('DOMContentLoaded', setupExtraFeatures, false);
                      }
                  } else {
                      yepnope({
                          load: toLoad,
                          complete: function (){
                              loadWidgets();
                              setupExtraFeatures();
                          }
                      });
                  }
              }
          }
  
          function loadWidgets() {
  
              yepnope({
                  test: loadHTML5Widgets,
                  yep: scriptDir + '../../shared/js/html5Widgets.js',
                  complete: function () {
                      if (loadHTML5Widgets) {
                          for (var i=0; i<toRunAfterLoad.length; i++)  {
                              eval(toRunAfterLoad[i] + '()');
                          }
                          EventHelpers.init();
                          html5Widgets.init();
                          //toRunAfterLoad.push('html5Widgets.init');
                      }
                  }
              })
  
          }
  
  
  
          /*
           * This should work even when webforms2 is not loaded.
           * It sets up extra features for HTML5Forms like:
           * 1) Setting custom error messages on form elements.
           * 2) setting up isBlank and isBlurred classes.
           * 3) settung up form.wf2_submitAttempted
           */
          function setupExtraFeatures() {
              var nodeNames = ["input", "select", "textarea"];
              for (var i=0; i<nodeNames.length; i++) {
                  var nodes = document.getElementsByTagName(nodeNames[i]);
  
                  for (var j=0; j<nodes.length; j++) {
                      var node = nodes[j];
                      setErrorMessageEvents(node);
                      setCustomClassesEvents(node);
                      setNodeClasses(node, true);
                  }
  
                  if (i==0 && node && node.type=="submit") {
                      EventHelpers.addEvent(node, 'click', submitClickEvent);
                  }
              }
  
              var forms = document.getElementsByTagName('form');
              for (var i=0; i<forms.length; i++) {
                  EventHelpers.addEvent(forms[i], 'submit', submitEvent);
                  EventHelpers.addEvent(forms[i], 'reset', resetEvent);
              }
          }
  
          function submitEvent(e) {
              var target = EventHelpers.getEventTarget(e);
              markSubmitAttempt(target);
          }
  
          function resetEvent(e) {
              var target = EventHelpers.getEventTarget(e);
  
              resetForm(target);
          }
          function submitClickEvent(e) {
              var target = EventHelpers.getEventTarget(e);
              markSubmitAttempt(target.form);
          }
  
          function markSubmitAttempt(form) {
              me.css.addClass(form, 'wf2_submitAttempted');
          }
  
          function removeSubmitAttempt(form) {
              me.css.removeClass(form, 'wf2_submitAttempted');
          }
  
          function resetForm(form) {
              removeSubmitAttempt(form);
              var nodeNames = ["input", "select", "textarea"];
              for (var i=0; i<nodeNames.length; i++) {
                  var nodes = form.getElementsByTagName(nodeNames[i]);
  
                  for (var j=0; j<nodes.length; j++) {
                      var node = nodes[j];
  
                      me.css.removeClass(node, 'wf2_lostFocus');
                      me.css.removeClass(node, 'wf2_notBlank');
                      me.css.addClass(node, 'wf2_isBlank');
                  }
  
              }
          }
  
          function setCustomClassesEvents(node) {
              EventHelpers.addEvent(node, 'keyup', nodeChangeEvent);
              EventHelpers.addEvent(node, 'change', nodeChangeEvent);
              EventHelpers.addEvent(node, 'blur', nodeBlurEvent);
          }
  
          function nodeChangeEvent(e) {
              var node = EventHelpers.getEventTarget(e);
              setNodeClasses(node);
          }
  
          function setNodeClasses(node, isLoadEvent) {
              if (node.value === '') {
  
                  me.css.addClass(node, 'wf2_isBlank');
                  me.css.removeClass(node, 'wf2_notBlank');
              } else {
                  me.css.addClass(node, 'wf2_notBlank');
                  me.css.removeClass(node, 'wf2_isBlank');
              }
  
              if (isLoadEvent && node.nodeName == 'SELECT') {
                  node.setAttribute('data-wf2-initialvalue', node.value)
              }
  
              if ((node.nodeName == 'SELECT' && me.getAttributeValue(node, 'data-wf2-initialvalue') != node.value)
                  || (node.nodeName != 'SELECT' && me.getAttributeValue(node, 'value') != node.value)) {
                  me.css.removeClass(node, 'wf2_defaultValue');
                  me.css.addClass(node, 'wf2_notDefaultValue');
              } else {
                  me.css.addClass(node, 'wf2_defaultValue');
                  me.css.removeClass(node, 'wf2_notDefaultValue');
              }
          }
  
          function nodeBlurEvent(e) {
              var node = EventHelpers.getEventTarget(e);
  
              me.css.addClass(node, 'wf2_lostFocus');
          }
  
          function setErrorMessageEvents(node) {
              var message = me.getAttributeValue(node, 'data-errormessage');
              if (message) {
                  if(document.addEventListener){
                      node.addEventListener('invalid', showCustomMessageEvent, false);
                      node.addEventListener('focus', showCustomMessageEvent, false);
  
                      // Opera doesn't work well with this.
                      if (!window.opera) {
                          node.addEventListener('keypress', clearMessageIfValidEvent, false);
                      }
  
                      node.addEventListener('input', clearMessageIfValidEvent, false);
  
                      if (node.nodeName == 'SELECT') {
                          node.addEventListener('change', clearMessageIfValidEvent, false);
                          node.addEventListener('click', clearMessageIfValidEvent, false);
                      }
                  } else {
                      var invalidEvent = ' this.setCustomValidity("' + message + '");';
                      if (node.oninvalid) {
                          node.oninvalid += invalidEvent;
                      } else {
                          node.oninvalid = invalidEvent;
                      }
                      node.oninvalid = new Function('event', node.oninvalid);
  
                      // IE freaks a little on keypress here, so change to keydown.
                      node.attachEvent('onkeydown', clearMessageIfValidEvent);
                      node.attachEvent('oninput', clearMessageIfValidEvent);
  
                      if (node.nodeName == 'SELECT') {
                          node.attachEvent('change', clearMessageIfValidEvent, false);
                          node.attachEvent('click', clearMessageIfValidEvent, false);
                      }
                  }
  
  
                  clearMessageIfValid(node);
  
              }
          }
  
          function showCustomMessageEvent(event) {
              var node = event.currentTarget || event.srcElement;
              showCustomMessage(node);
          }
  
          function showCustomMessage(node) {
              if (node.validity.valid) {
                  return;
              }
              var message = me.getAttributeValue(node, 'data-errormessage');
              node.setCustomValidity(message)
              //console.log('set custom validity')
          }
  
          function clearMessageIfValidEvent (event) {
              //console.log(event.type)
              var node = event.currentTarget || event.srcElement;
              clearMessageIfValid(node);
          }
  
          function clearMessageIfValid(node) {
              if (!node.setCustomValidity) {
                  // this happens when webforms2 is not loaded yet.  Bail.
                  return;
              }
  
              node.setCustomValidity('');
              if (!node.checkValidity()) {
                  showCustomMessage(node);
                  //console.log('invalid')
                  if (document.addEventListener) {
                      globalEvent.initEvent('invalid', true, true); // event type,bubbling,cancelable
                      node.dispatchEvent(globalEvent);
                  }
              } else {
                  //console.log('valid')
              }
          }
  
      }
  
      me.turnOffNativeValidation = function () {
  
          var formNodes = document.getElementsByTagName('form');
          for (var i=0; i<formNodes.length; i++) {
              formNodes[i].setAttribute('novalidate', 'novalidate');
          }
      }
  
      var supportsOutput = function () {
          var outputEl = document.createElement('output');
          return (outputEl.value != undefined && (outputEl.onforminput !== undefined || outputEl.oninput !== undefined));
  
      }
  
      var getScriptDir = function () {
          var arr = scriptNode.src.split('/');
          arr.pop();
  
          return arr.join('/') + '/';
      }
  
      me.getAttributeByName = function (obj, attrName) {
          var i;
  
          var attributes = obj.attributes;
          for (var i=0; i<attributes.length; i++) {
              var attr = attributes[i]
              if (attr.nodeName == attrName && attr.specified) {
                  return attr;
              }
          }
          return null;
      }
  
      me.getAttributeValue = function (obj, attrName) {
          var attr = me.getAttributeByName(obj, attrName);
  
          if (attr != null) {
              return attr.nodeValue;
          } else {
              return null;
          }
      }
  
      var initWhitespaceRe = /^\s\s*/;
      var endWhitespaceRe = /\s\s*$/;
  
      function trim(str) {
          return str.replace(initWhitespaceRe, '')
              .replace(endWhitespaceRe, '');
      }
  
      me.css = new function () {
          var me = this;
  
          var blankRe = new RegExp('\\s');
  
          /**
           * Generates a regular expression string that can be used to detect a class name
           * in a tag's class attribute.  It is used by a few methods, so I
           * centralized it.
           *
           * @param {String} className - a name of a CSS class.
           */
  
          function getClassReString(className) {
              return '\\s'+className+'\\s|^' + className + '\\s|\\s' + className + '$|' + '^' + className +'$';
          }
  
          function getClassPrefixReString(className) {
              return '\\s'+className+'-[0-9a-zA-Z_]+\\s|^' + className + '[0-9a-zA-Z_]+\\s|\\s' + className + '[0-9a-zA-Z_]+$|' + '^' + className +'[0-9a-zA-Z_]+$';
          }
  
  
          /**
           * Make an HTML object be a member of a certain class.
           *
           * @param {Object} obj - an HTML object
           * @param {String} className - a CSS class name.
           */
          me.addClass = function (obj, className) {
  
              if (blankRe.test(className)) {
                  return;
              }
  
              // only add class if the object is not a member of it yet.
              if (!me.isMemberOfClass(obj, className)) {
                  obj.className += " " + className;
              }
  
          }
  
          /**
           * Make an HTML object *not* be a member of a certain class.
           *
           * @param {Object} obj - an HTML object
           * @param {Object} className - a CSS class name.
           */
          me.removeClass = function (obj, className) {
  
              if (blankRe.test(className)) {
                  return;
              }
  
  
              var re = new RegExp(getClassReString(className) , "g");
  
              var oldClassName = obj.className;
  
  
              if (obj.className) {
                  obj.className = oldClassName.replace(re, ' ');
              }
  
  
          }
  
          /**
           * Determines if an HTML object is a member of a specific class.
           * @param {Object} obj - an HTML object.
           * @param {Object} className - the CSS class name.
           */
          me.isMemberOfClass = function (obj, className) {
  
              if (blankRe.test(className))
                  return false;
  
              var re = new RegExp(getClassReString(className) , "g");
  
              return (re.test(obj.className));
  
  
          }
  
      }
  
  }
  
  /*******************************************************************************
   * This notice must be untouched at all times.
   *
   * This javascript library contains helper routines to assist with event
   * handling consistently among browsers
   *
   * EventHelpers.js v.1.4 available at http://www.useragentman.com/
   *
   * released under the MIT License:
   *   http://www.opensource.org/licenses/mit-license.php
   *
   * Chagelog: 1.4: fix fireEvent to work correctly for IE9.
   *
   *******************************************************************************/
  var EventHelpers = new function(){
      var me = this;
  
      var safariTimer;
      var isSafari = /WebKit/i.test(navigator.userAgent);
      var isIEPolling = false;
      var globalEvent;
      var safariVer = navigator.userAgent.match(/Version\/([^\s]*)/);
  
      if (safariVer != null && safariVer.length == 2) {
          safariVer = parseFloat(safariVer[1]);
      }
  
  
      me.init = function () {
          if (me.hasPageLoadHappened(arguments)) {
              return;
          }
  
          /* This is for fireEvent */
          if (document.createEvent) {
              globalEvent = document.createEvent("HTMLEvents");
          } else if (document.createEventObject){
              // dispatch for IE8 and lower.
              globalEvent = document.createEventObject();
          }
  
          me.docIsLoaded = true;
      }
  
      /**
       * Adds an event to the document.  Examples of usage:
       * me.addEvent(window, "load", myFunction);
       * me.addEvent(docunent, "keydown", keyPressedFunc);
       * me.addEvent(document, "keyup", keyPressFunc);
       *
       * @author Scott Andrew - http://www.scottandrew.com/weblog/articles/cbs-events
       * @author John Resig - http://ejohn.org/projects/flexible-javascript-events/
       * @param {Object} obj - a javascript object.
       * @param {String} evType - an event to attach to the object.
       * @param {Function} fn - the function that is attached to the event.
       */
      me.addEvent = function(obj, evType, fn){
  
          if (obj.addEventListener) {
              obj.addEventListener(evType, fn, false);
          } else if (obj.attachEvent) {
              obj['e' + evType + fn] = fn;
              obj[evType + fn] = function(){
                  obj["e" + evType + fn](self.event);
              }
              obj.attachEvent("on" + evType, obj[evType + fn]);
          }
      }
  
  
      /**
       * Removes an event that is attached to a javascript object.
       *
       * @author Scott Andrew - http://www.scottandrew.com/weblog/articles/cbs-events
       * @author John Resig - http://ejohn.org/projects/flexible-javascript-events/	 * @param {Object} obj - a javascript object.
       * @param {String} evType - an event attached to the object.
       * @param {Function} fn - the function that is called when the event fires.
       */
      me.removeEvent = function(obj, evType, fn){
  
          if (obj.removeEventListener) {
              obj.removeEventListener(evType, fn, false);
          } else if (obj.detachEvent) {
              try {
                  obj.detachEvent("on" + evType, obj[evType + fn]);
                  obj[evType + fn] = null;
                  obj["e" + evType + fn] = null;
              }
              catch (ex) {
                  // do nothing;
              }
          }
      }
  
  
      /**
       * Find the HTML object that fired an Event.
       *
       * @param {Object} e - an HTML object
       * @return {Object} - the HTML object that fired the event.
       */
      me.getEventTarget = function(e){
          // first, IE method for mouse events(also supported by Safari and Opera)
          if (e.toElement) {
              return e.toElement;
              // W3C
          } else if (e.currentTarget) {
              return e.currentTarget;
  
              // MS way
          } else if (e.srcElement) {
              return e.srcElement;
          } else {
              return null;
          }
      }
  
  
  
  
      /**
       * Given an event fired by the keyboard, find the key associated with that event.
       *
       * @param {Object} e - an event object.
       * @return {String} - the ASCII character code representing the key associated with the event.
       */
      me.getKey = function(e){
          if (e.keyCode) {
              return e.keyCode;
          } else if (e.event && e.event.keyCode) {
              return window.event.keyCode;
          } else if (e.which) {
              return e.which;
          }
      }
  
      function mylog(s) {
          if (window.console && window.console.log) {
              console.log(s);
          }
  
      }
      /**
       *  Will execute a function when the page's DOM has fully loaded (and before all attached images, iframes,
       *  etc., are).
       *
       *  Usage:
       *
       *  EventHelpers.addPageLoadEvent('init');
       *
       *  where the function init() has this code at the beginning:
       *
       *  function init() {
       *
       *  if (EventHelpers.hasPageLoadHappened(arguments)) return;
       *
       *	// rest of code
       *   ....
       *  }
       *
       * @author This code is based off of code from http://dean.edwards.name/weblog/2005/09/busted/ by Dean
       * Edwards, with a modification by me.
       *
       * @param {String} funcName - a string containing the function to be called.
       */
      me.addPageLoadEvent = function(funcName, timerForIE){
  
          var func = eval(funcName);
  
          // for Internet Explorer < 9 (using conditional comments)
          /*@cc_on @*/
          /*@if (@_win32 && @_jscript_version < 10)
  		 if (timerForIE) {
  		 	isIEPolling = true;
  		 } else {
  	      	pageLoadEventArray.push(func);
  	     	return;
  		 }
           /*@end @*/
  
          // if document is already loaded, then just execute.
          if (!isIEPolling && /loaded|complete|interactive/.test(document.readyState)) {
              mylog('execute immediately')
              func();
              return;
          }
  
  
  
  
          if ((isSafari && safariVer < 3.1) || isIEPolling) { // sniff
              mylog('polling')
              pageLoadEventArray.push(func);
  
              if (!safariTimer) {
  
                  safariTimer = setInterval(function(){
                      if (/loaded|complete/.test(document.readyState)) {
                          clearInterval(safariTimer);
  
                          /*
                           * call the onload handler
                           * func();
                           */
                          me.runPageLoadEvents();
                          return;
                      }
                      set = true;
                  }, 10);
              }
              /* for Mozilla */
          } else if (document.addEventListener) {
  
              document.addEventListener("DOMContentLoaded", func, null);
              mylog("DOMContentLoaded " + document.readyState);
              /* Others */
          } else {
              mylog('window.load')
              me.addEvent(window, 'load', func);
          }
      }
  
      var pageLoadEventArray = new Array();
  
      me.runPageLoadEvents = function(e){
          if (isSafari || isIEPolling || e.srcElement.readyState == "complete") {
  
              for (var i = 0; i < pageLoadEventArray.length; i++) {
                  pageLoadEventArray[i]();
              }
          }
      }
      /**
       * Determines if either addPageLoadEvent('funcName') or addEvent(window, 'load', funcName)
       * has been executed.
       *
       * @see addPageLoadEvent
       * @param {Function} funcArgs - the arguments of the containing. function
       */
      me.hasPageLoadHappened = function(funcArgs){
          // If the function already been called, return true;
          if (funcArgs.callee.done)
              return true;
  
          // flag this function so we don't do the same thing twice
          funcArgs.callee.done = true;
      }
  
  
  
      /**
       * Used in an event method/function to indicate that the default behaviour of the event
       * should *not* happen.
       *
       * @param {Object} e - an event object.
       * @return {Boolean} - always false
       */
      me.preventDefault = function(e){
  
          if (e.preventDefault) {
              e.preventDefault();
          }
  
          try {
              e.returnValue = false;
          }
          catch (ex) {
              // do nothing
          }
  
      }
  
  
      /*
       * Fires an event manually.
       * @author Scott Andrew - http://www.scottandrew.com/weblog/articles/cbs-events
       * @author John Resig - http://ejohn.org/projects/flexible-javascript-events/
       * @param {Object} obj - a javascript object.
       * @param {String} evType - an event attached to the object.
       * @param {Function} fn - the function that is called when the event fires.
       *
       */
      me.fireEvent = function (element,event, options){
  
          if(!element) {
              return;
          }
  
          if (element.dispatchEvent) {
              // dispatch for firefox + ie9 + others
              globalEvent.initEvent(event, true, true); // event type,bubbling,cancelable
              return !element.dispatchEvent(globalEvent);
          } else if (document.createEventObject){
              return element.fireEvent('on' + event, globalEvent)
          } else {
              return false;
          }
      }
  
      /*
       * Detects whether the event "eventName" is supported on a tag with name
       * "nodeName".  Based on code from
       * http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
       */
      me.isSupported = function (eventName, nodeName) {
          var el = document.createElement(nodeName);
          eventName = 'on' + eventName;
          var isSupported = (eventName in el);
          if (!isSupported) {
              el.setAttribute(eventName, 'return;');
              isSupported = typeof el[eventName] == 'function';
          }
          el = null;
          return isSupported;
      }
  
  
      /* EventHelpers.init () */
      function init(){
          // Conditional comment alert: Do not remove comments.  Leave intact.
          // The detection if the page is secure or not is important. If
          // this logic is removed, Internet Explorer will give security
          // alerts.
          /*@cc_on @*/
          /*@if (@_win32)
  
           document.write('<script id="__ie_onload" defer src="' +
  
           ((location.protocol == 'https:') ? '//0' : 'javascript:void(0)') + '"><\/script>');
  
           var script = document.getElementById("__ie_onload");
  
           me.addEvent(script, 'readystatechange', me.runPageLoadEvents);
  
           /*@end @*/
  
      }
      if (!window.html5Forms) {
          init();
      }
  }
  
  html5Forms.start();
  