html5forms-rails 0.1.3

data/vendor/assets/javascripts/webforms2/webforms2_src.js

@@ -0,0 +1,3195 @@
+/*
+ * Web Forms 2.0 Cross-browser Implementation <http://code.google.com/p/webforms2/>
+ * Version: 0.7 (2011-03-01)
+ * Copyright: 2007, Weston Ruter <http://weston.ruter.net/> 
+ *    with additions by Zoltan Hawryluk <http://www.useragentman.com>
+ * Licenses (as of Feb 6, 2011)
+ * - MIT License (http://www.opensource.org/licenses/mit-license.php)
+ * - GPL (http://creativecommons.org/licenses/GPL/2.0/)
+ * 
+ * The comments contained in this code are largely quotations from the 
+ * WebForms 2.0 specification: <http://whatwg.org/specs/web-forms/current-work/>
+ *
+ * Usage: <script type="text/javascript" src="webforms2_src.js"></script>
+ * 
+ * Changelog:
+ * version 0.5.4  - initial release by Weston Ruter
+ * version 0.6    - refactored for use with HTML5Widgets by Zoltan Hawryluk (July 27th, 2010)
+ * version 0.6.1  - updated to deal with WebKit's half-implemented WebForms 2 Implementation (Sept 10, 2010)
+ * version 0.7    - bug fixes with nested repetition models by Zoltan Hawryluk.
+ * version 0.7.1  - updated to dual MIT/GPL 2.0 license.
+ */
+
+if(!window.$wf2){
+var $wf2 = {};
+
+if(document.implementation && document.implementation.hasFeature && 
+  !document.implementation.hasFeature('WebForms', '2.0')){
+
+$wf2 = {
+	version : '0.5.4',
+	isInitialized : false,
+	libpath : '',
+	globalEvent: null,
+	
+	hasElementExtensions : (window.HTMLElement && HTMLElement.prototype),
+	hasGettersAndSetters : ($wf2.__defineGetter__ && $wf2.__defineSetter__),
+	
+	hasBadImplementation: navigator.userAgent.indexOf('WebKit'),
+	
+	callBeforeValidation : new Array(),
+	callAfterValidation : new Array(),
+	callAfterDOMContentLoaded: new Array(),
+	
+	
+	onDOMContentLoaded : function(){
+		if($wf2.isInitialized)
+			return;
+		$wf2.isInitialized = true;  //Safari needs this here for some reason
+		
+		var i,j,k,node;
+		
+		//set global event for fireEvent method
+		if (document.createEventObject){
+	        // dispatch for IE
+	        $wf2.globalEvent = document.createEventObject();
+	    } else 	if (document.createEvent) {
+			$wf2.globalEvent = document.createEvent("HTMLEvents");
+		} 
+		
+		//Include stylesheet
+		var style = document.createElement('link');
+		style.setAttribute('type', 'text/css');
+		style.setAttribute('rel', 'stylesheet');
+		style.setAttribute('href', $wf2.libpath + 'webforms2.css');
+		var parent = document.getElementsByTagName('head')[0];
+		if(!parent)
+			parent = document.getElementsByTagName('*')[0];
+		parent.insertBefore(style, parent.firstChild);
+
+		//The zero point for datetime  controls is 1970-01-01T00:00:00.0Z, for datetime-local is
+		//   1970-01-01T00:00:00.0, for date controls is 1970-01-01, for month controls is 1970-01, for week
+		//   controls is 1970-W01 (the week starting 1969-12-29 and containing 1970-01-01), and for time controls
+		//   is 00:00.
+		$wf2.zeroPoint = {};
+		$wf2.zeroPoint.datetime          = $wf2.parseISO8601("1970-01-01T00:00:00.0Z");
+		$wf2.zeroPoint['datetime-local'] = $wf2.parseISO8601("1970-01-01T00:00:00.0");
+		$wf2.zeroPoint.date              = $wf2.zeroPoint.datetime; //parseISO8601("1970-01-01"); //.zeroPointDatetime; //1970-01-01 (UTC)
+		$wf2.zeroPoint.month             = $wf2.zeroPoint.datetime; //parseISO8601("1970-01"); //1970-01 (UTC)
+		$wf2.zeroPoint.week              = $wf2.parseISO8601("1970-W01"); //(UTC)
+		$wf2.zeroPoint.time              = $wf2.zeroPoint.datetime; //parseISO8601("00:00"); //00:00 (UTC)
+
+		//## Fetching data from external resources ##################################
+		$wf2.xhr = null;
+		if(window.XMLHttpRequest)
+			$wf2.xhr = new XMLHttpRequest();
+		else if(window.ActiveXObject){
+			try {
+				$wf2.xhr = new ActiveXObject("Msxml2.XMLHTTP");
+			} catch(e){
+				try {
+					$wf2.xhr = new ActiveXObject("Microsoft.XMLHTTP");
+				} catch(e){}
+			}
+		}
+		if($wf2.xhr){
+			$wf2.prefillSelectElements();
+			$wf2.prefillFormElements();
+		}
+
+		//Initialize Repetition Behaviors ****************************************
+		//Before load events are fired, but after the entire document has been parsed and after forms with data 
+		//   attributes are prefilled (if necessary), UAs must iterate through every node in the document, depth 
+		//   first, looking for templates so that their initial repetition blocks can be created. ... UAs should not 
+		//   specifically wait for images and style sheets to be loaded before creating initial repetition blocks 
+		//   as described above.
+		$wf2.initRepetitionBlocks();
+		$wf2.initRepetitionTemplates();
+		$wf2.initRepetitionButtons('add');
+		$wf2.initRepetitionButtons('remove');
+		$wf2.initRepetitionButtons('move-up');
+		$wf2.initRepetitionButtons('move-down');
+		$wf2.updateAddButtons();
+		$wf2.updateMoveButtons();
+	
+		// Initialize Non-Repetition Behaviors ****************************************
+		if(document.addEventListener){
+			document.addEventListener('mousedown', $wf2.clearInvalidIndicators, false);
+			document.addEventListener('keydown', $wf2.clearInvalidIndicators, false);
+		}
+		else if(document.attachEvent){
+			document.attachEvent('onmousedown', $wf2.clearInvalidIndicators);
+			document.attachEvent('onkeydown', $wf2.clearInvalidIndicators);
+		}
+		
+		$wf2.initNonRepetitionFunctionality();
+		
+		for (var i=0; i<$wf2.callAfterDOMContentLoaded.length; i++) {
+			$wf2.callAfterDOMContentLoaded[i]();
+		}
+	},
+
+
+	/*##############################################################################################
+	 # Section: Fetching data from external resources
+	 ##############################################################################################*/
+
+	prefillSelectElements : function(){
+		//If a select element or a datalist element being parsed has a data attribute, then as soon
+		//   as the element and all its children have been parsed and added to the document, the
+		//   prefilling process described here should start.
+		var select, selects = $wf2.getElementsByTagNames.apply(document.documentElement, ['select', 'datalist']); //$wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['select', 'datalist']]); //, 'data'
+		for(var i = 0; select = selects[i]; i++){
+			//If a select element or a datalist element has a data  attribute, it must be a URI or
+			//   IRI that points to a well-formed XML file whose root element is a select element
+			//   in the http://www.w3.org/1999/xhtml namespace. The MIME type must be an XML MIME
+			//   type [RFC3023], preferably application/xml. It should not be application/xhtml+xml
+			//   since the root element is not html.
+			//UAs must process this file if it has an XML MIME type [RFC3023], if it is a well-formed
+			//   XML file, and if the root element is the right root element in the right namespace.
+			//   If any of these conditions are not met, UAs must act as if the attribute was not
+			//   specified, although they may report the error to the user. UAs are expected to
+			//   correctly handle namespaces, so the file may use prefixes, etc.
+			var xmlDoc = $wf2.loadDataURI(select);
+			if(///\bxml\b/.test(xhr.getResponseHeader('Content-Type') && 
+			   xmlDoc &&
+			   xmlDoc.documentElement &&
+			   /:?\bselect$/i.test(xmlDoc.documentElement.nodeName) &&
+			   xmlDoc.documentElement.namespaceURI == 'http://www.w3.org/1999/xhtml'
+			   )
+			{
+				var root = xmlDoc.documentElement;
+				//1. Unless the root element of the file has a type attribute with the exact literal
+				//   string incremental, the children of the select or datalist  element in the original
+				//   document must all be removed from the document.
+				if(root.getAttribute('type') != 'incremental'){
+					while(select.lastChild)
+						select.removeChild(select.lastChild);
+				}
+				
+				//2. The entire contents of the select element in the referenced document are imported
+				//   into the original document and appended as children of the select or datalist
+				//   element. (Even if importing into a text/html document, the newly imported nodes
+				//   will still be namespaced.)
+				//3. All nodes outside the select (such as style sheet processing instructions, whitespace
+				//   text nodes, and DOCTYPEs) are ignored, as are attributes (other than type) on the
+				//   select element.
+				node = root.firstChild;
+				while(node){
+					//select.appendChild(node.cloneNode(true)); //MSIE BUG: Throws "No such interface supported" exception
+					select.appendChild($wf2.cloneNode(node));
+					node = node.nextSibling;
+				}
+			}
+		}
+	},
+
+	prefillFormElements : function(){
+		//-- Seeding a form with initial values -------------------------------
+		//Before load events are fired, but after the entire document has been parsed and after select
+		//   elements have been filled from external data sources (if necessary), forms with data attributes
+		//   are prefilled.
+		var frm, frms = document.getElementsByTagName('form'); //$wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['form'], 'data']);
+		for(var i = 0; frm = frms[i]; i++){
+			//If a form has a data attribute, it must be a URI or IRI that points to a well-formed XML file
+			//   whose root element is a formdata element in the http://n.whatwg.org/formdata namespace. The
+			//   MIME type must be an XML MIME type [RFC3023], preferably application/xml.
+			//UAs must process this file if these conditions are met. If any of these conditions are not met,
+			//   UAs must act as if the attribute was not specified, although they may report the error to
+			//   the user. UAs are expected to correctly handle namespaces, so the file may use prefixes, etc.
+			var xmlDoc = $wf2.loadDataURI(frm);
+			if(///\bxml\b/.test(xhr.getResponseHeader('Content-Type') && 
+			   xmlDoc &&
+			   xmlDoc.documentElement &&
+			   /:?\bformdata$/.test(xmlDoc.documentElement.nodeName) &&
+			   xmlDoc.documentElement.namespaceURI == 'http://n.whatwg.org/formdata'
+			   )
+			{
+				var rt;
+				var root = xmlDoc.documentElement;
+				//1. Unless the root element has a type attribute with the exact literal string incremental,
+				//   the form must be reset to its initial values as specified in the markup.
+				if(root.getAttribute('type') != 'incremental')
+					frm.reset();
+
+				//The algorithm must be processed in the order given above, meaning any clear  elements are
+				//   handled before any repeat  elements which are handled before the field elements, regardless
+				//   of the order in which the elements are given. (Note that this implies that this process
+				//   cannot be performed incrementally.)
+				
+				//clear elements in the http://n.whatwg.org/formdata namespace that are children of
+				//   the root element, have a non-empty template attribute, have no other non-namespaced
+				//   attributes (ignoring xmlns attributes), and have no content, must be processed...:
+				//The template attribute should contain the ID of an element in the document. If the
+				//   template attribute specifies an element that is not a repetition template, then
+				//   the clear element is ignored.
+				var clr, clrs = root.getElementsByTagName('clear'); //getElementsByTagNameNS('http://n.whatwg.org/formdata', 'clr')
+				for(j = 0; clr = clrs[j]; j++){
+					if(clr.namespaceURI == 'http://n.whatwg.org/formdata' &&
+					   clr.parentNode == root &&
+					   !clr.firstChild &&
+					   (rt = document.getElementById(clr.getAttribute('template'))) &&
+					   rt.getAttribute('repeat') == 'template'
+					   /*Examining of non-namespaced attributes skipped*/
+					   )
+					{
+						//The user must make a note of the list of repetition blocks associated with that
+						//   template that are siblings of the template, and must then go through this list,
+						//   removing each repetition block in turn.
+						//Note that we cannot use rt.repetitionBlocks since the repetition behavior has
+						//   not yet been initialized.
+						var attr,node,next;
+						node = rt.parentNode.firstChild;
+						while(node){
+							if(node.nodeType == 1 && (attr = node.getAttributeNode('repeat')) && attr.value != 'template'){
+								next = node.nextSibling;
+								node.parentNode.removeChild(node);
+								node = next;
+							}
+							else node = node.nextSibling;
+						}
+					}
+				}
+				
+				//repeat elements in the http://n.whatwg.org/formdata namespace that are children of
+				//   the root element, have a non-empty template attribute and an index  attribute that
+				//   contains only one or more digits in the range 0-9 with an optional leading minus
+				//   sign (U+002D, "-"), have no other non-namespaced attributes (ignoring xmlns
+				//   attributes), and have no content, must be processed as follows:
+				//The template attribute should contain the ID of an element in the document. If the
+				//   template attribute specifies an element that is not a repetition template, then
+				//   the repeat element is ignored.
+				var index, rpt, rpts = root.getElementsByTagName('repeat');
+				for(j = 0; rpt = rpts[j]; j++){
+					if(rpt.namespaceURI == 'http://n.whatwg.org/formdata' &&
+					   rpt.parentNode == root &&
+					   !rpt.firstChild &&
+					   (rt = document.getElementById(rpt.getAttribute('template'))) &&
+					   rt.getAttribute('repeat') == 'template' &&
+					   /^-?\d+$/.test(index = rpt.getAttribute('index'))
+					   /*Examining of non-namespaced attributes skipped*/
+					   )
+					{
+						//If the template attribute specifies a repetition template and that template
+						//   already has a repetition block with the index specified by the index attribute,
+						//   then the element is ignored.
+						//for(j = 0; j < rt.repetitionBlocks.length; j++){
+						//	if(rt.repetitionBlocks[j].repetititionIndex == index){
+						//		hasIndex = true;
+						//		break;
+						//	}
+						//}
+						var hasIndex,attr,node,next;
+						node = rt.parentNode.firstChild;
+						while(node){
+							if(node.nodeType == 1 && (attr = node.getAttributeNode('repeat')) && attr.value == index){
+								hasIndex = true;
+								break;
+							}
+							node = node.nextSibling;
+						}
+						
+						if(!hasIndex){
+							//Otherwise, the specified template's addRepetitionBlockByIndex()  method is
+							//   called, with a null first argument and the index specified by the repeat
+							//   element's index attribute as the second.
+							$wf2.addRepetitionBlockByIndex.apply(rt, [null, index]);
+						}
+					}
+				}
+				
+				//field elements in the http://n.whatwg.org/formdata namespace that are children of
+				//   the root element, have a non-empty name  attribute, either an index attribute
+				//   that contains only one or more digits in the range 0-9 or no index attribute at
+				//   all, have no other non-namespaced attributes (ignoring xmlns  attributes), and
+				//   have either nothing or only text and CDATA nodes as children, must be used to
+				//   initialize controls...
+				var fld, flds = root.getElementsByTagName('field');
+				var formElements = $wf2.getFormElements.apply(frm);
+				for(j = 0; fld = flds[j]; j++){
+					var indexAttr = fld.getAttributeNode('index');
+					var name = fld.getAttribute('name');
+					if(!name || (indexAttr && !/^\d+$/.test(indexAttr.value)))
+					   /*Examining of non-namespaced attributes skipped*/
+					   /*Verification of the presence of text and CDATA nodes below*/
+						continue;
+					//First, the form control that the field references must be identified. 
+					var value = '';
+					for(k = 0; node = fld.childNodes[k]; k++){
+						if(node.nodeType == 3 /*text*/ || node.nodeType == 4 /*CDATA*/)
+							value += node.data;
+						else break; //only text and CDATA nodes allowed
+					}
+					var ctrl, count = 0;
+					for(k = 0; ctrl = formElements[k]; k++){
+						//console.info(ctrl.name + ' == ' + name)
+						if(ctrl.type == 'image'){
+							//For image controls, instead of using the name given by the name attribute,
+							//   the field's name is checked against two names, the first being the value
+							//   of the name attribute with the string .x appended to it, and the second
+							//   being the same but with .y appended instead. If an image control's name
+							//   is the empty string (e.g. if its name attribute is omitted) then the
+							//   names x and y must be used instead. Thus image controls are handled as
+							//   if they were two controls.
+							if(ctrl.name ?
+								  (ctrl.name + '.x' == name || ctrl.name + '.y' == name)
+								: (name == 'x' || name == 'y') ){
+
+								if(!indexAttr || ++count-1 >= indexAttr.value)	
+									break;
+							}
+						}
+						//This is done by walking the list of form controls associated with the form until
+						//   one is found that has a name exactly equal to the name given in the field
+						//   element's name attribute, skipping as many such matches as is specified in
+						//   the index attribute, or, if the index attribute was omitted, skipping over
+						//   any type="radio" and type="checkbox" controls that have the exact name given
+						//   but have a value that is not exactly the same as the contents of the field element.
+						// SPECIFICATION DEFICIENCY: Note that this is not completely true. If the value of
+						//   a field element is empty, then it should not be skipped if it associated with
+						//   a radio button or checkbox. For example, the specification states four paragraphs
+						//   later, "The only values that would have an effect in this example are "", which
+						//   would uncheck the checkbox, and "green", which would check the checkbox."
+						else if(ctrl.name == name){
+							if(indexAttr){
+								if(++count-1 < indexAttr.value)	
+									continue;
+							}
+							else if((ctrl.type == 'radio' || ctrl.type == 'checkbox') &&
+									 (value && ctrl.value != value))
+								continue;
+							break;
+						}
+					}
+					
+					//If the identified form control is a file upload control, a push button control, or
+					//   an image control, then the field element is now skipped.
+					if(ctrl.type == 'file' || ctrl.type == 'button' || ctrl.type == 'image')
+						continue;
+
+					//Next, if the identified form control is not a multiple-valued control (a multiple-
+					//   valued control is one that can generate more than one value on submission, such
+					//   as a <select multiple="multiple">), or if it is a multiple-valued control but it
+					//   is the first time the control has been identified by a field element in this
+					//   data file that was not ignored, then it is set to the given value (the contents
+					//   of the field  element), removing any previous values (even if these values were
+					//   the result of processing previous field elements in the same data file).
+					if(!ctrl.getAttributeNode('multiple') || !ctrl.wf2Prefilled){
+						//If the element cannot be given the value specified, the field element is
+						//   ignored and the control's value is left unchanged. For example, if a
+						//   checkbox has its value attribute set to green and the field element
+						//   specifies that its value should be set to blue, it won't be changed from
+						//   its current value. (The only values that would have an effect in this
+						//   example are "", which would uncheck the checkbox, and "green", which would
+						//   check the checkbox.)
+						if(ctrl.type == 'checkbox' || ctrl.type == 'radio'){
+							if(!value)
+								ctrl.checked = false;
+							else if(ctrl.value == value)
+								ctrl.checked = true;
+							else break;
+						}
+						else if(ctrl.nodeName.toLowerCase() == 'select'){
+							ctrl.selectedIndex = -1;
+							for(var opt,k = 0; opt = ctrl.options[k]; k++){
+								if(opt.value ? opt.value == value : opt.text == value){
+									opt.selected = true;
+									break;
+								}
+							}
+						}
+						//Another example would be a datetime control where the specified value is
+						//   outside the range allowed by the min  and max attributes. The format
+						//   must match the allowed formats for that type for the value to be set.
+						else {
+							ctrl.value = value;
+							$wf2.updateValidityState(ctrl);
+							if(!ctrl.validity.valid){
+								ctrl.value = ctrl.defaultValue;
+								$wf2.updateValidityState(ctrl);
+							}
+						}
+						ctrl.wf2Prefilled = true; //TRACE
+					}
+					//Otherwise, this is a subsequent value for a multiple-valued control, and the
+					//   given value (the contents of the field element) should be added to the list of
+					//   values that the element has selected.
+					//If the element is a multiple-valued control and the control already has the given
+					//   value selected, but it can be given the value again, then that occurs. 
+					else if(ctrl.getAttributeNode('multiple')){
+						for(var opt,k = 0; opt = ctrl.options[k]; k++){
+							if(!opt.selected && (opt.value ? opt.value == value : opt.text == value)){
+								opt.selected = true;
+								break;
+							}
+						}
+					}
+					
+					//if(ctrl){
+					//	
+					//}
+				}
+				
+				//A formchange event is then fired on all the form controls of the form.
+				var formElements = $wf2.getFormElements.apply(frm);
+				for(j = 0; j < formElements.length; j++){
+					//onformchange();
+					//fireEvent()
+				}
+			}
+		}
+	},
+
+	/*##############################################################################################
+	 # Section: Repetition Model
+	 ##############################################################################################*/
+
+	//## REPETITION TEMPLATE #############################################################
+	repetitionTemplates:[],
+	constructRepetitionTemplate : function(){
+		if(this.wf2Initialized)
+			return;
+		this.wf2Initialized = true; //SAFARI needs this to be here for some reason...
+		
+		this.style.display = 'none'; //This is also specified via a stylesheet
+		this.repetitionType = RepetitionElement.REPETITION_TEMPLATE;
+		if(!this.repetitionIndex)
+			this.repetitionIndex = 0;
+		this.repetitionTemplate = null; //IMPLEMENT GETTER
+		if(!this.repetitionBlocks)
+			this.repetitionBlocks = []; //IMPLEMENT GETTER
+		var _attr;
+		this.repeatStart = /^\d+$/.test(_attr = this.getAttribute('repeat-start')) ? parseInt(_attr) : 1;
+		this.repeatMin   = /^\d+$/.test(_attr = this.getAttribute('repeat-min'))   ? parseInt(_attr) : 0;
+		this.repeatMax   = /^\d+$/.test(_attr = this.getAttribute('repeat-max'))   ? parseInt(_attr) : Number.MAX_VALUE; //Infinity;
+		
+		if(!this.addRepetitionBlock) this.addRepetitionBlock = function(refNode, index){
+			return $wf2.addRepetitionBlock.apply(this, [refNode, index]); //wrapper to save memory?
+		};
+		if(!this.addRepetitionBlockByIndex)
+			this.addRepetitionBlockByIndex = this.addRepetitionBlock/*ByIndex*/; //one method implements both algorithms
+		
+		//Any form controls inside a repetition template are associated with their forms' templateElements 
+		//   DOM attributes, and are not present in the forms' elements DOM attributes.
+		
+		//On the HTMLFormElement, the templateElements attribute contains the list of form controls associated 
+		//   with this form that form part of repetition templates. It is defined in more detail in the section 
+		//   on the repetition model. (Image controls are part of this array, when appropriate.) The controls 
+		//   in the elements and templateElements lists must be in document order. 
+		var frm = this;
+		while(frm = frm.parentNode){
+			if(frm.nodeName.toLowerCase() == 'form')
+				break;
+		}
+		
+		var _templateElements;
+		//IMAGE???, fieldset not included
+		if(frm && (_templateElements = $wf2.getElementsByTagNames.apply(this, ['button','input','select','textarea','isindex'])).length){
+			//INCORRECT IMPLEMENTATION: this should append the new elements onto the frm.templateElements array and then sort them in document order?
+			//each time that a nesting repetition block is instantiated, the form's templateElemenents property becomes invalid
+			
+			//frm.templateElements = _templateElements;
+
+			//Controls in the templateElements attribute cannot be successful; controls inside repetition templates can never be submitted.
+			//   Therefore disable all elements in the template; however, due to the issue below, the original disabled state must be stored in the field's class attribute as "disabled"
+			//   this storing of the original disabled state will enable the elements in cloned blocks to be disabled as originally coded in the template
+			//ISSUE: inputs retain disabled (but not defaultDisabled) attribue after returning to page from back button or reload
+			//   see http://weblogs.mozillazine.org/gerv/archives/2006/10/firefox_reload_behaviour.html
+			// As a workaround... this implementation requires that authors, in addition to supplying a DISABLED attribute (for Opera), to include a class name "disabled"
+			for(var el, i = 0; el = _templateElements[i]; i++)
+				el.disabled = true;
+			
+			//IMPLEMENTATION DEFICIENCY: unable to remove frm.templateElements from frm.elements
+		}
+		
+		//Repetition blocks without a repeat-template attribute are associated with their first following sibling 
+		//   that is a repetition template, if there is one.
+		var attr,sibling = this.parentNode.firstChild;
+		while(sibling && sibling != this){
+			if(sibling.nodeType == 1 && (attr = sibling.getAttributeNode('repeat')) && /^-?\d+$/.test(attr.value) && !sibling.getAttribute('repeat-template')){
+			//if(sibling.repetitionType == RepetitionElement.REPETITION_BLOCK && !sibling.getAttribute('repeat-template')){
+			//console.info(sibling)
+				sibling.repetitionTemplate = this;
+				sibling.setAttribute('repeat-template', this.id);
+				this.repetitionBlocks.push(sibling);
+			}
+			sibling = sibling.nextSibling;
+		}
+		//while(sibling = sibling.previousSibling){
+		//	if(sibling.repetitionType == RepetitionElement.REPETITION_BLOCK && !sibling.getAttribute('repeat-template')){
+		//		sibling.repetitionTemplate = this;
+		//		sibling.setAttribute('repeat-template', this.id);
+		//		this.repetitionBlocks.unshift(sibling);
+		//	}
+		//}
+	
+		//the UA must invoke the template's replication behaviour as many times as the repeat-start attribute 
+		//   on the same element specifies (just once, if the attribute is missing or has an invalid value). 
+		//   Then, while the number of repetition blocks associated with the repetition template is less than 
+		//   the template's repeat-min attribute, the template's replication behaviour must be further invoked. 
+		//   (Invoking the template's replication behaviour means calling its addRepetitionBlock() method).
+		//for(var i = 0; i < Math.max(this.repeatStart, this.repeatMin); i++)
+		for(var i = 0; (i < this.repeatStart || this.repetitionBlocks.length < this.repeatMin); i++)
+			if (!this.addRepetitionBlock()) {
+				break;
+			}
+		
+		$wf2.repetitionTemplates.push(this);
+		this.wf2Initialized = true;
+	},
+	
+	initRepetitionTemplates : function(parentNode){
+		//UAs must iterate through every node in the document, depth first, looking for templates so that their 
+		//   initial repetition blocks can be created. 
+		//var repetitionTemplates = cssQuery("*[repeat=template]", parentNode);
+		var repetitionTemplates = $wf2.getElementsByTagNamesAndAttribute.apply((parentNode || document.documentElement), [['*'], 'repeat', 'template']);
+		for(var i = 0, rt; i < repetitionTemplates.length; i++)
+			$wf2.constructRepetitionTemplate.apply(repetitionTemplates[i]);
+	},
+
+
+	//## REPETITION BLOCK  #############################################################
+	constructRepetitionBlock : function(){
+		if(this.wf2Initialized)
+			return;
+			
+		this.style.display = ''; //This should preferrably be specified via a stylesheet
+		this.repetitionType = RepetitionElement.REPETITION_BLOCK;
+		var _attr;
+		this.repetitionIndex = /^\d+$/.test(_attr = this.getAttribute('repeat')) ? parseInt(_attr) : 0;
+		this.repetitionBlocks = null;
+		
+		//find this block's repetition template
+		this.repetitionTemplate = null; //IMPLEMENT GETTER
+		var node;
+		
+		if((node = document.getElementById(this.getAttribute('repeat-template'))) && 
+		   node.getAttribute('repeat') == 'template')
+		{
+			this.repetitionTemplate = node;
+		}
+		else {
+			node = this;
+			while(node = node.nextSibling){
+				if(node.nodeType == 1 && node.getAttribute('repeat') == 'template'){
+					this.repetitionTemplate = node;
+					break;
+				}
+			}
+		}
+		
+		if(!this.removeRepetitionBlock) this.removeRepetitionBlock = function(){ 
+			return $wf2.removeRepetitionBlock.apply(this); //wrapper to save memory
+		};
+		if(!this.moveRepetitionBlock) this.moveRepetitionBlock = function(distance){ 
+			return $wf2.moveRepetitionBlock.apply(this, [distance]); //wrapper to save memory
+		};
+		this.wf2Initialized = true;
+	},
+
+	initRepetitionBlocks : function(parentNode){
+		//var repetitionBlocks = cssQuery('*[repeat]:not([repeat="template"])', parentNode); //:not([repeat="template"])
+		var repetitionBlocks = $wf2.getElementsByTagNamesAndAttribute.apply((parentNode || document.documentElement), [['*'], 'repeat', 'template', true]);
+		for(var i = 0; i < repetitionBlocks.length; i++)
+			$wf2.constructRepetitionBlock.apply(repetitionBlocks[i]);
+	},
+	
+	
+	//## Repetition buttons #############################################################
+	repetitionButtonDefaultLabels : {
+		'add' : 'Add',
+		'remove' : 'Remove',
+		'move-up' : 'Move-up',
+		'move-down' : 'Move-down'
+	},
+	
+	constructRepetitionButton : function(btnType){
+		if(this.wf2Initialized)
+			return;
+		this.htmlTemplate = $wf2.getHtmlTemplate(this); //IMPLEMENT GETTER
+		if(!this.firstChild)
+			this.appendChild(document.createTextNode($wf2.repetitionButtonDefaultLabels[btnType]));
+		
+		//user agents must automatically disable remove, move-up, and move-down buttons when they are not in a repetition 
+		//   block. [NOT IMPLEMENTED:] This automatic disabling does not affect the DOM disabled  attribute. It is an intrinsic property of these buttons.
+		if(btnType != 'add')
+			this.disabled = !$wf2.getRepetitionBlock(this);
+		//user agents must automatically disable add buttons (irrespective of the value of the disabled 
+		//   DOM attribute [NOT IMPLEMENTED]) when the buttons are not in a repetition block that has an 
+		//   associated template and their template attribute is either not specified or does not have 
+		//   an ID that points to a repetition template...
+		else {
+			var rb;		
+			this.disabled = !(((rb = $wf2.getRepetitionBlock(this)) && rb.repetitionTemplate)
+								||
+								this.htmlTemplate
+							 );
+		}
+
+		if(this.addEventListener)
+			this.addEventListener('click', $wf2.clickRepetitionButton, false);
+		else if(this.attachEvent)
+			this.attachEvent('onclick', $wf2.clickRepetitionButton);
+		else this.onclick = $wf2.clickRepetitionButton;
+		
+		this.wf2Initialized = true;
+	},
+
+	initRepetitionButtons : function(btnType, parent){
+		var i;
+		if(!parent)
+			parent = document.documentElement;
+
+		//change INPUTs to BUTTONs
+		var inpts = $wf2.getElementsByTagNamesAndAttribute.apply(parent, [['input'], 'type', btnType]);
+		for(i = 0; i < inpts.length; i++){
+			var btn = document.createElement('button');
+			for(var j = 0, attr; attr = inpts[i].attributes[j]; j++)
+				btn.setAttribute(attr.nodeName, inpts[i].getAttribute(attr.nodeName)); //MSIE returns correct value with getAttribute but not nodeValue
+			inpts[i].parentNode.replaceChild(btn, inpts[i]);
+			btn = null;
+		}
+
+		//construct all buttons
+		var btns = $wf2.getElementsByTagNamesAndAttribute.apply(parent, [['button'], 'type', btnType]);
+		for(var i = 0; i < btns.length; i++)
+			$wf2.constructRepetitionButton.apply(btns[i], [btnType]);
+	},
+
+	clickRepetitionButton : function(e){
+		if(e && e.preventDefault)
+			e.preventDefault(); //Keep default submission behavior from executing
+
+		//If the event is canceled (btn.returnValue === false, set within onclick handler), then the default action will not occur.
+		var btn;
+		if(e && e.target)
+			btn = e.target;
+		else if(window.event)
+			btn = event.srcElement;
+		else if(this.nodeName.toLowerCase() == 'button')
+			btn = this;
+		var btnType = String(btn.getAttribute('type')).toLowerCase();
+		
+		//Prevent the onclick handler from firing afterwards (would fire after movement action)
+		//  ISSUE: This only works in Firefox
+		if(btn.onclick){
+			btn._onclick = btn.onclick;
+			btn.removeAttribute('onclick');
+			btn.onclick = null; 
+		}
+
+		//Terminate if an onclick handler was called beforehand and returned a false value
+		//   passed via the button's returnValue property. Handlers defined by HTML attributes
+		//   are called before those assigned by onclick DOM properties.
+		if(btn.returnValue !== undefined && !btn.returnValue){
+			btn.returnValue = undefined;
+			return false;
+		}
+		
+		//Ensure that a user-supplied onclick handler is fired before the repetition behavior is executed
+		//  and terminate if this onclick handler returns a false value
+		//  Note that handlers defined in onclick HTML attributes are executed before clickRepetitionButton
+		if(btn._onclick && btn.returnValue === undefined){ //  && !btn.getAttributeNode("onclick") //&& btn.hasAttribute && !btn.hasAttribute("onclick") //NOTE: MSIE fires this afterwards???			btn.returnValue = btn._onclick(e);
+			btn.returnValue = btn._onclick(e);
+			if(btn.returnValue !== undefined && !btn.returnValue){
+				btn.returnValue = undefined;
+				return false;
+			}
+		}
+		btn.returnValue = undefined;
+		
+		//ISSUE: How do we ensure that the MSIE and DOM Level 2 Event handlers are executed beforehand?
+		
+		var block;
+		if(btnType != 'add'){
+			block = $wf2.getRepetitionBlock(btn);
+			
+			//user agents must automatically disable remove, move-up, and move-down buttons when they are not in a repetition 
+			//   block. [NOT IMPLEMENTED:] This automatic disabling does not affect the DOM disabled  attribute. It is an intrinsic property of these buttons.
+			this.disabled = !block;
+			
+			if(block){
+				if(btnType.indexOf('move') === 0){
+					block._clickedMoveBtn = btn;
+					block.moveRepetitionBlock(btnType == 'move-up' ? -1 : 1);
+				}
+				else if(btnType == 'remove'){
+					block.removeRepetitionBlock();
+				}
+			}
+		}
+		else {
+			var rt;
+			//If an add button with a template attribute is activated, and its template attribute gives the ID 
+			//   of an element in the document that is a repetition template as defined above, then that 
+			//   template's replication behaviour is invoked. (Specifically, in scripting-aware environments, 
+			//   the template's addRepetitionBlock() method is called with a null argument.) In the case of 
+			//   duplicate IDs, the behaviour should be the same as with getElementById().
+			if(btn.htmlTemplate)
+				rt = btn.htmlTemplate;
+			else {
+			//If an add button without a template attribute is activated, and it has an ancestor that is a 
+			//   repetition block that is not an orphan repetition block, then the repetition template associated 
+			//   with that repetition block has its template replication behaviour invoked with the respective 
+			//   repetition block as its argument. (Specifically, in scripting-aware environments, the template's 
+			//   addRepetitionBlock() method is called with a reference to the DOM Element node that represents 
+			//   the repetition block.)
+				block = $wf2.getRepetitionBlock(btn);
+				if(block && block.repetitionTemplate)
+					rt = block.repetitionTemplate;
+			}
+			if(rt)
+				rt.addRepetitionBlock();
+			else
+				btn.disabled = true; //NOTE: THIS IS NOT A VALID IMPLEMENTATION
+		}
+		return false;
+	},
+	
+	//## AddRepetitionBlock algorithm #############################################################
+	
+	//Element addRepetitionBlock(in Node refNode);
+	addRepetitionBlock : function(refNode, index){ //addRepetitionBlockByIndex functionalty enabled if @index defined
+		//if(refNode && !refNode.nodeType)
+		//	throw Error("Exception: WRONG_ARGUMENTS_ERR");
+
+		//if(this.repetitionType == RepetitionElement.REPETITION_TEMPLATE)
+		if(this.getAttribute('repeat') != 'template')
+			throw $wf2.DOMException(9); //NOT_SUPPORTED_ERR
+
+		//if addRepetitionBlock called before repetition constructors called (by pre-filling forms)
+		if(!this.repetitionBlocks)
+			this.repetitionBlocks = [];
+		if(!this.repetitionIndex)
+			this.repetitionIndex = 0;
+		if(!this.repeatMin)
+			this.repeatMin = 0;
+		if(!this.repeatMax)
+			this.repeatMax = Number.MAX_VALUE;
+		if(!this.repeatStart)
+			this.repeatStart = 1;
+
+		//1. If the template has no parent node or its parent node is not an element, then the method must abort 
+		//   the steps and do nothing. 
+		if(this.parentNode == null)
+			return null;
+			
+		//[furthermore, if this template is the child of another template (not the child of an instance, a block) return false]
+		var node = this;
+		while(node = node.parentNode){
+			//if(node.repetitionType == RepetitionElement.REPETITION_TEMPLATE)
+			if(node.nodeType == 1 && node.getAttribute('repeat') == 'template')
+				return false;
+		}
+		
+		//2. The template examines its preceding siblings, up to the start of the parent element. For each sibling 
+		//   that is a repetition block whose associated template is this template, if the repetition block's index 
+		//   is greater than or equal to the template's index, then the template's index is increased to the repetition 
+		//   block's index plus one. The total number of repetition blocks associated with this template that were 
+		//   found is used in the next step.
+		//QUESTION: Why not just use this.repetitionBlocks.length????????????
+		var sibling = this.previousSibling;
+		var currentBlockCount = 0;
+		while(sibling != null){
+			if(sibling.nodeType == 1){
+				var repeatAttr,repeatTemplateAttr;
+				repeat = parseInt(sibling.getAttribute('repeat'));
+				repeatTemplateAttr = sibling.getAttributeNode('repeat-template');
+				
+				//if(sibling.repetitionType == RepetitionElement.REPETITION_BLOCK && sibling.repetitionTemplate == this)
+				if(!isNaN(repeat) && (!repeatTemplateAttr || repeatTemplateAttr.value == this.id))
+				{
+					//Old Note: sibling.getAttribute('repeat') is used instead of sibling.repetitionIndex because appearantly
+					//      the sibling is not yet bound to the document and so the getters are not available
+					//this.repetitionIndex = Math.max(this.repetitionIndex, parseInt(sibling.getAttribute('repeat'))+1);
+					this.repetitionIndex = Math.max(this.repetitionIndex, repeat+1);
+					currentBlockCount++;
+				}
+			}
+			sibling = sibling.previousSibling;
+		}
+		
+		//3. If the repetition template has a repeat-max attribute and that attribute's value is less than or equal 
+		//   to the number of repetition blocks associated with this template that were found in the previous step, 
+		//   the UA must stop at this step, returning a null value.
+		if(this.repeatMax <= currentBlockCount)
+			return null;
+			
+		//4. If this algorithm was invoked via the addRepetitionBlockByIndex()  method, and the value of the method's 
+		//   index argument is greater than the template's index, then the template's index is set to the value of the 
+		//   method's index argument.
+		if(index !== undefined && index > this.repetitionIndex)
+			this.repetitionIndex = index;
+
+		//(the following steps are out of order to facilitate a custom cloneNode to cope for MSIE and Gecko issues)
+		
+		//9. If the new repetition block has an ID attribute (that is, an attribute specifying an ID, regardless 
+		//   of the attribute's namespace or name), then that attribute's value is used as the template name in 
+		//   the following steps. Otherwise, the template has no name. (If there is more than one ID attribute, 
+		//   the "first" one in terms of node order is used. [DOM3CORE]) 
+		//   [Since this step was moved here, it uses 'this' and not 'block', which hasn't been created yet]
+		//var IDAttr = block.getAttributeNode('id') ? block.getAttributeNode('id') : block.getAttributeNode('name'); //DETECT ID TYPE For others?
+		var IDAttrName = this.getAttribute('id') ? 'id' : this.getAttribute('name') ? 'name' : ''; //NOTE: hasAttribute not implemented in MSIE
+		var IDAttrValue = this.getAttribute(IDAttrName);
+
+		//5. A clone of the template is made. The resulting element is the new repetition block element.
+		//   [Note that the DOM cloneNode method is not invoked in this implementation due to MSIE 
+		//   errors, such as not being able to modify the name attribute of an existing node and strange Gecko behavior
+		//   regarding the inconsistant correspondence of an input node's value attribute and value property.
+		//   Instead of invoking the native cloneNode method, each element is copied manually when it is iterated over.]
+		//	 [Note: step 11 of the the specification's algorithm has been merged into step 5. See note at step 11 below]
+		//(11). If the template has a name and it is not being ignored (see the previous two steps), then, for every 
+		//      attribute on the new element, and for every attribute in every descendant of the new element: if the 
+		//      attribute starts with a zero-width non-breaking space character (U+FEFF) then that character is 
+		//      removed from the attribute; otherwise, any occurrences of a string consisting of an opening square 
+		//      bracket (U+005B, "[") or a modifier letter half triangular colon (U+02D1), the template's name, 
+		//      and a closing square bracket (U+005D, "]") or a middle dot (U+00B7), are replaced by the new 
+		//      repetition block's index. This is performed regardless of the types, names, or namespaces of attributes, 
+		//      and is done to all descendants, even those inside nested forms, nested repetition templates, and so forth.
+		var block;
+		
+		//(10). If the template has a name (see the previous step), and that name contains either an opening square 
+		//      bracket (U+005B, "[") a modifier letter half triangular colon (U+02D1), a closing square bracket 
+		//      (U+005D, "]") or a middle dot (U+00B7), then the template's name is ignored for the purposes of 
+		//      [this] step.
+		var replaceValue = this.repetitionIndex;
+		var reTemplateName, processAttr;
+		if(IDAttrValue && !/\u005B|\u02D1|\u005D|\u00B7/.test(IDAttrValue)){ //VALID LOGIC?
+			reTemplateName = new RegExp("(\\[|\u02D1)" + IDAttrValue + "(\\]|\u00B7)", 'g'); //new RegExp('(\\u005B|\\u02D1)' + IDAttrValue + '(\\u005D|\\u00B7)', 'g');
+			processAttr = function(attrVal){ //Function that processes an attribute value as defined in step 11
+				if(!attrVal) 
+					return attrVal;
+				attrVal = attrVal.toString();
+				if(attrVal.indexOf("\uFEFF") === 0)
+					return attrVal.replace(/^\uFEFF/, '');
+				return attrVal.replace(reTemplateName, replaceValue);
+			};
+		}
+		block = $wf2.cloneNode(this, processAttr);
+		block.wf2Initialized = false;
+		reTemplateName = null;
+		
+		//6. If this algorithm was invoked via the addRepetitionBlockByIndex()  method, the new repetition block 
+		//   element's index is set to the method's index argument. Otherwise, the new repetition block element's 
+		//   index is set to the template's index. [Note: if called by addRepetitionBlockByIndex() then the 
+		//   template's repetitionIndex has already been set to the index argument. Redundant algorithm step.]
+		//block.repetitionIndex = this.repetitionIndex; //this is set in the constructor for the repetitionBlock
+		//7. If the new repetition block element is in the http://www.w3.org/1999/xhtml namespace, then the 
+		//   repeat attribute in no namespace on the cloned element has its value changed to the new block's 
+		//   index. Otherwise, the repeat attribute in the http://www.w3.org/1999/xhtml namespace has its value 
+		//   changed to the new block's index.
+		//if(block.namespaceURI == 'http://www.w3.org/1999/xhtml')
+			block.setAttribute('repeat', this.repetitionIndex); //when inserted into DOM, constructor sets block.repetitionIndex
+		//else
+		//	block.setAttributeNS('http://www.w3.org/1999/xhtml', 'repeat', this.repetitionIndex);
+		
+		//8. If the new repetition block element is in the http://www.w3.org/1999/xhtml namespace, then any 
+		//   repeat-min, repeat-max, or repeat-start attributes in no namespace are removed from the element. 
+		//   Otherwise, any repeat-min, repeat-max, or repeat-start attributes in the http://www.w3.org/1999/xhtml 
+		//   namespace are removed instead.
+
+		//if(block.namespaceURI == 'http://www.w3.org/1999/xhtml'){
+			block.removeAttribute('repeat-min');
+			block.removeAttribute('repeat-max');
+			block.removeAttribute('repeat-start');
+		//}
+		//else {
+		//	block.removeAttributeNS('http://www.w3.org/1999/xhtml', 'repeat-min');
+		//	block.removeAttributeNS('http://www.w3.org/1999/xhtml', 'repeat-max');
+		//	block.removeAttributeNS('http://www.w3.org/1999/xhtml', 'repeat-start');
+		//}
+		
+		//(steps 9 and 10 moved to before step 5 (operates on this repetition template, and not on cloned block))
+
+
+		//11. (Note: the algorithm below which most closely follows the algorithm as described in the specification,
+		//    this has been merged into the cloning of the template in step 5. This has been done because of MSIE 
+		//    errors, such as not being able to modify the name attribute of an existing node and strange Gecko behavior
+		//    regarding the inconsistant correspondence of an input node's value attribute and value property.)
+		//if(IDAttrValue && !ignoreName){
+		//	var reTemplateName = new RegExp('(?:\\u005B|\\u02D1)' + IDAttrValue + '(?:\\u005D|\\u00B7)', 'g');
+		//	function processAttrs(node){
+		//		var i,attr;
+		//		for(i = 0; node.attributes && i < node.attributes.length; i++){
+		//			if(!(attr = node.attributes[i]).nodeValue)
+		//				continue;
+		//			
+		//			if(String(attr.nodeValue).indexOf("\uFEFF") === 0)
+		//				attr.nodeValue = attr.nodeValue.replace(/^\uFEFF/, '');
+		//				
+		//			else if(reTemplateName.test(attr.nodeValue))
+		//				attr.nodeValue = attr.nodeValue.replace(reTemplateName, block.getAttribute('repeat'));
+		//		}
+		//		for(i = 0; i < node.childNodes.length; i++)
+		//			processAttrs(node.childNodes[i]);
+		//	}
+		//	processAttrs(block);
+		//}
+
+			
+		//12. If the template has a name (see the earlier steps): If the new repetition block element is in the 
+		//    http://www.w3.org/1999/xhtml namespace, then the repeat-template attribute in no namespace on the 
+		//    cloned element has its value set to the template's name. Otherwise, the repeat-template attribute 
+		//    in the http://www.w3.org/1999/xhtml namespace has its value set to the template's name. (This 
+		//    happens even if the name was ignored for the purposes of the previous step.)
+		if(IDAttrName){
+			//if(block.namespaceURI == "http://www.w3.org/1999/xhtml")
+				block.setAttribute('repeat-template', IDAttrValue); //block.setAttributeNS(null, 'repeat-template', IDAttr.nodeValue);
+			//else 
+			//	block.setAttributeNS('http://www.w3.org/1999/xhtml', 'repeat-template', IDAttr.nodeValue);
+			
+			
+			//13. The attribute from which the template's name was derived, if any, and even if it was ignored, is 
+			//    removed from the new repetition block element. (See the previous four steps.)
+			block.removeAttribute(IDAttrName);
+		}
+
+		//14. If the first argument to the method was null, then the template once again crawls through its 
+		//    previous siblings, this time stopping at the first node (possibly the template itself) whose 
+		//    previous sibling is a repetition block (regardless of what that block's template is) or the first 
+		//    node that has no previous sibling, whichever comes first. The new element is the inserted into the 
+		//    parent of the template, immediately before that node. Mutation events are fired if appropriate.
+		if(!refNode){
+			refNode = this;
+			while(refNode.previousSibling && refNode.previousSibling.repetitionType != RepetitionElement.REPETITION_BLOCK)
+				refNode = refNode.previousSibling;
+			this.parentNode.insertBefore(block, refNode);
+			this.repetitionBlocks.push(block);
+		}
+		//15. Otherwise, the new element is inserted into the parent of the node that was passed to the method 
+		//    as the first argument, immediately after that node (before the node's following sibling, if any). 
+		//    Mutation events are fired if appropriate.
+		else {
+			refNode.parentNode.insertBefore(block, refNode.nextSibling);
+			this.repetitionBlocks.push(block);
+			if($wf2.sortNodes)
+				this.repetitionBlocks.sort($wf2.sortNodes);
+		}
+		
+		//16. The template's index is increased by one. 
+		this.repetitionIndex++;
+		
+		//[apply constructors to the new repetition block, and to the new remove buttons, add buttons, etc]
+		$wf2.constructRepetitionBlock.apply(block);
+		$wf2.initRepetitionTemplates(block);
+		
+		$wf2.initRepetitionButtons('add', block);
+		$wf2.initRepetitionButtons('remove', block);
+		$wf2.initRepetitionButtons('move-up', block);
+		$wf2.initRepetitionButtons('move-down', block);
+		
+		//In addition, user agents must automatically disable add buttons (irrespective of the value of the 
+		//   disabled DOM attribute) when the buttons are not in a repetition block that has an associated 
+		//   template and their template attribute is either not specified or does not have an ID that points 
+		//   to a repetition template, and, when the repetition template's repeat-max attribute is less than 
+		//   or equal to the number of repetition blocks that are associated with that template and that have 
+		//   the same parent. This automatic disabling does not affect the DOM disabled attribute. It is an 
+		//   intrinsic property of these buttons.
+		if($wf2.isInitialized){ //if buttons not yet initialized, will initially be called by _init_document
+			$wf2.updateAddButtons(this);
+			$wf2.updateMoveButtons(this.parentNode);
+		}
+		
+		//Setup block with the other WF2 behavior
+		$wf2.initNonRepetitionFunctionality(block);
+		//var els = $wf2.getElementsByTagNamesAndAttribute.apply(block, [['*'], "autofocus"]); //ISSUE: Any form control (except hidden and output controls) can have an autofocus attribute specified. //var elName = els[i].nodeName.toLowerCase(); if(elName == 'output' || (elName == 'input' && els[i].type == 'hidden'))
+		//for(var i = 0; i < els.length; i++)
+		//	$wf2.initAutofocusElement(els[i]);
+
+		//17. An added event with no namespace, which bubbles but is not cancelable and has no default action, 
+		//    must be fired on the repetition template using the RepetitionEvent interface, with the repetition 
+		//    block's DOM node as the context information in the element  attribute.
+		var addEvt;
+		try {
+			if(document.createEvent)
+				addEvt = document.createEvent('UIEvents'); //document.createEvent("RepetitionEvent")
+			else if(document.createEventObject)
+				addEvt = document.createEventObject();
+			RepetitionEvent._upgradeEvent.apply(addEvt);
+			addEvt.initRepetitionEvent('added', true /*canBubble*/, false /*cancelable*/, block);
+			if(this.dispatchEvent)
+				this.dispatchEvent(addEvt);
+			else if(this.fireEvent){
+				//console.warn("fireEvent('onadd') for MSIE is not yet working");
+				//this.fireEvent('onadded', addEvt);
+			}
+		}
+		catch(err){
+			addEvt = new Object();
+			RepetitionEvent._upgradeEvent.apply(addEvt);
+			addEvt.initRepetitionEvent('added', true /*canBubble*/, false /*cancelable*/, block);
+		}
+
+		//Add support for event handler set with HTML attribute 
+		var handlerAttr;
+		if((handlerAttr = this.getAttribute('onadded')) && (!this.onadded || typeof this.onadded != 'function')){  //in MSIE, attribute == property
+			this.onadded = new Function('event', handlerAttr);
+		}
+		//Deprecated
+		else if((handlerAttr = this.getAttribute('onadd')) && (!this.onadd || typeof this.onadd != 'function')){
+			this.onadd = new Function('event', handlerAttr);
+		}
+
+		try {
+			//Dispatch events for the old event model (extension to spec)
+			if(this.onadded){
+				//this.onadded(addEvt); 
+				this.onadded.apply(this, [addEvt]); //for some reason, exceptions cannot be caught if using the method above in MSIE
+			}
+			else if(this.onadd){ //deprecated
+				//this.onadd(addEvt);
+				this.onadd.apply(this, [addEvt]); 
+			}
+		}
+		catch(err){
+			//throw exception within setTimeout so that the current execution will not be aborted
+			setTimeout(function(){
+				throw err;
+			}, 0); //using 0 milliseconds done at <http://novemberborn.net/javascript/threading-quick-tip>
+		}
+
+		//18. The return value is the newly cloned element.
+		return block;
+	},
+	//Element addRepetitionBlockByIndex(in Node refNode, in long index);
+	addRepetitionBlockByIndex : function(refNode, index){
+		$wf2.addRepetitionBlock.apply(this, [refNode, index])
+	},
+	
+	//## RemoveRepetitionBlock algorithm #############################################################
+	
+	//void removeRepetitionBlock();
+	removeRepetitionBlock : function(){
+		if(this.repetitionType != RepetitionElement.REPETITION_BLOCK)
+			throw $wf2.DOMException(9); //NOT_SUPPORTED_ERR
+
+		//1. The node is removed from its parent, if it has one. Mutation events are fired if appropriate. 
+		//   (This occurs even if the repetition block is an orphan repetition block.)
+		var parentNode = this.parentNode; //save for updateMoveButtons
+		var block = parentNode.removeChild(this);
+		$wf2.updateMoveButtons(parentNode);
+		
+		//The following loop used to appear within step #3 below; 
+		//  this caused problems because the program state was incorrect when onremoved was called (repetitionBlocks was not modified)
+		if(this.repetitionTemplate != null){
+			for(var i = 0; i < this.repetitionTemplate.repetitionBlocks.length; i++){
+				if(this.repetitionTemplate.repetitionBlocks[i] == this){
+					this.repetitionTemplate.repetitionBlocks.splice(i,1);
+					break;
+				}
+			}
+		}
+
+		//2. If the repetition block is not an orphan, a removed event with no namespace, which bubbles but 
+		//   is not cancelable and has no default action, must be fired on the element's repetition template, 
+		//   using the RepetitionEvent interface, with the repetition block's DOM node as the context information 
+		//   in the element attribute.
+		if(this.repetitionTemplate != null){
+			var removeEvt;
+			try {
+				if(document.createEvent)
+					removeEvt = document.createEvent('UIEvents'); //document.createEvent("RepetitionEvent")
+				else if(document.createEventObject)
+					removeEvt = document.createEventObject();
+				RepetitionEvent._upgradeEvent.apply(removeEvt);
+				removeEvt.initRepetitionEvent('removed', true /*canBubble*/, false /*cancelable*/, this);
+				if(this.repetitionTemplate.dispatchEvent)
+					this.repetitionTemplate.dispatchEvent(removeEvt);
+				else if(this.repetitionTemplate.fireEvent){
+					//console.warn("fireEvent('onremoved') for MSIE is not yet working");
+					//this.repetitionTemplate.fireEvent('onremoved', removeEvt);
+				}
+			}
+			catch(err){
+				removeEvt = new Object();
+				RepetitionEvent._upgradeEvent.apply(removeEvt);
+				removeEvt.initRepetitionEvent('removed', true /*canBubble*/, false /*cancelable*/, this);
+			}
+			
+			//Add support for event handler set with HTML attribute
+			var handlerAttr;
+			if((handlerAttr = this.repetitionTemplate.getAttribute('onremoved')) &&
+				    (!this.repetitionTemplate.onremoved || typeof this.repetitionTemplate.onremoved != 'function')) //in MSIE, attribute == property
+			{  
+				this.repetitionTemplate.onremoved = new Function('event', handlerAttr);
+			}
+			//Deprecated
+			else if((handlerAttr = this.repetitionTemplate.getAttribute('onremove')) &&
+					 (!this.repetitionTemplate.onremove || typeof this.repetitionTemplate.onremove != 'function'))
+			{
+				this.repetitionTemplate.onremove = new Function('event', handlerAttr);
+			}
+
+			try {
+				//Dispatch events for the old event model (extension to spec)
+				if(this.repetitionTemplate.onremoved){
+					//this.repetitionTemplate.onremoved(removeEvt);	
+					this.repetitionTemplate.onremoved.apply(this, [removeEvt]); //for some reason, exceptions cannot be caught if using the method above in MSIE
+				}
+				else if(this.repetitionTemplate.onremove){ //deprecated
+					//this.repetitionTemplate.onremove(removeEvt);
+					this.repetitionTemplate.onremove.apply(this, [removeEvt]); 
+				}
+			}
+			catch(err){
+				//throw exception within setTimeout so that the current execution will not be aborted
+				setTimeout(function(){
+					throw err;
+				}, 0);
+			}
+		}
+
+		//3. If the repetition block is not an orphan, then while the remaining number of repetition blocks 
+		//   associated with the original element's repetition template and with the same parent as the template 
+		//   is less than the template's repeat-min attribute and less than its repeat-max attribute, the 
+		//   template's replication behaviour is invoked (specifically, its addRepetitionBlock() method is called). 
+		if(this.repetitionTemplate != null){
+//			//BUG: The following needs to be moved before the call to onremoved
+//			var t = this.repetitionTemplate;
+//			for(var i = 0; i < t.repetitionBlocks.length; i++){
+//				if(t.repetitionBlocks[i] == this){
+//					t.repetitionBlocks.splice(i,1);
+//					break;
+//				}
+//			}
+			if(this.repetitionTemplate.repetitionBlocks.length < this.repetitionTemplate.repeatMin 
+			     && this.repetitionTemplate.repetitionBlocks.length < this.repetitionTemplate.repeatMax)
+			{
+				this.repetitionTemplate.addRepetitionBlock();
+			}
+
+			//enable add buttons
+			if(this.repetitionTemplate.repetitionBlocks.length < this.repetitionTemplate.repeatMax){
+				//var addBtns = cssQuery("button[type=add]");
+				var addBtns = $wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['button'], 'type', 'add']);
+				for(i = 0; i < addBtns.length; i++){
+					if(addBtns[i].htmlTemplate == this.repetitionTemplate)
+						addBtns[i].disabled = false;
+				}
+			}
+		}
+	},
+
+	//## MoveRepetitionBlock algorithm #############################################################
+	 
+	//void moveRepetitionBlock(in long distance);
+	moveRepetitionBlock : function(distance){
+		if(this.repetitionType != RepetitionElement.REPETITION_BLOCK)
+			throw $wf2.DOMException(9); //NOT_SUPPORTED_ERR
+		
+		//1. If distance is 0, or if the repetition block has no parent, nothing happens and the algorithm ends here.
+		if(distance == 0 || this.parentNode == null)
+			return;
+		
+		//2. Set target, a reference to a DOM Node, to the repetition block being moved.
+		//   [Furthermore, move the reference to this block in the template's repetitionBlocks HTMLCollection to 
+		//   reflect the new position that it is being moved to.]
+		var target = this;
+		if(this.repetitionTemplate){
+			var pos = 0;
+			var rp = this.repetitionTemplate.repetitionBlocks;
+			while(pos < rp.length && rp[pos] != this)
+				pos++;
+			rp.splice(pos, 1);
+			rp.splice(distance < 0 ? Math.max(pos+distance, 0) : Math.min(pos+distance, rp.length), 0, this);
+		}
+		
+		//3. If distance is negative: while distance is not zero and target's previousSibling is defined and is 
+		//   not a repetition template, set target to this previousSibling and, if it is a repetition block, 
+		//   increase distance by one (make it less negative by one).
+		if(distance < 0){
+			while(distance != 0 && target.previousSibling && 
+			      target.previousSibling.repetitionType != RepetitionElement.REPETITION_TEMPLATE)
+			{
+				target = target.previousSibling;
+				if(target.repetitionType == RepetitionElement.REPETITION_BLOCK)
+					distance++;
+			}
+		}
+		//4. Otherwise, distance is positive: while distance  is not zero and target's nextSibling is defined 
+		//   and is not a repetition template, set target to this nextSibling and, if it is a repetition block, 
+		//   decrease distance by one. After the loop, set target to target's nextSibling (which may be null).
+		else {
+			while(distance != 0 && target.nextSibling && target.nextSibling.repetitionType != RepetitionElement.REPETITION_TEMPLATE){
+				target = target.nextSibling;
+				if(target.repetitionType == RepetitionElement.REPETITION_BLOCK)
+					distance--;
+			}
+			target = target.nextSibling;
+		}
+		
+		//5. Call the repetition block's parent node's insertBefore()  method with the newChild argument 
+		//   being the repetition block and the refChild argument being target (which may be null by this 
+		//   point). Mutation events are fired if appropriate. 
+		this.parentNode.insertBefore(this, target);
+		
+		//Keep focus on the move button which was clicked
+		if(this._clickedMoveBtn){
+			this._clickedMoveBtn.focus();
+			this._clickedMoveBtn = null;
+		}
+		
+		//In addition, user agents must automatically disable move-up buttons (irrespective of the 
+		//   value of the disabled DOM attribute) when their repetition block could not be moved any 
+		//   higher according to the algorithm above, and when the buttons are not in a repetition 
+		//   block. Similarly, user agents must automatically disable move-down buttons when their 
+		//   repetition block could not be moved any lower according to the algorithm above, and 
+		//   when the buttons are not in a repetition block. This automatic disabling does not affect 
+		//   the DOM disabled  attribute. It is an intrinsic property of these buttons.
+		$wf2.updateMoveButtons(this.parentNode);
+		
+		//6. A moved event with no namespace, which bubbles but is not cancelable and has no default action, 
+		//   must be fired on the element's repetition template (if it has one), using the RepetitionEvent 
+		//   interface, with the repetition block's DOM node as the context information in the element  attribute.
+		if(this.repetitionTemplate != null){
+			var moveEvt;
+			try {
+				if(document.createEvent)
+					moveEvt = document.createEvent('UIEvents'); //document.createEvent("RepetitionEvent")
+				else if(document.createEventObject)
+					moveEvt = document.createEventObject();
+				RepetitionEvent._upgradeEvent.apply(moveEvt);
+				moveEvt.initRepetitionEvent('moved', true /*canBubble*/, false /*cancelable*/, this);
+				if(this.repetitionTemplate.dispatchEvent)
+					this.repetitionTemplate.dispatchEvent(moveEvt);
+				else if(this.repetitionTemplate.fireEvent){
+					//console.warn("fireEvent('onmoved') for MSIE is not yet working");
+					//this.fireEvent('onmoved', moveEvt);
+				}
+			}
+			catch(err){
+				moveEvt = new Object();
+				RepetitionEvent._upgradeEvent.apply(moveEvt);
+				moveEvt.initRepetitionEvent('moved', true /*canBubble*/, false /*cancelable*/, this);
+			}
+			
+			//Add support for event handler set with HTML attribute---------------------
+			var handlerAttr;
+			if((handlerAttr = this.repetitionTemplate.getAttribute('onmoved')) &&
+				    (!this.repetitionTemplate.onmoved || typeof this.repetitionTemplate.onmoved != 'function')) //in MSIE, attribute == property
+			{  
+				this.repetitionTemplate.onmoved = new Function('event', handlerAttr);
+			}
+			//Deprecated
+			else if(handlerAttr = this.repetitionTemplate.getAttribute('onmove'))
+			{
+				if(!this.repetitionTemplate.onmove || typeof this.repetitionTemplate.onmove != 'function'){
+					this.repetitionTemplate.onmove = new Function('event', handlerAttr);
+				}
+
+				//For MSIE, onmove is already an event, and attributes are equal to properties, so attribute value can be function.
+				//  The 'event' argument must be added to the function argument list.
+				var funcMatches;
+				if(typeof handlerAttr == 'function' && (funcMatches = handlerAttr.toString().match(/^\s*function\s+anonymous\(\s*\)\s*\{((?:.|\n)+)\}\s*$/))){
+					this.repetitionTemplate.onmove = new Function('event', funcMatches[1]);
+				}
+			}
+			
+			
+//			var onmovedAttr = this.repetitionTemplate.getAttribute('onmoved') 
+//			                   || /* deprecated */ this.repetitionTemplate.getAttribute('onmove');
+			
+			//For MSIE, onmove is already an event, and attributes are equal to properties, so attribute value can be function.
+			//  The 'event' argument must be added to the function argument list.
+//			var funcMatches;
+//			if(typeof onmovedAttr == 'function' && (funcMatches = onmovedAttr.toString().match(/^\s*function\s+anonymous\(\s*\)\s*\{((?:.|\n)+)\}\s*$/))){
+//				this.repetitionTemplate.onmoved = new Function('event', funcMatches[1]);
+//			}
+			
+			//If the onmove attribute has been set but the property (method) has not
+//			if(onmovedAttr && !this.repetitionTemplate.onmoved)
+//				this.repetitionTemplate.onmoved = new Function('event', onmovedAttr);
+			
+			//This need not be done in MSIE since onmove is already an event, and attributes == properties
+			//if(onmoveAttr && typeof onmoveAttr != 'function' /* for MSIE */ && 
+			//      (!this.repetitionTemplate.onmove || typeof this.repetitionTemplate.onmove != 'function')
+			//   ){
+			//	this.repetitionTemplate.onmove = new Function('event', onmoveAttr);
+			//}
+
+			try {
+				//Dispatch events for the old event model (extension to spec)
+				if(this.repetitionTemplate.onmoved){
+					//this.repetitionTemplate.onmoved(moveEvt);
+					this.repetitionTemplate.onmoved.apply(this, [moveEvt]);
+				}
+				else if(this.repetitionTemplate.onmove){ //deprecated
+					//this.repetitionTemplate.onmove(moveEvt);
+					this.repetitionTemplate.onmove.apply(this, [moveEvt]);
+				}
+			}
+			catch(err){
+				//throw exception within setTimeout so that the current execution will not be aborted
+				setTimeout(function(){
+					throw err;
+				}, 0); //using 0 milliseconds done at <http://novemberborn.net/javascript/threading-quick-tip>
+			}
+		}
+	},
+	
+	//## Other helper functions for the repetition model behaviors ##############################
+	getRepetitionBlock : function(node){
+		while(node = node.parentNode){
+			if(node.repetitionType == RepetitionElement.REPETITION_BLOCK){
+				return node;
+			}
+		}
+		return null;
+	},
+
+	getHtmlTemplate : function(button){
+		var attr = button.getAttribute('template');
+		var node;
+		if(attr && (node = document.getElementById(attr)) && node.getAttribute('repeat') == 'template' /*node.repetitionType == RepetitionElement.REPETITION_TEMPLATE*/)
+			return node;
+		return null;
+	},
+	
+	updateAddButtons : function(rt){
+		//In addition, user agents must automatically disable add buttons (irrespective of the value of the 
+		//   disabled DOM attribute) when the buttons are not in a repetition block that has an associated 
+		//   template and their template attribute is either not specified or does not have an ID that points 
+		//   to a repetition template, and, when the repetition template's repeat-max attribute is less than 
+		//   or equal to the number of repetition blocks that are associated with that template and that have 
+		//   the same parent. This automatic disabling does not affect the DOM disabled attribute. It is an 
+		//   intrinsic property of these buttons.
+		
+		var repetitionTemplates = rt ? [rt] : $wf2.repetitionTemplates;
+		
+		//var btns = cssQuery("button[type=add]");
+		var btns = $wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['button'], 'type', 'add']);
+		for(var i = 0; i < btns.length; i++){
+			for(var t, j = 0; t = repetitionTemplates[j]; j++){
+				if(btns[i].htmlTemplate == t && t.repetitionBlocks.length >= t.repeatMax){
+					btns[i].disabled = true;
+				}
+			}
+		}
+	},
+
+	updateMoveButtons : function(parent){
+		//In addition, user agents must automatically disable move-up buttons (irrespective of the value of 
+		//   the disabled DOM attribute) when their repetition block could not be moved any higher according 
+		//   to the algorithm above, and when the buttons are not in a repetition block. Similarly, user agents 
+		//   must automatically disable move-down buttons when their repetition block could not be moved any 
+		//   lower according to the algorithm above, and when the buttons are not in a repetition block. This 
+		//   automatic disabling does not affect the DOM disabled  attribute. It is an intrinsic property of 
+		//   these buttons.
+		
+		var i;
+		var rbs = [];
+		
+		//update all move buttons if a repetition block's parent was not given
+		if(!parent){
+			var visitedParents = [];
+			//var rbs = cssQuery('*[repeat]:not([repeat="template"])');
+			//var rbs = $wf2.getElementsByProperty('repetitionType', RepetitionElement.REPETITION_BLOCK);
+			rbs = $wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['*'], 'repeat', 'template', true]);
+			for(i = 0; block = rbs[i]; i++){
+				//if(!visitedParents.some(function(i){return i == block.parentNode})){
+				if(!$wf2.arrayHasItem(visitedParents, block.parentNode)){
+					$wf2.updateMoveButtons(block.parentNode);
+					visitedParents.push(block.parentNode);
+				}
+			}
+			return;
+		}
+		
+		//get all of the repetition block siblings
+		var j,btn,block;
+		var child = parent.firstChild;
+		while(child){
+			if(child.repetitionType == RepetitionElement.REPETITION_BLOCK)
+				rbs.push(child);
+			child = child.nextSibling;
+		}
+		
+		//disable or enable movement buttons within each block
+		for(i = 0; block = rbs[i]; i++){
+			//var moveUpBtns = cssQuery("button[type=move-up]", block);
+			var moveUpBtns = $wf2.getElementsByTagNamesAndAttribute.apply(block, [['button'], 'type', 'move-up']);
+			for(j = 0; btn = moveUpBtns[j]; j++){
+				btn.disabled = 
+					//if the button is not in a repetition block
+					!(rb = $wf2.getRepetitionBlock(btn))
+					 ||
+					//when their repetition block could not be moved any lower
+					(i == 0);
+			}
+			//var moveDownBtns = cssQuery("button[type=move-down]", block);
+			var moveDownBtns = $wf2.getElementsByTagNamesAndAttribute.apply(block, [['button'], 'type', 'move-down']);
+			for(j = 0; btn = moveDownBtns[j]; j++){
+				btn.disabled = 
+					//if the button is not in a repetition block
+					!(rb = $wf2.getRepetitionBlock(btn))
+					 ||
+					//when their repetition block could not be moved any higher
+					(i == rbs.length-1);
+			}
+		}
+	},
+
+	/*#############################################################################################
+	 # Section: Extensions to the input element
+	 ##############################################################################################*/
+	
+	initNonRepetitionFunctionality : function(parent){
+		parent = (parent || document.documentElement);
+		var i,j, frm, frms = parent.getElementsByTagName('form');
+		for(i = 0; frm = frms[i]; i++){
+			if(frm.checkValidity && !$wf2.hasBadImplementation)
+				continue;
+			frm.checkValidity = $wf2.formCheckValidity;
+			
+			if(frm.addEventListener)
+				frm.addEventListener('submit', $wf2.onsubmitValidityHandler, false);
+			else
+				frm.attachEvent('onsubmit', $wf2.onsubmitValidityHandler);
+		}
+		
+		var ctrl, ctrls = $wf2.getElementsByTagNames.apply(parent, ['input','select','textarea', 'button']);//parent.getElementsByTagName([i]);
+		for(i = 0; ctrl = ctrls[i]; i++){
+			$wf2.applyValidityInterface(ctrl);
+			$wf2.updateValidityState(ctrl); //ctrl._updateValidityState();
+		}
+		
+		//Autofocus **********************************************************
+		//Authors must not set the autofocus attribute on multiple enabled elements in a document.
+		//  If multiple elements with the autofocus attribute set are inserted into a document, each one
+		//  will be processed as described above, as they are inserted. This means that during document
+		//  load, for example, the last focusable form control in document order with the attribute set
+		//  will end up with the focus.
+		var els = $wf2.getElementsByTagNamesAndAttribute.apply(document.documentElement, [['*'], 'autofocus']); //ISSUE: Any form control (except hidden and output controls) can have an autofocus attribute specified. //var elName = els[i].nodeName.toLowerCase(); if(elName == 'output' || (elName == 'input' && els[i].type == 'hidden'))
+		if(parent.getAttribute('autofocus'))
+			els.unshift(parent);
+		for(i = 0; i < els.length; i++)
+			$wf2.initAutofocusElement(els[i]);
+
+		// Maxlength for textareas ******************************************************
+		var textareas = $wf2.getElementsByTagNamesAndAttribute.apply(parent, [['textarea'], 'maxlength']);
+		if(parent.nodeName.toLowerCase() == 'textarea')
+			textareas.unshift(parent);
+		for(i = 0; i < textareas.length; i++)
+			textareas[i].maxLength = parseInt(textareas[i].getAttribute('maxlength'));
+		//TODO: we must dynamically apply this behavior for new textareas (via repetition model or eventlistener)
+	},
+	
+	initAutofocusElement : function(el){
+		//skip if already initialized
+		if(el.autofocus === false || el.autofocus === true) //(el.autofocus !== undefined) does not work due to MSIE's handling of attributes
+			return;
+		el.autofocus = true;
+		
+		//[autofocus if] the control is not disabled
+		if(el.disabled)
+			return;
+
+		//[control] is of a type normally focusable in the user's operating environment
+		//Don't focus on the control if it is not visible or nor displayed
+		var node = el;
+		while(node && node.nodeType == 1){
+			if($wf2.getElementStyle(node, 'visibility') == 'hidden' || $wf2.getElementStyle(node, 'display') == 'none')
+				return;
+			node = node.parentNode;
+		}
+
+		//Then the UA should focus the control, as if the control's focus() method was invoked.
+		//  UAs with a viewport should also scroll the document enough to make the control visible,
+		//  [[even if it is not of a type normally focusable.]] //WHAT DOES THIS MEAN?
+		el.focus(); //BUG: in Gecko this does not work within DOMNodeInserted event handler, but the following does; setTimeout(function(){el.focus();}, 0);
+		
+		
+	},
+
+	/*#############################################################################################
+	 # Section: Form Validation model
+	 ##############################################################################################*/
+
+	formCheckValidity : function(){
+		var i, el, valid = true;
+		
+		//When a form is submitted, user agents must act as if they used the following algorithm.
+		//   First, each element in that form's elements list is added to a temporary list (note that
+		//   the elements list is defined to be in document order).
+		
+		//An invalid event must be fired on each element that, when checked, is found to fail to
+		//   comply with its constraints (i.e. each element whose validity.valid DOM attribute is
+		//   false) and is still a member of the form after the event has been handled.
+		//var _elements = [];
+		var formElements = $wf2.getFormElements.apply(this);
+		//for(i = 0; i < formElements.length; i++)
+		//	_elements.push(formElements[i]);
+		for(i = 0; el = formElements[i]; i++){
+			var type = (el.getAttribute('type') ? el.getAttribute('type').toLowerCase() : el.type);
+			el.willValidate = !(/(hidden|button|reset|add|remove|move-up|move-down)/.test(type) || !el.name || el.disabled)
+			//Then, each element in this list whose willValidate DOM attribute is true is checked for validity
+			if(el.checkValidity && el.willValidate){
+				if(!el.checkValidity() && el.checkValidity() != undefined)
+					valid = false;
+			}
+		}
+		
+		if (!valid) {
+			$wf2.hiliteFirstError();
+		}
+		return valid;
+	},
+	
+	hiliteFirstError: function () {
+		
+		if($wf2.invalidIndicators.length){ //second condition needed because modal in oninvalid handler may cause indicators to disappear before this is reached
+			$wf2.invalidIndicators[0].errorMsg.className += " wf2_firstErrorMsg";
+			
+			//scroll to near the location where invalid control is
+			el = $wf2.invalidIndicators[0].target;
+			if(el.style.display == 'none' || !el.offsetParent){
+				while(el && (el.nodeType != 1 || (el.style.display == 'none' || !el.offsetParent)))
+					el = el.previousSibling;
+				var cur = el;
+				var top = 0;
+				if(cur && cur.offsetParent) {
+					top = cur.offsetTop;
+					while (cur = cur.offsetParent)
+						top += cur.offsetTop;
+				}
+				scrollTo(0, top);
+			}
+			//focus on the first invalid control and make sure error message is visible
+			else {
+				
+				setTimeout(
+					function() {
+						el.focus();
+						$wf2.fireEvent(el, 'focus');
+					}
+				, 10)
+				
+				//NOTE: We should only do this if the control's style.bottom == 0
+				scrollBy(0, $wf2.invalidIndicators[0].errorMsg.offsetHeight);
+			}
+		}
+		
+	},
+	
+	controlCheckValidity : function(){
+		$wf2.controlCheckValidityOfElement(this);
+		
+	},
+	
+	controlCheckValidityOfElement: function (el) {
+		
+	
+		
+		$wf2.updateValidityState(el);
+		
+		if (el.validity.valid) {
+			
+			return true;
+		}
+		
+		var canceled = false;
+		
+		var evt;
+		try {
+			if(document.createEvent)
+				evt = document.createEvent('Events'); //document.createEvent("RepetitionEvent")
+			else if(document.createEventObject)
+				evt = document.createEventObject();
+			evt.initEvent('invalid', true /*canBubble*/, true /*cancelable*/);
+			evt.srcElement = el;
+			if(el.dispatchEvent)
+				canceled = !el.dispatchEvent(evt);
+			else if(el.fireEvent){
+				//console.warn("fireEvent('oninvalid') for MSIE is not yet working");
+				//el.fireEvent('oninvalid', invalidEvt);
+			}
+		}
+		catch(err){
+			evt = new Object();
+			if(evt.initEvent)
+				evt.initEvent('invalid', true /*canBubble*/, true /*cancelable*/);
+			else {
+				evt.type = 'invalid';
+				evt.cancelBubble = false;
+			}
+			evt.target = evt.srcElement = el;
+		}
+		
+		var oninvalidAttr = el.getAttribute('oninvalid');
+		if(oninvalidAttr && (!el.oninvalid || typeof el.oninvalid != 'function')) //in MSIE, attribute == property
+			el.oninvalid = new Function('event', oninvalidAttr);
+
+		try {
+			//Dispatch events for the old event model
+			if(el.oninvalid){
+				//canceled = el.oninvalid(evt) === false || canceled; 
+				canceled = el.oninvalid.apply(el, [evt]) === false || canceled; //for some reason, exceptions cannot be caught if using the method above in MSIE
+			}
+		}
+		catch(err){
+			//throw exception within setTimeout so that the current execution will not be aborted
+			setTimeout(function(){
+				throw err;
+			}, 0);
+		}
+
+		//Determine if this radio/checkbox already has an invalid indicator
+		var hasInvalidIndicator = false;
+		if(el.type == 'radio' || el.type == 'checkbox'){
+			for(var i = 0; i < $wf2.invalidIndicators.length; i++){
+				if(el.form[el.name][0] == $wf2.invalidIndicators[i].target){
+					hasInvalidIndicator = true;
+					break;
+				}
+			}
+		}
+
+		//Do default action
+		if(!canceled && !hasInvalidIndicator) //(!(el.form && el.form[el.name]) || !el.form[el.name].wf2HasInvalidIndicator)
+			$wf2.addInvalidIndicator(el);
+		return false;
+	},
+
+	//Frequently used regular expressions //W(?:0[1-9]|[1-4]\d|5[0-2])|
+	//monthRegExp : /^\d\d\d\d-(0\d|1[0-2])$/,
+	//weekRegExp : /^(\d\d\d\d)-W(0[1-9]|[1-4]\d|5[0-2])$/,
+	//timeRegExp : /^(0\d|1\d|2[0-4]):([0-5]\d)(:[0-5]\d(.\d+)?)?$/,
+	numberRegExp : /^-?\d+(.\d+)?(e-?\d+)?$/,
+	//numberOrAnyRegExp : /^(any|-?\d+(.\d+)?(e-?\d+)?)$/i,
+	urlRegExp : /^(\w+):(\/\/)?.+$/i,
+	emailRegExp : /^\S+@\S+$/i,
+	
+	//Zero points for datetime-related types (set in onDOMContentLoaded function)
+//	zeroPointDatetime      : null,
+//	zeroPointDatetimeLocal : null,
+//	zeroPointDate          : null,
+//	zeroPointMonth         : null,
+//	zeroPointWeek          : null,
+//	zeroPointTime          : null,
+	
+	copyOf: function(obj) {
+		if (obj !== null && obj !== undefined) {
+			var r = new Object();
+			for (i in obj) {
+				
+				try {
+					r[i] = obj[i];
+				} 
+				catch (ex) {
+				// do nothing;
+				}
+			}
+			
+		} else {
+			r = null;
+		}
+		
+		return r;
+	},
+	
+	getOriginalAttrNode: function (node, attrName) {
+		var r;
+		
+		var dataSetItemName = attrName + 'AttrNode';
+		
+		if ($wf2.getDatasetItem(node, dataSetItemName) == null) {
+			r = $wf2.copyOf(node.getAttributeNode(attrName));
+			$wf2.setDatasetItem(node, dataSetItemName, r);
+		} else {
+			r = $wf2.getDatasetItem(node, dataSetItemName);
+			if (r == 'null') {
+				r = null;
+			}
+		}
+		
+		return r;
+	},
+	
+	//This function is called "live" 
+	updateValidityState : function(node){
+		//if(node.form && node.form[node.name] && node.form[node.name].wf2HasInvalidIndicator)
+		//	return;
+		
+		var minAttrNode, maxAttrNode, valueAttrNode;
+		
+		minAttrNode = $wf2.getOriginalAttrNode(node, 'min');
+		maxAttrNode = $wf2.getOriginalAttrNode(node, 'max');
+		valueAttrNode = $wf2.getOriginalAttrNode(node, 'value');
+
+		node.min = undefined; //wf2Min
+		node.max = undefined; //wf2Max
+		node.step = undefined; //wf2Step
+		
+		
+		
+		node.validity = $wf2.createValidityState();
+		node.validity.customError = !!node.validationMessage;
+		
+		//var type = node.type ? node.type.toLowerCase() : 'text';
+		//var type = (node.type ? node.getAttribute('type').toLowerCase() :
+		//                       (node.nodeName.toLowerCase() == 'input' ? 'text' : ''));
+		var type = (node.getAttribute('type') ? node.getAttribute('type').toLowerCase() : node.type);
+		var isTimeRelated = (type == 'datetime' || type == 'datetime-local' || type == 'time'); //datetime, datetime-local, time
+		var isDateRelated = (type == 'date' || type == 'month' || type == 'week'); //date, month, week
+		var isNumberRelated = (type == 'number' || type == 'range'); //number, range
+		var isFileInput = (type == 'file');
+		var doCheckPrecision = (isTimeRelated || isDateRelated || isNumberRelated); //datetime, datetime-local, time, date, month, week, number, range
+		var doMaxLengthCheck = doCheckPrecision || node.nodeName.toLowerCase() == 'textarea'; //datetime, datetime-local, time, date, month, week, number, range, textarea
+		var doCheckRange = (doCheckPrecision || isFileInput); //datetime, datetime-local, time, date, month, week, number, range, file
+		var isRadioOrCheckbox = (type == 'radio' || type == 'checkbox');
+		var doRequiredCheck = (doMaxLengthCheck  || //datetime, datetime-local, time, date, month, week, number, range, textarea
+							   isFileInput       ||
+							   type == 'email'   ||
+							   type == 'url'     ||
+							   type == 'text'    ||
+							   type == 'password'||
+							   type == 'tel' ||
+							   isRadioOrCheckbox);
+		
+		//If a control has its type attribute changed to another type, then the user agent must reinterpret the min and
+		//   max  attributes. If an attribute has an invalid value according to the new type, then the appropriate
+		//   default must be used (and not, e.g., the default appropriate for the previous type). Control values that
+		//   no longer match the range allowed for the control must be handled as described in the error handling section.
+		//if(!node.wf2PreviousType)
+		//	node.wf2PreviousType == type;
+		//else if(type != node.wf2PreviousType){
+		//	throw Error("Currently unable to change the type of a control."); //TODO
+		//}
+		
+		if(type == 'range'){
+			//For this type...min defaults to 0...and value defaults to the min value.
+			node.min = (minAttrNode && $wf2.numberRegExp.test(minAttrNode.value)) ? Number(minAttrNode.value) : 0;
+			if((!valueAttrNode || !valueAttrNode.specified) && node.value === '' && !node.wf2ValueProvided){ //(!valueAttrNode || !valueAttrNode.specified) && 
+				node.setAttribute('value', node.min);
+				node.value = node.min;
+				node.wf2ValueProvided = true;
+			}
+		}
+		
+		node.wf2Value = node.value;
+
+		//valueMissing -- The control has the required attribute set but it has not been satisfied.
+		//The required attribute applies to all form controls except controls with the type hidden,
+		//   image inputs, buttons (submit, move-up, etc), and select and output elements. For
+		//   disabled or readonly controls, the attribute has no effect.
+		var type = (node.getAttribute('type') ? node.getAttribute('type').toLowerCase() : node.type);
+		node.willValidate = !(/(hidden|button|reset|add|remove|move-up|move-down)/.test(type) || !node.name || node.disabled);
+		if(doRequiredCheck && node.willValidate){
+			//For checkboxes, the required  attribute shall only be satisfied when one or more of
+			//  the checkboxes with that name in that form are checked.
+			//For radio buttons, the required attribute shall only be satisfied when exactly one of
+			//  the radio buttons in that radio group is checked. 
+			if(isRadioOrCheckbox){
+				if(node.form && node.form[node.name]){
+					var isRequired = false;
+					var hasChecked = false;
+					
+					var inputs =  node.form[node.name];
+					
+					/* 
+					 * remember: the above expression may return an array
+					 * or a single value.  Must check for this.
+					 */
+					if (inputs.length == undefined) {
+						if (inputs.getAttributeNode('required')) 
+							isRequired = true;
+						if (inputs.checked) 
+							hasChecked = true;
+					} else {
+						for (var i = 0; i < inputs.length; i++) {
+							if (inputs[i].getAttributeNode('required')) 
+								isRequired = true;
+							if (inputs[i].checked) 
+								hasChecked = true;
+						}
+					}
+					node.validity.valueMissing = (isRequired && !hasChecked);
+				}
+			}
+			//The required attribute applies to all form controls except controls with the type hidden,
+			//   image inputs, buttons (submit, move-up, etc), and select and output elements. For
+			//   disabled or readonly controls, the attribute has no effect.
+			else if(node.getAttributeNode('required')){
+				//if(node.options)
+				//	node.validity.valueMissing = (node.selectedIndex == -1);
+				//For other controls, any non-empty value shall satisfy the required condition,
+				//   including a simple whitespace character.
+				//else
+					node.validity.valueMissing = (node.value == '');
+			}
+			//if(node.options ? node.selectedIndex == -1 : node.value === '')
+			//	node.validity.valueMissing = true;
+			//
+		}
+		if(!node.validity.valueMissing && node.value){
+			//patternMismatch -- The value of the control with a pattern attribute doesn't match the pattern. 
+			//   If the control is empty, this flag must not be set.
+			//If the pattern attribute is present but empty, it doesn't match any value, and thus the
+			//   patternMismatch flag shall be set whenever the control's value isn't empty.
+			var patternAttr = node.getAttributeNode('pattern');
+			if(patternAttr){
+				//the pattern attribute must match the entire value, not just any subset (somewhat as if
+				//   it implied a ^(?: at the start of the pattern and a )$ at the end).
+				var rePattern = new RegExp("^(?:" + patternAttr.value + ")$");
+				//The pattern must be compiled with the global, ignoreCase, and multiline flags disabled
+				rePattern.global = false;
+				rePattern.ignoreCase = false;
+				rePattern.multiline = false;
+				//When the pattern is not a valid regular expression, it is ignored for the purposes of
+				//   validation, as if it wasn't specified.
+				if(rePattern)
+					node.validity.patternMismatch = !rePattern.test(node.value);
+			}
+			
+			//typeMismatch -- The data entered does not match the type of the control. For example, if the UA 
+			//   allows uninterpreted arbitrary text entry for month controls, and the user has entered SEP02, 
+			//   then this flag would be set. This code is also used when the selected file in a file upload 
+			//   control does not have an appropriate MIME type. If the control is empty, this flag must not be set.
+			if(isDateRelated || isTimeRelated)
+				node.validity.typeMismatch = ((node.wf2Value = $wf2.parseISO8601(node.value, type)) == null);
+			else {
+				switch(type){
+					case 'number':
+					case 'range':
+						node.validity.typeMismatch = !$wf2.numberRegExp.test(node.value);
+	//						if(!node.validity.typeMismatch && node.getAttribute("step") != 'any'){
+	//							if(node.step == undefined)
+	//								node.step = 1;
+	//							var val = Number(node.value);
+	//							node.validity.stepMismatch = (val == parseInt(val) && node.step != parseInt(node.step));
+	//						}
+						break;
+					case 'email':
+						//An e-mail address, following the format of the addr-spec  token defined in RFC 2822 section
+						//   3.4.1 [RFC2822], but excluding the CFWS  subtoken everywhere, and excluding the FWS
+						//   subtoken everywhere except in the quoted-string subtoken. UAs could, for example, offer
+						//   e-mail addresses from the user's address book. (See below for notes on IDN.)
+						//http://www.ietf.org/rfc/rfc2822						
+						node.validity.typeMismatch = !$wf2.emailRegExp.test(node.value);
+						break;
+					case 'url':
+						//An IRI, as defined by [RFC3987] (the IRI token, defined in RFC 3987 section 2.2). UAs could,
+						//   for example, offer the user URIs from his bookmarks. (See below for notes on IDN.) The value
+						//   is called url (as opposed to iri or uri) for consistency with CSS syntax and because it is
+						//   generally felt authors are more familiar with the term "URL" than the other, more technically
+						//   correct terms.
+						//http://www.ietf.org/rfc/rfc3987
+						node.validity.typeMismatch = !$wf2.urlRegExp.test(node.value);
+						break;
+				}
+			}
+			
+			if(!node.validity.patternMismatch && !node.validity.typeMismatch){
+				//To limit the range of values allowed by some of the above types, two new attributes are introduced, which
+				//   apply to the date-related, time-related, numeric, and file upload types: min and max
+				
+				//rangeUnderflow -- The numeric, date, or time value of a control with a min attribute is lower than 
+				//   the minimum, or a file upload control has fewer files selected than the minimum. If the control 
+				//   is empty or if the typeMismatch flag is set, this flag must not be set. 
+				//rangeOverflow -- The numeric, date, or time value of a control with a max attribute is higher than 
+				//   the maximum, or a file upload control has more files selected than the maximum. If the control 
+				//   is empty or if the typeMismatch flag is set, this flag must not be set. 
+				if(doCheckRange){
+					if(isNumberRelated){
+						//For numeric types (number  and range) the value must exactly match the number type (numberRegExp)
+						if(type == 'range'){
+							//For this type...max defaults to 100
+							node.max = (maxAttrNode && $wf2.numberRegExp.test(maxAttrNode.value)) ? Number(maxAttrNode.value) : 100;
+							//node.min is set at the beginning of this function so that the min value can be set as the default value
+						}
+						else {
+							if(minAttrNode && $wf2.numberRegExp.test(minAttrNode.value))
+								node.min = Number(minAttrNode.value);
+							if(maxAttrNode && $wf2.numberRegExp.test(maxAttrNode.value))
+								node.max = Number(maxAttrNode.value);
+						}
+						node.validity.rangeUnderflow = (node.min != undefined && Number(node.value) < node.min);
+						node.validity.rangeOverflow  = (node.max != undefined && Number(node.value) > node.max);
+					}
+					//For file types it must be a sequence of digits 0-9, treated as a base ten integer.
+					else if(type == 'file'){
+						if(minAttrNode && /^\d+$/.test(minAttrNode.value))
+							node.min = Number(minAttrNode.value);
+						//If absent, or if the minimum value is not in exactly the expected format, there
+						//   is no minimum restriction, except for the ... file types, where the default is zero.
+						else node.min = 0;
+						if(maxAttrNode && /^\d+$/.test(maxAttrNode.value))
+							node.max = Number(maxAttrNode.value);
+						//If absent, or if the maximum value is not in exactly the expected format, there is no
+						//  maximum restriction (beyond those intrinsic to the type), except for ... the file
+						//  type, where the default is 1.
+						else node.max = 1;
+						
+						//node.validity.rangeUnderflow = (node.min != undefined && Number(node.value) < node.min);
+						//node.validity.rangeOverflow  = (node.max != undefined && Number(node.value) > node.max);
+					}
+					//Date related
+					else {
+						//For date and time types it must match the relevant format mentioned for that type, all fields
+						//   having the right number of digits, with the right separating punctuation.
+						if(minAttrNode){
+							node.min = $wf2.parseISO8601(minAttrNode.value, type);
+							node.validity.rangeUnderflow = (node.min && node.wf2Value < node.min);
+						}
+						if(maxAttrNode){
+							node.max = $wf2.parseISO8601(maxAttrNode.value, type);
+							node.validity.rangeOverflow = (node.max && node.wf2Value > node.max);
+						}
+					}
+				}
+				//The step attribute controls the precision allowed for the date-related, time-related, and numeric types.
+				if(doCheckPrecision && !node.validity.rangeUnderflow && !node.validity.rangeOverflow){
+					//stepMismatch -- The value is not one of the values allowed by the step attribute, and the UA will 
+					//   not be rounding the value for submission. Empty values and values that caused the typeMismatch 
+					//   flag to be set must not cause this flag to be set.
+					
+					var stepAttrNode = $wf2.getOriginalAttrNode(node, 'step'); //node.getAttributeNode('step');
+					if(!stepAttrNode){
+						//The step attribute [for types datetime, datetime-local, and time] ... defaulting to 60 (one minute).
+						//For time controls, the value of the step attribute is in seconds, although it may be a fractional
+						//   number as well to allow fractional times.  The default value of the step
+						//   attribute for datetime, datetime-local and time controls is 60 (one minute).
+						//The step [for type date] attribute specifies the precision in days, defaulting to 1.
+						//The step [for type month] attribute specifies the precision in months, defaulting to 1.
+						//The step [for type week] attribute specifies the precision in weeks, defaulting to 1.
+						//For date controls, the value of the step attribute is in days, weeks, or months, for the date,
+						//   week, and month  types respectively. The format is a non-negative integer; one or more digits
+						//   0-9 interpreted as base ten. If the step is zero, it is interpreted as the default. The default
+						//   for the step  attribute for these control types is 1.
+						//The step [for types number and range] attribute specifies the precision, defaulting to 1.
+						node.step = isTimeRelated ? 60 : 1;
+					}
+					//The literal value 'any' may be used as the value of the step attribute. This keyword indicates that
+					//   any value may be used (within the bounds of other restrictions placed on the control).
+					else if(stepAttrNode.value == 'any')
+						node.step = 'any'; //isStepAny = true;
+					//The format of the step attribute is the number format described above, except that
+					//   the value must be greater than zero.
+					else if($wf2.numberRegExp.test(stepAttrNode.value) && stepAttrNode.value > 0)
+						node.step = Number(stepAttrNode.value);
+					else
+						node.step = isTimeRelated ? 60 : 1;
+					
+					if(node.step != 'any'){
+						node.wf2StepDatum = null;
+						if(minAttrNode)
+							node.wf2StepDatum = node.min;
+						else if(maxAttrNode)
+							node.wf2StepDatum = node.max;
+						else
+							node.wf2StepDatum = $wf2.zeroPoint[type] ? $wf2.zeroPoint[type] : 0;
+						
+						//The zero point for datetime  controls is 1970-01-01T00:00:00.0Z, for datetime-local is
+						//   1970-01-01T00:00:00.0, for date controls is 1970-01-01, for month controls is 1970-01,
+						//   for week controls is 1970-W01 (the week starting 1969-12-29 and containing 1970-01-01),
+						//   and for time controls is 00:00.
+						var _step = node.step;
+						if(type == 'month' && node.wf2StepDatum && node.wf2StepDatum.getUTCFullYear){
+							var month1 = node.wf2StepDatum.getUTCFullYear()*12 + node.wf2StepDatum.getUTCMonth();
+							var month2 = node.wf2Value.getUTCFullYear()*12 + node.wf2Value.getUTCMonth();
+							node.validity.stepMismatch = (month2 - month1)%_step != 0;
+						}
+						else {
+							switch(type){
+								case 'datetime':
+								case 'datetime-local':
+								case 'time':
+									_step = parseInt(_step * 1000); //for millisecond comparisons
+									break;
+								case 'date':
+									_step = parseInt(_step * 24*60*60*1000);
+									break;
+								case 'week':
+									_step = parseInt(_step * 7*24*60*60*1000);
+									break;
+							}
+
+							//For the control to be valid, the control's value must be an integral number of steps from the min value,
+							//   or, if there is no min attribute, the max value, or if there is neither attribute, from the zero point.
+							//allow decimal places to the 1,000th place
+							node.validity.stepMismatch = (Math.round((node.wf2Value - node.wf2StepDatum)*1000) % Math.round(_step*1000)) != 0;
+						}
+					}
+				}
+			}
+			
+			//[TEXTAREA] tooLong -- The value of a control with a maxlength attribute is longer than the attribute allows, 
+			//   and the value of the control doesn't exactly match the control's default value. 
+			//[The maxlength] attribute must not affect the initial value (the DOM defaultValue attribute). It must only
+			//   affect what the user may enter and whether a validity error is flagged during validation.
+			if(doMaxLengthCheck && node.maxLength >= 0 && node.value != node.defaultValue){
+				//A newline in a textarea's value must count as two code points for maxlength processing (because
+				//   newlines in textareas are submitted as U+000D U+000A). [[NOT IMPLEMENTED: This includes the
+				//   implied newlines that are added for submission when the wrap attribute has the value hard.]]
+				//var matches = node.value.match(/((?<!\x0D|^)\x0A|\x0D(?!^\x0A|$))/g); //no negative lookbehind
+				var shortNewlines = 0;
+				var v = node.value;
+				node.wf2ValueLength = v.length;
+				for(var i = 1; i < v.length; i++){
+					if(v[i] === "\x0A" && v[i-1] !== "\x0D" || v[i] == "\x0D" && (v[i+1] && v[i+1] !== "\x0A"))
+						node.wf2ValueLength++;
+				}
+				
+				//The tooLong flag is used when this attribute is specified on a ... textarea control and the control
+				//   has more than the specified number of code points and the value doesn't match the control's default value.
+				node.validity.tooLong = node.wf2ValueLength > node.maxLength;
+			}
+		}
+
+		//customError -- The control was marked invalid from script. See the definition of the setCustomValiditiy() method.
+		
+		node.validity.valid = !$wf2.hasInvalidState(node.validity);
+		
+		//This is now done onmousedown or onkeydown, just as Opera does
+		//if(node.validity.valid){
+		//	node.className = node.className.replace(/\s*\binvalid\b\s*/g, " "); //substitute for :invalid pseudo class
+		//	//if(node.wf2_errorMsg){
+		//	//	node.wf2_errorMsg.parentNode.removeChild(node.wf2_errorMsg);
+		//	//	node.wf2_errorMsg = null;
+		//	//}
+		//	var errMsg = document.getElementById((node.id || node.name) + '_wf2_errorMsg');
+		//	if(errMsg)
+		//		errMsg.parentNode.removeChild(errMsg);
+		//}
+	},
+
+	applyValidityInterface : function(node){
+		
+		/* Webkit browsers need this */
+		if ($wf2.hasBadImplementation) {
+			
+			if (node.type == 'submit' || node.type == 'button') {
+				
+				node.formNoValidate=true;
+				
+			}
+		}
+	
+		/* ZOLTAN made a change here to ensure Google's unfinished native implementation is not used. */
+		else if((node.validity && node.validity.typeMismatch !== undefined)) {//MSIE needs the second test for some reason
+			//	console.log('bad implementation!! ' + node.id);
+			
+			return node;
+		}
+		node.validationMessage = "";
+		
+		//ValidityState interface
+		node.validity = $wf2.createValidityState();
+		node.willValidate = true;
+		
+		var nodeName = node.nodeName.toLowerCase();
+		if(nodeName == 'button' || nodeName == 'fieldset'){
+			node.setCustomValidity = function(error){
+				throw $wf2.DOMException(9); //NOT_SUPPORTED_ERR
+			};
+			node.checkValidity = function(){
+				return true;
+			};
+			return node;
+		}
+		//node._updateValidityState = $wf2._updateValidityState;
+		
+		if (!node.setCustomValidity) {
+			node.setCustomValidity = $wf2.controlSetCustomValidity;
+		}
+		
+		
+		node.checkValidity = $wf2.controlCheckValidity;
+		
+		
+		//var type = (node.type ? node.type.toLowerCase() : (nodeName == 'input' ? 'text' : ''));
+		var type = (node.getAttribute('type') ? node.getAttribute('type').toLowerCase() : node.type);
+		
+		if(/(hidden|button|reset|add|remove|move-up|move-down)/.test(type) || !node.name || node.disabled)
+			node.willValidate = false;
+		else if(window.RepetitionElement) {
+			var parent = node;
+			while(parent = parent.parentNode){
+				if(parent.repetitionType == RepetitionElement.REPETITION_TEMPLATE){
+					node.willValidate = false;
+					break;
+				}
+			}
+		}
+		
+		//var handler = function(event){
+		//	return (event.currentTarget || event.srcElement)._updateValidityState();
+		//};
+		
+		////attempt to check validity live
+		//if(document.addEventListener){
+		//	node.addEventListener('change', handler, false);
+		//	node.addEventListener('blur', handler, false);
+		//	node.addEventListener('keyup', handler, false);
+		//}
+		//else if(window.attachEvent){
+		//	node.attachEvent('onchange', handler);
+		//	node.attachEvent('onblur', handler);
+		//	node.attachEvent('onkeyup', handler);
+		//}
+		//else {
+		//
+		//}
+		
+		return node;
+	},
+
+	onsubmitValidityHandler : function(event){
+		var frm = event.currentTarget || event.srcElement;
+		var r;
+		
+		// call routines other libraries have set to be run before
+		// validation.
+		for (var i=0; i<$wf2.callBeforeValidation.length; i++) {
+			$wf2.callBeforeValidation[i](event);
+		}
+		
+		/* ZOLTAN */
+		if(!frm.checkValidity()){
+			if(event.preventDefault)
+				event.preventDefault();
+			event.returnValue = false;
+			r = false;
+		} else {
+			event.returnValue = true;
+			r = true;
+		}
+		
+		// call routines other libraries have set to be run before
+		// validation.
+		for (var i=0; i<$wf2.callAfterValidation.length; i++) {
+			$wf2.callAfterValidation[i](event, r);
+		}
+		
+		
+		
+		return r;
+	},
+
+	controlSetCustomValidity : function(error){
+		if(error){
+			this.validationMessage = String(error);
+			this.validity.customError = true;
+		}
+		else {
+			this.validationMessage = "";
+			this.validity.customError = false;
+		}
+		this.validity.valid = !$wf2.hasInvalidState(this.validity);
+	},
+	hasInvalidState : function(validity){
+		return validity.typeMismatch 
+			|| validity.rangeUnderflow 
+			|| validity.rangeOverflow
+			|| validity.stepMismatch
+			|| validity.tooLong 
+			|| validity.patternMismatch 
+			|| validity.valueMissing 
+			|| validity.customError;
+	},
+	createValidityState : function(){
+		return {
+			typeMismatch    : false,
+			rangeUnderflow  : false,
+			rangeOverflow   : false,
+			stepMismatch    : false,
+			tooLong         : false,
+			patternMismatch : false,
+			valueMissing    : false,
+			customError     : false,
+			valid           : true
+		};
+	},
+
+	//## Default action functions for invalid events ##################################################
+
+	invalidIndicators : [],
+	indicatorTimeoutId : null,
+	indicatorIntervalId : null,
+	
+	stepUnits : {
+		'datetime' : 'second',
+		'datetime-local': 'second',
+		'time': 'second',
+		'date': 'day',
+		'week': 'week',
+		'month': 'month'
+	},
+
+	invalidMessages : {
+		valueMissing   : 'A value must be supplied or selected.',
+		typeMismatch   : 'The value is invalid for %s type.',
+		rangeUnderflow : 'The value must be equal to or greater than %s.',
+		rangeOverflow  : 'The value must be equal to or less than %s.',
+		stepMismatch   : 'The value has a step mismatch; it must be a certain number multiples of %s from %s.',
+		tooLong        : 'The value is too long. The field may have a maximum of %s characters but you supplied %s. Note that each line-break counts as two characters.',
+		patternMismatch: 'The value is not in the format required.'
+	},
+	
+	valueToWF2Type : function(value, type){
+		switch(String(type).toLowerCase()){
+			case 'datetime':
+			case 'datetime-local':
+			case 'date':
+			case 'month':
+			case 'week':
+			case 'time':
+				return $wf2.dateToISO8601(value, type);
+			default:
+				return value;
+		}
+	},
+
+	addInvalidIndicator : function(target){
+		//show contextual help message
+		var msg = document.createElement('div');
+		msg.className = 'wf2_errorMsg';
+		//msg.title = "Close";
+		msg.id = (target.id || target.name) + '_wf2_errorMsg'; //QUESTION: does this work for MSIE?
+		msg.onmousedown = function(){
+			this.parentNode.removeChild(this);
+		};
+		//var type = String(target.getAttribute('type')).toLowerCase();
+		//var type = (target.type ? target.type.toLowerCase() : (target.nodeName.toLowerCase() == 'input' ? 'text' : ''));
+		var type = (target.getAttribute('type') ? target.getAttribute('type').toLowerCase() : target.type);
+		var isDateTimeRelated = (type == 'datetime' || type == 'datetime-local' || type == 'time' || type == 'date' || type == 'month' || type == 'week');
+
+		var ol = document.createElement('ol');
+		if(target.validity.valueMissing)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.valueMissing));
+		if(target.validity.typeMismatch)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.typeMismatch.replace(/%s/, type)));
+		if(target.validity.rangeUnderflow)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.rangeUnderflow.replace(/%s/, $wf2.valueToWF2Type(target.min, type))));
+		if(target.validity.rangeOverflow)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.rangeOverflow.replace(/%s/, $wf2.valueToWF2Type(target.max, type))));
+		if(target.validity.stepMismatch)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.stepMismatch.replace(/%s/, target.step + ($wf2.stepUnits[type] ? ' ' + $wf2.stepUnits[type] + '(s)' : '')).replace(/%s/, $wf2.valueToWF2Type(target.wf2StepDatum, type))));
+		if(target.validity.tooLong)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.tooLong.replace(/%s/, target.maxLength).replace(/%s/, target.wf2ValueLength ? target.wf2ValueLength : target.value.length)));
+		if(target.validity.patternMismatch)
+			ol.appendChild($wf2.createLI($wf2.invalidMessages.patternMismatch.replace(/%s/, target.title ? target.title : ' "' + target.getAttribute('pattern') + '"')));
+		if(target.validity.customError)
+			ol.appendChild($wf2.createLI(target.validationMessage));
+		
+		if(ol.childNodes.length == 1)
+			ol.className = 'single';
+		
+		msg.appendChild(ol);
+		////remove existing error message
+		//if(document.getElementById(msg.id))
+		//	document.documentElement.removeChild(document.getElementById(msg.id));
+		//target.parentNode.insertBefore(msg, target); //Inserting error message next to element in question causes problems when the element has a positioned containing block
+		var parent = document.body ? document.body : document.documentElement;
+		if($wf2.invalidIndicators.length) //insert before other error messages so that it appears on top
+			parent.insertBefore(msg, $wf2.invalidIndicators[$wf2.invalidIndicators.length-1].errorMsg);
+		else //insert at the end of the document
+			parent.insertBefore(msg, null); 
+		//target.wf2_errorMsg = msg;
+		//if(target.style.display == 'none' || !target.offsetParent){
+		//	var prevEl = target.previousSibling;
+		//	var nextEl = target.nextSibling;
+		//	var prevCount = 0, nextCount = 0;
+		//	while(prevEl && (prevEl.nodeType != 1 || (prevEl.style.display == 'none' || !prevEl.offsetParent)) && ++prevCount)
+		//		prevEl = prevEl.previousSibling;
+		//	while(nextEl && (nextEl.nodeType != 1 || (nextEl.style.display == 'none' || !nextEl.offsetParent)) && ++nextCount)
+		//		nextEl = nextEl.nextSibling;
+		//	
+		//	if(prevEl && prevCount > nextCount)
+		//	
+		//}
+		var el = target;
+		while(el && (el.nodeType != 1 || (el.style.display == 'none' || el.style.visibility == 'hidden' || !el.offsetParent)))
+			el = el.parentNode;
+		
+		var top = left = 0;
+		var cur = el;
+		if(cur && cur.offsetParent){
+			left = cur.offsetLeft;
+			top = cur.offsetTop;
+			while(cur = cur.offsetParent){
+				left += cur.offsetLeft;
+				top += cur.offsetTop;
+			}
+			top += el.offsetHeight;
+		}
+		msg.style.top = top + 'px';
+		msg.style.left = left + 'px';
+		
+		$wf2.invalidIndicators.push({
+			target : target,
+			errorMsg : msg
+		});
+		//if(target.form && target.form[target.name]){
+		//	target.form[target.name].wf2HasInvalidIndicator = true;
+		//	console.info('set')
+		//}
+		if(!target.className.match(/\bwf2_invalid\b/))
+			target.className += " wf2_invalid";
+			
+		if($wf2.indicatorIntervalId == null){
+			//var i = $wf2.invalidIndicators.length - 1;
+			$wf2.indicatorIntervalId = setInterval(function(){
+				var invalidIndicator;
+				for(var i = 0; invalidIndicator = $wf2.invalidIndicators[i]; i++){
+					if(!invalidIndicator.target.className.match(/\bwf2_invalid\b/)){
+						invalidIndicator.target.className += " wf2_invalid";
+					}
+					else {
+						invalidIndicator.target.className = invalidIndicator.target.className.replace(/\s?wf2_invalid/, "");
+					}
+				}
+				
+			}, 500);
+			// call routines other libraries have set to be run before
+			// validation.
+			setTimeout(function() {
+				for (var i=0; i<$wf2.callAfterValidation.length; i++) {
+					$wf2.callAfterValidation[i](null, false);
+				}
+			}, 1);
+			$wf2.indicatorTimeoutId = setTimeout($wf2.clearInvalidIndicators, 4000);
+		}
+		
+	},
+
+	clearInvalidIndicators : function(){
+		clearTimeout($wf2.indicatorTimeoutId);
+		$wf2.indicatorTimeoutId = null;
+		clearInterval($wf2.indicatorIntervalId);
+		$wf2.indicatorIntervalId = null;
+
+		var invalidIndicator;
+		while(invalidIndicator = $wf2.invalidIndicators[0]){
+			if(invalidIndicator.errorMsg && invalidIndicator.errorMsg.parentNode)
+				invalidIndicator.errorMsg.parentNode.removeChild(invalidIndicator.errorMsg);
+			//clearInterval(insts[0].intervalId);
+			var target = invalidIndicator.target;
+			//if(target.form && target.form[target.name])
+			//	target.form[target.name].wf2HasInvalidIndicator = false;
+			target.className = target.className.replace(/\s?wf2_invalid/, ""); //([^\b]\s)?
+			$wf2.invalidIndicators.shift();
+		}
+		
+	},
+
+	/*##############################################################################################
+	 # Other helper functions (not made into methods)
+	 ##############################################################################################*/
+
+	cloneNode_customAttrs : { //FOR MSIE BUG: it cannot perceive the attributes that were actually specified
+		'type':1,'template':1,'repeat':1,'repeat-template':1,'repeat-min':1,
+		'repeat-max':1,'repeat-start':1,'value':1,'class':1,'required':1,
+		'pattern':1,'form':1,'autocomplete':1,'autofocus':1,'inputmode':1,
+		'max':1,'min':1,'step':1,
+		onmoved:1,onadded:1,onremoved:1, 
+		onadd:1,onremove:1,onmove:1 //deprecated
+	},
+	cloneNode_skippedAttrs : {
+		'name':1,  //due to MSIE bug, set via $wf2.createElement
+		'class':1, //due to MSIE bug, set below (see http://www.alistapart.com/articles/jslogging)
+		'for':1,   //due to preceived MSIE bug, set below
+		'style':1, //inline styles require special handling
+		'checked':1, //set by $wf2.createElement due to MSIE bug creating INPUT@type=radio
+		
+		//for MSIE, properties (or methods) == attributes
+		addRepetitionBlock:1,addRepetitionBlockByIndex:1,moveRepetitionBlock:1,
+		removeRepetitionBlock:1, repetitionBlocks:1,
+		setCustomValidity:1,checkValidity:1,validity:1,validationMessage:1,willValidate:1,
+		wf2StepDatum:1,wf2Value:1,wf2Initialized:1,wf2ValueLength:1
+	},
+	cloneNode_rtEventHandlerAttrs : {
+		onmoved:1,onadded:1,onremoved:1, //don't copy Repetition old model event attributes not methods
+		onadd:1,onremove:1,onmove:1 //deprecated
+		//QUESTION: is this right???
+	},
+
+	//The following cloneNode algorithm was designed to handle the attribute processing that the repetition
+	//  model specifies. Gecko starts to have irratic behavior with a cloned input's value attribute and value
+	//  property when using DOM cloneNode; furthermore, various MSIE bugs prevent its use of DOM cloneNode
+	cloneNode : function (node, processAttr, rtNestedDepth){
+		if(!rtNestedDepth)
+			rtNestedDepth = 0;
+		var clone, i, attr;
+		switch(node.nodeType){
+			case 1: /*Node.ELEMENT_NODE*/
+				//if(node.nodeType == 1 /*Node.ELEMENT_NODE*/){
+				var isTemplate = node.getAttribute('repeat') == 'template';
+				if(isTemplate)
+					rtNestedDepth++;
+				//BROWSER BUGS: MSIE does not allow the setting of the node.name, except when creating the new node
+				//              MSIE neither permits the standard DOM creation of radio buttons
+				var attrs = [];
+				if(node.name)
+					attrs.name = processAttr ? processAttr(node.name) : node.name;
+				if(node.type == 'radio')
+					attrs.type = node.type;
+				if(node.checked)
+					attrs.checked = 'checked';
+				clone = $wf2.createElement(node.nodeName, attrs);
+				//clone = node.name  ? 
+				//		$wf2.createElement(node.nodeName, attrs) 
+				//	  : document.createElement(node.nodeName);
+						
+				for(i = 0; attr = node.attributes[i]; i++){
+					
+					//MSIE ISSUE: Custom attributes specified do not have .specified property set to true?
+					//ISSUE: VALUE IS REPEATED IN MSIE WHEN VALUE ATTRIBUTE SET?
+					//if(attr.specified || node.getAttribute(attr.nodeName)) //$wf2.cloneNode_customAttrs[attr.nodeName] || 
+					//	if(window.console && console.info) console.info(node.nodeName + "@" + attr.nodeName + " -- " + attr.specified + " <font color=red>" + node.getAttribute(attr.nodeName) + "</font>(" + typeof node.getAttribute(attr.nodeName) + ")<br>");
+	
+					//MSIE needs $wf2.cloneNode_customAttrs[attr.name] test since attr.specified does not work with custom attributes
+					//If the node is a template, the repetition event handlers should only be copied
+					//   if the template is nested and is being cloned by a parent repetition template.
+					if((attr.specified || $wf2.cloneNode_customAttrs[attr.name])
+						  && !$wf2.cloneNode_skippedAttrs[attr.name] && (
+								(!isTemplate || (rtNestedDepth > 1 || !$wf2.cloneNode_rtEventHandlerAttrs[attr.name])) // && 
+							))
+					{
+						
+						//MSIE BUG: when button[type=add|remove|move-up|move-down], then (attr.nodeValue and attr.value == 'button') but node.getAttribute(attr.nodeName) == 'add|remove|move-up|move-down' (as desired)
+						
+						//clone and process an event handler property (attribute);
+						//   keep event handler attributes as plain text if nested repetition template
+						if(rtNestedDepth < 2 && (attr.name.indexOf('on') === 0) && (typeof node[attr.name] == 'function')){
+							var funcBody = processAttr(node[attr.name].toString().match(/{((?:.|\n)+)}/)[1]);
+							funcBody = processAttr(funcBody);
+							clone[attr.name] = new Function('event', funcBody);
+						}
+						//clone and process other attributes
+						else {
+							var attrValue = node.getAttribute(attr.name);
+							attrValue = (processAttr ? processAttr(attrValue) : attrValue);
+							clone.setAttribute(attr.name, attrValue);
+						}
+						//console.log(StringHelpers.sprintf("AFTER attr: %s val: %s (%s)", attr.name, attr.value, processAttr(attrValue)))
+					}
+				}
+				//MSIE BUG: setAttribute('class') creates duplicate value attribute in MSIE; 
+				//QUESTION: will setting className on this clonedNode still cause this error later on for users? will addClassName croak? Should it be improved?
+				//see: http://www.alistapart.com/articles/jslogging
+				if(node.className){
+					var _className = (processAttr ? processAttr(node.className) : node.className);
+					if(clone.getAttributeNode('class')){
+						for(i = 0; i < clone.attributes.length; i++) {
+							if(clone.attributes[i].name == 'class')
+								clone.attributes[i].value = _className;
+						}
+					}
+					else clone.setAttribute('class', _className);
+				}
+	
+				//Restore the template's elements to the originally coded disabled state (indicated by 'disabled' class name)
+				// All elements within the repetition template are disabled to prevent them from being successful.
+				if(!/\bdisabled\b/.test(node.className))
+					clone.disabled = false;
+				
+				//Process the inline style
+				if(node.style && node.style.cssText){
+					//clone.setAttribute('style', processAttr(node.style.cssText));
+					clone.style.cssText = (processAttr ? processAttr(node.style.cssText) : node.style.cssText);
+				}
+				
+				//label's 'for' attribute, set here due to MSIE bug
+				if(node.nodeName && node.nodeName.toLowerCase() == 'label' && node.htmlFor)
+					clone.htmlFor = (processAttr ? processAttr(node.htmlFor) : node.htmlFor);
+				
+
+				if(clone.nodeName.toLowerCase() == 'option'){ //MSIE clone element bug requires this
+					clone.selected = node.selected;
+					clone.defaultSelected = node.defaultSelected;
+				}
+				
+				for(i = 0; i < node.childNodes.length; i++){
+					clone.appendChild($wf2.cloneNode(node.childNodes[i], processAttr, rtNestedDepth));
+				}
+				break;
+			//MSIE BUG: The following three cases are for MSIE because when cloning nodes from XML
+			//          files loaded via SELECT@data attribute, MSIE fails when performing appendChild.
+			case 3: /*Node.TEXT_NODE*/
+			case 4: /*Node.CDATA_SECTION_NODE*/
+				clone = document.createTextNode(node.data);
+				break;
+			case 8: /*Node.COMMENT_NODE*/
+				clone = document.createComment(node.data);
+				break;
+			default:
+				clone = node.cloneNode(true)
+		}
+		//else clone = node.cloneNode(true);
+		return clone;
+	},
+	
+	getFormElements : function(){
+		var elements = [];
+		var allElements = $wf2.getElementsByTagNames.apply(this, ['input','output','select','textarea','button']); //fieldset
+		for(var i = 0; i < allElements.length; i++){
+			var node = allElements[i].parentNode;
+			while(node && node.nodeType == 1 && node.getAttribute('repeat') != 'template')
+				node = node.parentNode;
+			if(!node || node.nodeType != 1)
+				elements.push(allElements[i]);
+		}
+		return elements;
+	},
+	
+	loadDataURI : function(el){
+		var uri = el.data || el.getAttribute('data');
+		if(!uri)
+			return null;
+		var doc = null, matches;
+		try {
+			if(matches = uri.match(/^data:[^,]*xml[^,]*,((?:.|\n)+)/)){
+				var xml = decodeURI(matches[1].replace(/%3D/ig, '=').replace(/%3A/ig, ':').replace(/%2F/ig, '/'));
+				if(window.DOMParser){
+					var parser = new DOMParser();
+					doc = parser.parseFromString(xml, 'text/xml');
+				}
+				else if(window.ActiveXObject){
+					doc = new ActiveXObject("Microsoft.XMLDOM");
+					doc.async = 'false';
+					doc.loadXML(xml);
+				}
+			}
+			else {
+				$wf2.xhr.open('GET', uri, false);
+				$wf2.xhr.send(null); //Note: if in Firefox and null not provided, and if Firebug is disabled, an error occurs
+				doc = $wf2.xhr.responseXML;
+			}
+		}
+		catch(e){
+			return null;
+		}
+		return doc;
+	},
+	
+	getAttributeByName: function (obj, attrName) {
+		var i;
+		
+		var attributes = obj.attributes;
+		for (i=0; i<attributes.length; i++) {
+			var attr = attributes[i]
+			if (attr.nodeName == attrName && attr.specified) {
+			  	return attr;
+			}
+		}
+		return null;
+	},
+	
+	getAttributeValue: function (obj, attrName) {
+		var attr = $wf2.getAttributeByName(obj, attrName);
+		
+		if (attr != null) {
+			return attr.nodeValue;
+		} else {
+			return null;
+		}
+	},	
+	
+	setAttributeValue: function (obj, attrName, attrValue) {
+		var attr = $wf2.getAttributeByName(obj, attrName);
+		
+		if (attr != null) {
+			attr.nodeValue = attrValue;
+		} else {
+			return;
+		}
+	},
+	
+	
+	getDatasetItem: function (obj, name) {
+		var r = $wf2.getAttributeValue(obj, 'data-' + name);
+		
+		if (!r) {
+			r = $wf2.getAttributeValue(obj, 'data-' + name.toLowerCase())
+		} 
+		
+		if (!r) {
+			r = obj['data-' + name.toLowerCase()]
+		}
+		return r;
+	},
+	
+	setDatasetItem: function (obj, name, value) {
+		var attrName = 'data-' + name.toLowerCase();
+		
+		var val = $wf2.setAttributeValue(obj, attrName, value);
+		
+		if ($wf2.getAttributeValue(obj, attrName) == null) {
+			obj[attrName] = value;
+			
+		}
+	},
+
+	getElementsByTagNames : function(/* ... */){
+		var els,i,results = [];
+		if(document.evaluate){
+			var _tagNames = [];
+			for(i = 0; i < arguments.length; i++)
+				_tagNames.push(".//" + arguments[i]);
+			els = document.evaluate(_tagNames.join('|'), this, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null); 
+			for(i = 0; i < els.snapshotLength; i++)
+				results.push(els.snapshotItem(i));
+		}
+		else {
+			for(i = 0; i < arguments.length; i++){
+				els = this.getElementsByTagName(arguments[i]);
+				for(var j = 0; j < els.length; j++){
+					results.push(els[j]);
+				}
+			}
+			if($wf2.sortNodes)
+				results.sort($wf2.sortNodes);
+		}
+		return results;
+	},
+	
+	getElementsByTagNamesAndAttribute : function(elNames, attrName, attrValue, isNotEqual){
+		var els,el,i,j,results = [];
+		
+		//QUESTION!!! Can we exclude all nodes that are not decendents of the repetition template?
+		if(document.evaluate){
+			var attrExpr = '';
+			if(attrName)
+				attrExpr = '[@' + attrName + (attrValue ? (isNotEqual ? '!=' : '=') + '"' + attrValue + '"' : "") + "]";
+			var xPaths = [];
+			for(i = 0; i < elNames.length; i++)
+				xPaths.push('.//' + elNames[i] + attrExpr);
+			els = document.evaluate(xPaths.join('|'), this, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null); 
+			for(i = 0; i < els.snapshotLength; i++)
+				results.push(els.snapshotItem(i));
+		}
+		else {
+			for(i = 0; i < elNames.length; i++){
+				els = this.getElementsByTagName(elNames[i]);
+				for(j = 0; el = els[j]; j++){
+					var thisAttrNode = el.getAttributeNode(attrName);
+					var thisAttrValue = el.getAttribute(attrName); //MSIE needs getAttribute here for custom button types to be read
+					if(!attrName || (thisAttrNode && (attrValue === undefined || (isNotEqual ? thisAttrValue != attrValue : thisAttrValue == attrValue) ))){
+						results.push(el);
+					}
+				}
+			}
+			if($wf2.sortNodes)
+				results.sort($wf2.sortNodes);
+		}
+		return results;
+	},
+	
+	arrayHasItem : function(arr, item){
+		for(var i = 0; i < arr.length; i++){
+			if(arr[i] == item)
+				return true;
+		}
+		return false;
+	},
+	
+	//Note: this function has been deemed harmful
+	getElementStyle : function(el, property) { //adapted from Danny Goodman <http://www.oreillynet.com/pub/a/javascript/excerpt/JSDHTMLCkbk_chap5/index5.html>
+		if(el.currentStyle)
+			return el.currentStyle[property];
+		else if(window.getComputedStyle)
+			return getComputedStyle(el, '').getPropertyValue(property);
+		else if(el.style)
+			return el.style[property];
+		else return '';
+	},
+
+	//createElement code based on Anthony Lieuallen's work <http://www.easy-reader.net/archives/2005/09/02/death-to-bad-dom-implementations/#comment-444>
+	//   The following function enables MSIE to create elements with the name attribute set, per MSDN:
+	//   The NAME attribute cannot be set at run time on elements dynamically created with the 
+	//   createElement method. To create an element with a name attribute, include the attribute 
+	//   and value when using the createElement method.
+	//   The same goes for creating radio buttons and creating defaultly checked checkboxes,
+	//   per <http://channel9.msdn.com/wiki/default.aspx/Channel9.InternetExplorerProgrammingBugs>
+	createElement : (function(){
+		try {
+			var el = document.createElement('<div name="foo">'); //MSIE memory leak according to Drip
+			if(el.tagName.toLowerCase() != 'div' || el.name != 'foo')
+				throw 'create element error';
+				
+			return function(tag, attrs){
+				var html = '<' + tag;
+				for(var name in attrs)
+					html += ' ' + name + '="' + attrs[name] + '"';
+				html += '>';
+				if(tag.toLowerCase() != 'input')
+					html += '</'+tag+'>';
+				return document.createElement(html); //'<'+tag+' name="'+name+'"></'+tag+'>'
+			};
+		}
+		catch(err){
+			return function(tag, attrs){
+				var el = document.createElement(tag);
+				for(var name in attrs)
+					el.setAttribute(name, attrs[name]);
+				return el;
+			};
+		}
+	})(),
+
+	//Sort elements in document order (from ppk)
+	sortNodes : (function(){
+		var n = document.documentElement.firstChild;
+		if(n.sourceIndex){
+			return function (a,b){
+				return a.sourceIndex - b.sourceIndex;
+			};
+		}
+		else if(n.compareDocumentPosition){
+			return function (a,b){
+				return 3 - (a.compareDocumentPosition(b) & 6);
+			};
+		}
+	})(),
+
+	//Shortcut to create new list items; used by default invalid event handler in listing the errors
+	createLI : function(text){
+		var li = document.createElement('li');
+		li.appendChild(document.createTextNode(text));
+		return li;
+	},
+	
+	//Initially inspired by Paul Sowden <http://delete.me.uk/2005/03/iso8601.html>
+	ISO8601RegExp : /^(?:(\d\d\d\d)-(W(0[1-9]|[1-4]\d|5[0-2])|(0\d|1[0-2])(-(0\d|[1-2]\d|3[0-1])(T(0\d|1\d|2[0-4]):([0-5]\d)(:([0-5]\d)(\.(\d+))?)?(Z)?)?)?)|(0\d|1\d|2[0-4]):([0-5]\d)(:([0-5]\d)(\.(\d+))?)?)$/,
+	parseISO8601 : function (str, type) {
+		var d = $wf2.validateDateTimeType(str, type);
+		if(!d)
+			return null;
+		
+		var date = new Date(0);
+		var _timePos = 8;
+		
+		if(d[15]){ //Time
+			if(type && type != 'time') // a time date
+				return null;
+			_timePos = 15;
+		}
+		else {
+			date.setUTCFullYear(d[1]);
+			
+			//ISO8601 Week
+			if(d[3]){
+				if(type && type != 'week')
+					return null;
+				date.setUTCDate(date.getUTCDate() + ((8 - date.getUTCDay()) % 7) + (d[3]-1)*7); //set week day and week
+				return date;
+			}
+			//Other date-related types
+			else {
+				date.setUTCMonth(d[4] - 1); //Month must be supplied for WF2
+				if(d[6])
+					date.setUTCDate(d[6]);
+			}
+		}
+
+		//Set time-related fields
+		if(d[_timePos+0]) date.setUTCHours(d[_timePos+0]);
+		if(d[_timePos+1]) date.setUTCMinutes(d[_timePos+1]);
+		if(d[_timePos+2]) date.setUTCSeconds(d[_timePos+3]);
+		if(d[_timePos+4]) date.setUTCMilliseconds(Math.round(Number(d[_timePos+4]) * 1000));
+		
+		//Set to local time if date given, hours present and no 'Z' provided
+		if(d[4] && d[_timePos+0] && !d[_timePos+6])
+			date.setUTCMinutes(date.getUTCMinutes()+date.getTimezoneOffset());
+
+		return date;
+	},
+
+	validateDateTimeType : function(value, type){ //returns RegExp matches
+		var isValid = false;
+		var d = $wf2.ISO8601RegExp.exec(value); //var d = string.match(new RegExp(regexp));
+		if(!d || !type)
+			return d;
+		type = type.toLowerCase();
+		
+		if(type == 'week') // a week date
+			isValid = (d[2].toString().indexOf('W') === 0); //valid if W present
+		else if(type == 'time') // a time date
+			isValid = !!d[15];
+		else if(type == 'month')
+			isValid = !d[5];
+		else { //a date related value
+			//Verify that the number of days in the month are valid
+			if(d[6]){
+				var date = new Date(d[1], d[4]-1, d[6]);
+				if(date.getMonth() != d[4]-1)
+					isValid = false;
+				else switch(type){
+					case 'date':
+						isValid = (d[4] && !d[7]); //valid if day of month supplied and time field not present
+						break;
+					case 'datetime':
+						isValid = !!d[14]; //valid if Z present
+						break;
+					case 'datetime-local':
+						isValid = (d[7] && !d[14]); //valid if time present and Z not provided
+						break;
+				}
+			}
+		}
+		return isValid ? d : null;
+	},
+	
+	zeroPad : function(num, pad){
+		if(!pad)
+			pad = 2;
+		var str = num.toString();
+		while(str.length < pad)
+			str = '0' + str;
+		return str;
+	},
+	
+	dateToISO8601 : function(date, type){
+		type = String(type).toLowerCase();
+		var ms = '';
+		if(date.getUTCMilliseconds())
+			ms = '.' + $wf2.zeroPad(date.getUTCMilliseconds(), 3).replace(/0+$/,'');
+		switch(type){
+			case 'date':
+				return date.getUTCFullYear() + '-' + $wf2.zeroPad(date.getUTCMonth()+1) + '-' + $wf2.zeroPad(date.getUTCDate());
+			case 'datetime-local':
+				return date.getFullYear() + '-' + $wf2.zeroPad(date.getMonth()+1) + '-' + $wf2.zeroPad(date.getDate()) + 
+				       'T' + $wf2.zeroPad(date.getHours()) + ':' + $wf2.zeroPad(date.getMinutes()) + ':' + $wf2.zeroPad(date.getMinutes()) + ms + 'Z';
+			case 'month':
+				return date.getUTCFullYear() + '-' + $wf2.zeroPad(date.getUTCMonth()+1);
+			case 'week':
+				var week1 = $wf2.parseISO8601(date.getUTCFullYear() + '-W01');
+				return date.getUTCFullYear() + '-W' + $wf2.zeroPad(((date.valueOf() - week1.valueOf()) / (7*24*60*60*1000)) + 1);
+			case 'time':
+				return $wf2.zeroPad(date.getUTCHours()) + ':' + $wf2.zeroPad(date.getUTCMinutes()) + ':' + $wf2.zeroPad(date.getUTCMinutes()) + ms;
+			case 'datetime':
+			default:
+				return date.getUTCFullYear() + '-' + $wf2.zeroPad(date.getUTCMonth()+1) + '-' + $wf2.zeroPad(date.getUTCDate()) + 
+				       'T' + $wf2.zeroPad(date.getUTCHours()) + ':' + $wf2.zeroPad(date.getUTCMinutes()) + ':' + $wf2.zeroPad(date.getUTCMinutes()) + ms + 'Z';
+		}
+	},
+	
+	/* 
+	 * 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.
+	 * 
+	 */
+	fireEvent: function (element, event, options){
+		
+		if(!element) {
+			return;
+		}
+		
+	    if (document.createEventObject){
+			return element.fireEvent('on' + event, $wf2.globalEvent);
+	    } else{
+	        // dispatch for firefox + others
+	        $wf2.globalEvent.initEvent(event, true, true); // event type,bubbling,cancelable
+	        return !element.dispatchEvent($wf2.globalEvent);
+	    }
+	},
+	
+	//Emulation of DOMException
+	DOMException : function(code){
+		var message = 'DOMException: ';
+		switch(code){
+			case  1: message += 'INDEX_SIZE_ERR'; break;
+			case  9: message += 'NOT_SUPPORTED_ERR'; break;
+			case 11: message += 'INVALID_STATE_ERR'; break;
+			case 12: message += 'SYNTAX_ERR'; break;
+			case 13: message += 'INVALID_MODIFICATION_ERR'; break;
+		}
+	
+		var err = new Error(message);
+		err.code = code;
+		err.name = 'DOMException';
+	
+		//Provide error codes and messages for the exception types that are raised by WF2
+		err.INDEX_SIZE_ERR = 1;
+		err.NOT_SUPPORTED_ERR = 9;
+		err.INVALID_STATE_ERR = 11;
+		err.SYNTAX_ERR = 12;
+		err.INVALID_MODIFICATION_ERR = 13;
+	
+		//with($wf2.DOMException.prototype){
+		//	INDEX_SIZE_ERR = 1;
+		//	DOMSTRING_SIZE_ERR = 2;
+		//	HIERARCHY_REQUEST_ERR = 3;
+		//	WRONG_DOCUMENT_ERR = 4;
+		//	INVALID_CHARACTER_ERR = 5;
+		//	NO_DATA_ALLOWED_ERR = 6;
+		//	NO_MODIFICATION_ALLOWED_ERR = 7;
+		//	NOT_FOUND_ERR = 8;
+		//	NOT_SUPPORTED_ERR = 9;
+		//	INUSE_ATTRIBUTE_ERR = 10;
+		//	INVALID_STATE_ERR = 11;
+		//	SYNTAX_ERR = 12;
+		//	INVALID_MODIFICATION_ERR = 13;
+		//	NAMESPACE_ERR = 14;
+		//	INVALID_ACCESS_ERR = 15;
+		//};
+	
+		return err;
+	}
+}; //End $wf2 = {
+
+
+/*##############################################################################################
+ # Section: Repetition Model Definitions
+ ##############################################################################################*/
+
+var RepetitionElement = {
+	REPETITION_NONE:0,
+	REPETITION_TEMPLATE:1,
+	REPETITION_BLOCK:2
+};
+
+var RepetitionEvent = {
+	//the following takes a UIEvent and adds the required properties for a RepetitionEvent
+	_upgradeEvent : function(){
+		this.initRepetitionEvent = RepetitionEvent.initRepetitionEvent;
+		this.initRepetitionEventNS = RepetitionEvent.initRepetitionEventNS;
+	},
+	initRepetitionEvent : function(typeArg, canBubbleArg, cancelableArg, elementArg){
+		if(this.initEvent)
+			this.initEvent(typeArg, canBubbleArg, cancelableArg);
+		else { //manually initialize event (i.e., for MSIE)
+			this.type = typeArg;
+	//		switch(typeArg.toLowerCase()){
+	//			case 'added':
+	//				this.type = 'add';
+	//				break;
+	//			case 'removed':
+	//				this.type = 'remove';
+	//				break;
+	//			case 'moved':
+	//				this.type = 'move';
+	//				break;
+	//		}
+			//this.srcElement = elementArg.repetitionTemplate;
+			//this.cancelBubble = false;
+			//this.cancelable = cancelableArg;
+			//this.returnValue = false;
+			
+			if(!this.preventDefault)
+			this.preventDefault = function(){
+				this.returnValue = false;
+			};
+			if(!this.stopPropagation)
+			this.stopPropagation = function(){
+				this.cancelBubble = true;
+			};
+		}
+		this.element = elementArg;
+		this.relatedNode = elementArg; //for Opera (deprecated?)
+	},
+	initRepetitionEventNS : function(namespaceURIArg, typeArg, canBubbleArg, cancelableArg, elementArg){
+		throw Error("NOT IMPLEMENTED: RepetitionEvent.initRepetitionEventNS");
+		//this.initEvent(namespaceURIArg, typeArg, canBubbleArg, cancelableArg);
+		//this.element = elementArg;
+		//this.relatedNode = elementArg; //for Opera (deprecated?)
+	}
+};
+
+/*##############################################################################################
+ # Change the prototypes of HTML elements
+ ##############################################################################################*/
+
+//RepetitionElement interface must be implemented by all elements.
+if(window.Element && Element.prototype){
+	Element.prototype.REPETITION_NONE     = RepetitionElement.REPETITION_NONE;
+	Element.prototype.REPETITION_TEMPLATE = RepetitionElement.REPETITION_TEMPLATE;
+	Element.prototype.REPETITION_BLOCK    = RepetitionElement.REPETITION_BLOCK;
+	
+	Element.prototype.repetitionType      = RepetitionElement.REPETITION_NONE;
+	Element.prototype.repetitionIndex     = 0;
+	Element.prototype.repetitionTemplate  = null; /*readonly*/
+	Element.prototype.repetitionBlocks    = null; /*readonly*/
+
+	Element.prototype.repeatStart = 1;
+	Element.prototype.repeatMin   = 0;
+	Element.prototype.repeatMax   = Number.MAX_VALUE; //Infinity;
+	
+	Element.prototype.addRepetitionBlock        = $wf2.addRepetitionBlock;
+	Element.prototype.addRepetitionBlockByIndex = $wf2.addRepetitionBlockByIndex;
+	Element.prototype.moveRepetitionBlock       = $wf2.moveRepetitionBlock;
+	Element.prototype.removeRepetitionBlock     = $wf2.removeRepetitionBlock;
+}
+
+/*##############################################################################################
+ # Set mutation event handlers to automatically add WF2 behaviors
+ ##############################################################################################*/
+
+//When a form control is inserted into a document, the UA must check to see if it has [the autofocus]
+//  attribute set. If it does, and the control is not disabled, and it is of a type normally
+//  focusable in the user's operating environment, then the UA should focus the control, as if
+//  the control's focus() method was invoked. UAs with a viewport should also scroll the document
+//  enough to make the control visible, even if it is not of a type normally focusable.
+//REVISE: there should be one handler for all attr events on the page.
+if(document.addEventListener){
+	document.addEventListener('DOMNodeInsertedIntoDocument', function(evt){ //DOMNodeInserted? DOMNodeInsertedIntoDocument
+		if(evt.target.nodeType == 1 && evt.target.hasAttribute('autofocus')){
+			$wf2.initAutofocusElement(evt.target);
+		}
+		//[[UAs may ignore this attribute if the user has indicated (for example, by starting to type in a
+		//    form control) that he does not wish focus to be changed.]]
+	}, false);
+
+	//NOT CURRENTLY IMPLEMENTABLE:
+	//  Setting the DOM attribute to true must set the content attribute to the value autofocus.
+	//  Setting the DOM attribute to false must remove the content attribute.
+
+	document.addEventListener('DOMAttrModified', function(evt){
+		//The autofocus DOM attribute must return true when the content attribute is present (regardless
+		//   of its value, even if it is the empty string), and false when it is absent.
+		if(evt.attrName == 'autofocus'){
+			if(evt.attrChange == evt.ADDITION)
+				//evt.relatedNode.autofocus = true;
+				$wf2.initAutofocusElement(evt.target);
+			else if(evt.attrChange == evt.REMOVAL)
+				evt.target.autofocus = false;
+		}
+	}, false);
+}
+
+/*##################################################################################
+ # Execute WF2 code onDOMContentLoaded
+ # Some of the following code was borrowed from Dean Edwards, John Resig, et al <http://dean.edwards.name/weblog/2006/06/again/>
+ ##################################################################################*/
+
+(function(){
+//Get the path to the library base directory
+var match;
+//For some reason, if not using documentElement, scriptaculous fails to load if reference to
+//   webforms2 script placed beforehand in Firefox
+var scripts = document.documentElement.getElementsByTagName('script'); 
+for(var i = 0; i < scripts.length; i++){
+	if(match = scripts[i].src.match(/^(.*)webforms2[^\/]+$/))
+		$wf2.libpath = match[1];
+}
+
+//The script has been included after the DOM has loaded (perhaps via Greasemonkey), so fire immediately
+//NOTE: This does not work with XHTML documents in Gecko
+if(document.body){
+	$wf2.onDOMContentLoaded();
+	return;
+}
+
+var eventSet = 0;
+if(document.addEventListener){
+	//for Gecko and Opera
+	document.addEventListener('DOMContentLoaded', function(){
+		$wf2.onDOMContentLoaded();
+	}, false);
+
+	//for other browsers which do not support DOMContentLoaded use the following as a fallback to be called hopefully before all other onload handlers
+	window.addEventListener('load', function(){
+		$wf2.onDOMContentLoaded();
+	}, false);
+	
+	eventSet = 1;
+}
+
+//for Safari
+if (/WebKit/i.test(navigator.userAgent)) { //sniff
+	var _timer = setInterval(function() {
+		if (/loaded|complete/.test(document.readyState)) {
+			clearInterval(_timer);
+			delete _timer;
+			$wf2.onDOMContentLoaded();
+		}
+	}, 10);
+	eventSet = 1;
+}
+//for Internet Explorer (formerly using conditional comments) //sniff
+else if(/MSIE/i.test(navigator.userAgent) && !document.addEventListener && window.attachEvent){
+	//This following attached onload handler will attempt to be the first onload handler to be called and thus
+	//  initiate the repetition model as early as possible if the DOMContentLoaded substitute fails.
+	window.attachEvent('onload', function(){
+		$wf2.onDOMContentLoaded();
+	});
+	
+	//Dean Edward's first solution: http://dean.edwards.name/weblog/2005/09/busted/
+	//document.getElementsByTagName('*')[0].addBehavior(dirname + 'repetition-model.htc'); //use this if Behaviors are employed in 0.9
+	document.write("<script defer src='" + $wf2.libpath + "webforms2-msie.js'><"+"/script>");
+
+	//Dean Edward's revisited solution <http://dean.edwards.name/weblog/2005/09/busted/> (via Matthias Miller with insights from jQuery)
+	//  Note that this solution will not result in its code firing before onload if there are no external images in the page; in this case, first solution above is used.
+	document.write("<scr" + "ipt id='__wf2_ie_onload' defer src='//:'><\/script>"); //MSIE memory leak according to Drip
+	var script = document.getElementById('__wf2_ie_onload');
+	script.onreadystatechange = function(){
+		if(this.readyState == 'complete'){
+			this.parentNode.removeChild(this);
+			$wf2.onDOMContentLoaded();
+			
+			//See issue #3 <http://code.google.com/p/repetitionmodel/issues/detail?id=3>
+			//Sometimes cssQuery doesn't find all repetition templates from here within this DOMContentLoaded substitute
+			if($wf2.repetitionTemplates.length == 0)
+				$wf2.isInitialized = false;
+		}
+	};
+	script = null;
+	eventSet = 1;
+}
+
+//old event model used as a last-resort fallback
+if(!eventSet){
+	if(window.onload){ //if(window.onload != RepetitionElement._init_document)
+		var oldonload = window.onload;
+		window.onload = function(){
+			$wf2.onDOMContentLoaded();
+			oldonload();
+		};
+	}
+	else window.onload = function(){
+		$wf2.onDOMContentLoaded();
+	};
+}
+})();
+} //End If(!document.implementation...
+
+/*##############################################################################################
+ # Extensions for existing Web Forms 2.0 Implementations
+ ##############################################################################################*/
+else if(document.addEventListener && ($wf2.oldRepetitionEventModelEnabled === undefined || $wf2.oldRepetitionEventModelEnabled)){
+	$wf2.oldRepetitionEventModelEnabled = true;
+	(function(){
+		
+	var deprecatedAttrs = {
+		added   : 'onadd',
+		removed : 'onremove',
+		moved   : 'onmove'
+	};
+	
+	function handleRepetitionEvent(evt){
+		if(!$wf2.oldRepetitionEventModelEnabled)
+			return;
+		if(!evt.element && evt.relatedNode) //Opera uses evt.relatedNode instead of evt.element as the specification dictates
+			evt.element = evt.relatedNode;
+		if(!evt.element || !evt.element.repetitionTemplate)
+			return;
+		
+		var rt = evt.element.repetitionTemplate;
+		var attrName = 'on' + evt.type;
+		
+		//Add support for event handler set with HTML attribute
+		var handlerAttr = rt.getAttribute(attrName) || /* deprecated */ rt.getAttribute(deprecatedAttrs[evt.type]);
+		if(handlerAttr && (!rt[attrName] || typeof rt[attrName] != 'function')) //in MSIE, attribute == property
+			rt[attrName] = new Function('event', handlerAttr);
+		
+		if(evt.element.repetitionTemplate[attrName])
+			evt.element.repetitionTemplate[attrName](evt);
+		else if(evt.element.repetitionTemplate[deprecatedAttrs[evt.type]]) //deprecated
+			evt.element.repetitionTemplate[deprecatedAttrs[evt.type]](evt);
+	}
+	
+	document.addEventListener('added', handleRepetitionEvent, false);
+	document.addEventListener('removed', handleRepetitionEvent, false);
+	document.addEventListener('moved', handleRepetitionEvent, false);
+	
+	})();
+}
+
+} //end if(!window.$wf2)
+
+