<!--

// Courtesy of SimplytheBest.net - http://simplythebest.net/scripts/DHTML_scripts/javascripts/javascript_138.html

// Input box
//=============================================================================
keytotal1 = 20;
function changed1 (form, mytext1) {
var s = mytext1.name;
var index;
if (s.indexOf('[') == -1) {
index = 0;
} else {
index = s.substring( s.indexOf('[')+1,s.indexOf(']') );
}
checkit1(mytext1,index);
}

function checkit1(mytext1,zindex) {
if (!(zindex >= 0)) {
zindex = '';
}
var s = mytext1.name;
var zindex;
if (s.indexOf('[') == -1) {
zindex = 0;
}
else
{
zindex = s.substring( s.indexOf('[')+1,s.indexOf(']') );
}
if (mytext1.value.length > keytotal1) {
mytext1.value = mytext1.value.substring(0,keytotal1);
}
if (document.getElementById('charCountA'+zindex)) {
document.getElementById('charCountA'+zindex).innerHTML = mytext1.value.length
}
}

// Textarea Characters counter
//=============================================================================

function changed2 (form, mytext2,maxChar,spantest) {
	keytotal2 = maxChar;
	SpanID = spantest;
	var s = mytext2.name;
	var index;
	if (s.indexOf('[') == -1) {
	index = 0;
	} else {
	index = s.substring( s.indexOf('[')+1,s.indexOf(']') );
	}
checkit2(mytext2,index);
}

function checkit2(mytext2,zindex) {
if (!(zindex >= 0)) {
zindex = '';
}
var s = mytext2.name;
var zindex;
if (s.indexOf('[') == -1) {
zindex = 0;
 }
else
{
zindex = s.substring( s.indexOf('[')+1,s.indexOf(']') );
}
if (mytext2.value.length > keytotal2) {
mytext2.value = mytext2.value.substring(0,keytotal2);
}
if (document.getElementById(SpanID+zindex)) {
document.getElementById(SpanID+zindex).innerHTML = mytext2.value.length
}
}








/**
 * DHTML textbox character counter script. Courtesy of SmartWebby.com (http://www.smartwebby.com/dhtml/)
 */

//maxL=255;
var bName = navigator.appName;
function taLimit(taObj) {
	if (taObj.value.length==maxL) return false;
	return true;
}

function taCount(taObj,Cnt,maxL) { 
	objCnt=createObject(Cnt);
	objVal=taObj.value;
	if (objVal.length>maxL) objVal=objVal.substring(0,maxL);
	if (objCnt) {
		if(bName == "Netscape"){	
			objCnt.textContent=maxL-objVal.length;}
		else{objCnt.innerText=maxL-objVal.length;}
	}
	return true;
}
function createObject(objId) {
	if (document.getElementById) return document.getElementById(objId);
	else if (document.layers) return eval("document." + objId);
	else if (document.all) return eval("document.all." + objId);
	else return eval("document." + objId);
}




// Generic Form Validation
//
// Copyright (C) 2000 Jacob Hage - [jacobhage@hotmail.com]
// Distributed under the terms of the GNU Library General Public License
// -----------------------------------------------------------------------------

// -----------------------------------------------------------------------------
// Initializing script  - setting global variables
// -----------------------------------------------------------------------------
var checkObjects		= new Array(); 	// Array containing the objects to validate.
var errors				= ""; 			// Variable holding the error message.
var returnVal			= false; 		// General return value. The validated form will only be submitted if true.
var language			= new Array(); 	// Language independent error messages!
var selectecLanguage	= "english";	// Choose between "english", "danish", "dutch", "french", "spanish", "russian", "portuguese"

language.english		= new Array();

// Error messages in english:
	language.english.header		= "The following error(s) occurred:";
	language.english.start		= ">>";
	language.english.field		= " ";
	language.english.require	= " is required ";
	language.english.min			= " and must consist of at least ";
	language.english.max			= " and must not contain more than ";
	language.english.minmax		= " and no more than ";
	language.english.chars		= " characters ";
	language.english.num			= " and must contain a number ";
	language.english.email		= " must contain a valid e-mail address ";

// -----------------------------------------------------------------------------
// define - Call this function in the beginning of the page. I.e. onLoad.
//
// n = name of the input field (Required)
// type= string, num, email (Required)
// min = the value must have at least [min] characters (Optional)
// max = the value must have maximum [max] characters (Optional)
// d = (Optional)
// -----------------------------------------------------------------------------
function define(n,type,HTMLname,min,max,d){
	var p;
	var i;
	var x;
	if(!d) d=document;
	if((p=n.indexOf("?"))>0&&parent.frames.length){
    	d=parent.frames[n.substring(p+1)].document;
    	n=n.substring(0,p);
    }
	if(!(x=d[n])&&d.all) x=d.all[n];

  	for (i=0;!x&&i<d.forms.length;i++){
  		x=d.forms[i][n];
  	}
	for(i=0;!x&&d.layers&&i<d.layers.length;i++){
		x=define(n,type,HTMLname,min,max,d.layers[i].document);
		return x;
	}

	// Create Object. The name will be "V_something" where something is the "n" parameter above.
	eval("V_"+n+" = new formResult(x,type,HTMLname,min,max);");
	checkObjects[eval(checkObjects.length)] = eval("V_"+n);
}

// -----------------------------------------------------------------------------
// formResult - Used internally to create the objects
// -----------------------------------------------------------------------------
function formResult(form,type,HTMLname,min,max){
	this.form = form;
	this.type = type;
	this.HTMLname = HTMLname;
	this.min  = min;
	this.max  = max;
}

// -----------------------------------------------------------------------------
// validate - Call this function onSubmit and return the "returnVal". (onSubmit="validate();return returnVal;")
// -----------------------------------------------------------------------------
function validate(){
	if(checkObjects.length>0){
		errorObject = "";

		for(i=0;i<checkObjects.length;i++){
			validateObject 			= new Object();
			validateObject.form 		= checkObjects[i].form;
			validateObject.HTMLname = checkObjects[i].HTMLname;
			validateObject.val 		= checkObjects[i].form.value;
			validateObject.len 		= checkObjects[i].form.value.length;
			validateObject.min 		= checkObjects[i].min;
			validateObject.max 		= checkObjects[i].max;
			validateObject.type 		= checkObjects[i].type;

			//Debug alert line
			//alert("validateObject: "+validateObject+"\nvalidateObject.val: "+validateObject.val+"\nvalidateObject.len: "+validateObject.len+"\nvalidateObject.min,validateObject.max: "+validateObject.min+","+validateObject.max+"\nvalidateObject.type: "+validateObject.type);

			// Checking input. If "min" and/or "max" is defined the input has to be within the specific range
			if(validateObject.type == "num" || validateObject.type == "string"){
				if((validateObject.type == "num" && validateObject.len <= 0) || (validateObject.type == "num" && isNaN(validateObject.val))){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].num+"\n";
				} else if (validateObject.min && validateObject.max && (validateObject.len < validateObject.min || validateObject.len > validateObject.max)){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].minmax+validateObject.max+language[selectecLanguage].chars+"\n";
				} else if (validateObject.min && !validateObject.max && (validateObject.len < validateObject.min)){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].min+validateObject.min+language[selectecLanguage].chars+"\n";
				} else if (validateObject.max && !validateObject.min &&(validateObject.len > validateObject.max)){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+language[selectecLanguage].max+validateObject.max+language[selectecLanguage].chars+"\n";
				} else if (!validateObject.min && !validateObject.max && validateObject.len <= 0){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].require+"\n";
				}
			} else if(validateObject.type == "email"){
				// Checking existense of "@" and ".". The length of the input must be at least 5 characters. The "." must neither be preceding the "@" nor follow it.
				if((validateObject.val.indexOf("@") == -1) || (validateObject.val.charAt(0) == ".") || (validateObject.val.charAt(0) == "@") ||(validateObject.len < 6) || (validateObject.val.indexOf(".") == -1) || (validateObject.val.charAt(validateObject.val.indexOf("@")+1) == ".") || (validateObject.val.charAt(validateObject.val.indexOf("@")-1) == ".")){errors+=language[selectecLanguage].start+language[selectecLanguage].field+validateObject.HTMLname+language[selectecLanguage].email+"\n";}
			}
		}
	}
	// Used to set the state of the returnVal. If errors -> show error messages in chosen language
	if(errors){
		alert(language[selectecLanguage].header.concat("\n"+errors));
		errors = "";
		returnVal = false;
	} else {
		returnVal = true;
	}
}

// ---------------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------------- //
// Date   : 07/01/2005
// Creator: Grazia Cipresso (gcipresso.com/netzcart.com)
// Purpose: Array based custom javascript form validation
//          (created in this manner to eliminate interference with other scripts on the page)
//				( - the dynamic product boxes and html editor.)
//
// GPU License (keep this entire message intact)
//
// Details:
//          Validates the following input types (email, password, phone, string, number, postal code, money,
//           radio, checkbox, select)
// -------------------------------------------- step (1) ---------------------------------------------- //
//			     <form name="login1" onSubmit="initValid();authenticate();return returnVal;">              //
// -------------------------------------------- step (2) ---------------------------------------------- //
/*                **** Add the following to the same page as the form.
	               <script language="JavaScript" type="text/javascript">
	               <!--
	               function initValid(){
	               	  var identify = "";
		                 identify = new Array();
		                 //arrayname = ["fieldname","type","fieldlabel",min,max,document.formname,required(0/1)];
		                 identify[0] = ["Email","email","Email Address",,,"document.login1",1];
		                 identify[1] = ["Password","password","Password",6,15,"document.login1",1];
	               }
	              // -->
	              </script>
*/
//               Notes:	required: 0, 1, 2
//								if required is set to 0 then field is not required, but the content is checked and
//                          any illegal characters are stripped.
//                      if required is set to 1 then field is required and validated.
//                      if required is set to 2 then field is required and not validated.
//
// ---------------------------------------------------------------------------------------------------- //
// Updated 07/31/2008 - gac - Note: if validation is not working on a field, then please make sure that
// the call to this script is after all other scripts on the top of the page. After, calendar.js, after
// functions.js, etc.
// ---------------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------------- //
// ---------------------------------------------------------------------------------------------------- //
//var returnVal			= false; 			// General return value. The validated form will only be submitted if true.
var identify 			= "";
function authenticate() {
	var errors 			= "";
	var perrors 		= "";
	var debugValid 		= false;  			// Set to true to display debug alert messages.

	var ccValid = new Date();
	ccValid.setMonth(ccValid.getMonth() + 1); // Months array 0 to 11
	var ccMonthNum = ccValid.getMonth();
	var ccYearNum  = ccValid.getFullYear();

	var fffFlag = 0;					//  First Form Field with Error Flag
	var ffField = "";					//  First Form Field with Errors fieldname
	var ffSpecFlag = 0;

	function setFieldFocus() {
		// Find error field to set focus too.
		if (fffFlag == 0 ) {

			if (arrfield_name != "inpContent1" || arrfield_name != "inpContent2" || arrfield_name.type != "strCountyTax") { // cannot focus on HTMLEditor or hidden countytax field
				ffField = arrfield_form + "." + arrfield_name + ".focus()";
			}
		}
		fffFlag++;
	}

   function checkContent (tempVal) {
		// Updated 08/29/2007 - GAC
		ffSpecFlag = 0;
		var intGoodChars = "";
		// Remove illegal characters from input fields / global replace
		intGoodChars = tempVal.replace(/(<script)+/ig,"");
		intGoodChars = intGoodChars.replace(/(\<\/script>)+/ig,"");
		intGoodChars = intGoodChars.replace(/(\<\%)+/ig,"");
		intGoodChars = intGoodChars.replace(/(\%\>)+/ig,"");
		intGoodChars = intGoodChars.replace(/(\<\?)+/ig,"");
		intGoodChars = intGoodChars.replace(/(\?\>)+/ig,"");
		if (intGoodChars.length < tempVal.length) {
			 ffSpecFlag++;
		}
		//alert("intGoodChars.length = " + intGoodChars.length + "\ntempVal.length = " + tempVal.length);
		//alert(ffSpecFlag);
	}

	// ---------------------------------------------------------------------------------------------------------- //
	// --------------------------------------- start - loop through array --------------------------------------- //
	// ---------------------------------------------------------------------------------------------------------- //
	for (var x = 0; x < identify.length; x++) {
		if ( identify[x] != null || identify[x] != undefined ) {

			// Populate generic variables from identify array
			arrfield_name 	= identify[x][0]; // field name
			arrfield_type 	= identify[x][1]; // field type
			arrfield_label = identify[x][2]; // label/HTML name
			arrfield_min 	= identify[x][3]; // min length
			arrfield_max 	= identify[x][4]; // max length
			arrfield_form 	= identify[x][5]; // form name (document.form)
			arrfield_req 	= identify[x][6]; // required? (0=no/test,1=yes/test,2=yes/notest)

			arrfield_el		= eval(arrfield_form + "." + arrfield_name);					// field descriptor

			if ( arrfield_el != null || arrfield_el != undefined ) {

				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
					arrfield_val	= eval(arrfield_form + "." + arrfield_name + ".value");				// field value
					arrfield_len	= eval(arrfield_form + "." + arrfield_name + ".value.length");		// length of field value
				}
				// ---------------------------------------------------------------------------------------------------------- //
				// ------------------------------ start - check dropdowns and buttons function ------------------------------ //
				// ---------------------------------------------------------------------------------------------------------- //
				if (arrfield_type == "radio" || arrfield_type == "checkbox" || arrfield_type == "select") {
					if ( arrfield_type == "radio" ) {
						var radioCtr = 0;
						var radioChk = eval(arrfield_form + "." + arrfield_name + ".length");
						for (var i = 0; i < radioChk; i++) {
							if (eval(arrfield_form + "." + arrfield_name + "[" + i + "].checked") == true) { radioCtr++; }
						}
						if ( radioCtr == 0 ) {
							if ( arrfield_len > 0 && arrfield_req == 1 ) {
								errors += "\n\n\u00BB Radio button for  '" + arrfield_label + "'  was not checked.";
								setFieldFocus();
							} else { errors += ""; }
						}
					}
					if ( arrfield_type == "checkbox" ) {
						var checkCtr = 0;
						if (eval(arrfield_form + "." + arrfield_name + ".checked") == true) { checkCtr++; }
						if ( checkCtr == 0 ) {
							if ( arrfield_len > 0 && arrfield_req == 1 ) {
								errors += "\n\n\u00BB Checkbox for  '" + arrfield_label + "'  was not checked.";
								setFieldFocus();
							} else { errors += ""; }
						}
					}
					if ( arrfield_type == "select" ) {
						var selectCtr = 0;
						var selectChk = eval(arrfield_form + "." + arrfield_name + ".options[" + arrfield_form + "." + arrfield_name + ".selectedIndex].value.length");
						if ( selectChk > 0) { selectCtr++; }
						if ( selectCtr == 0 ) {
							if ( arrfield_len > 0 && arrfield_req == 1 ) {
								errors += "\n\n\u00BB Dropdown item for  '" + arrfield_label + "'  was not selected.";
								setFieldFocus();
							} else { errors += ""; }
						}
					}
				}
				// ---------------------------------------------------------------------------------------------------------- //
				// ------------------------------  end  - check dropdowns and buttons function ------------------------------ //
				// ---------------------------------------------------------------------------------------------------------- //
				// Debug Output string
				aText =  "\nname = " + arrfield_name + "\ntype = " + arrfield_type + "\nlabel = " + arrfield_label + "\nmin = " + arrfield_min;
				aText += "\nmax = " + arrfield_max + "\nform = " + arrfield_form;
				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
				aText += "\nval = " + arrfield_val + "\nlen = " + arrfield_len;
				}
				aText += "\nrequired = " + arrfield_req;
				if (debugValid) { alert(aText); }   // Set debugValid to true to view debug output

				// ---------------------------------------------------------------------------------------------------------- //
				// ----------------------------------- start - strip whitespace function ------------------------------------ //
				// ---------------------------------------------------------------------------------------------------------- //
				// Trim Leading and Trailing White Space
				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
					if ( arrfield_len > 0 && arrfield_req == 1 ) {
						var LTrimPattern = /^\s */;
						var RTrimPattern = /\s *$/;

						arrfield_val = arrfield_val.replace(/^\s */g, "");
						arrfield_val = arrfield_val.replace(/\s *$/g, "");
						eval(arrfield_form + "." + arrfield_name + ".value = arrfield_val");					// populate field with new value
						arrfield_len = eval(arrfield_form + "." + arrfield_name + ".value.length");		// length of field value

					}
				}
				// ---------------------------------------------------------------------------------------------------------- //
				// -----------------------------------  end  - strip whitespace function ------------------------------------ //
				// ---------------------------------------------------------------------------------------------------------- //

				// ---------------------------------------------------------------------------------------------------------- //
				// ----------------------------------- start - min/max validation function ---------------------------------- //
				// ---------------------------------------------------------------------------------------------------------- //
				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
					if ( arrfield_len > 0 && arrfield_req == 1 ) {			// Check if field is required (1)
						// form field contains data = true

						// min > 0 and max > 0 = true
						if ( ( arrfield_min > 0 && arrfield_max > 0 ) && ( arrfield_len < arrfield_min || arrfield_len > arrfield_max ) ) {
							errors += "\n\n\u00F7 " + arrfield_label + " - must be between " + arrfield_min + " and " + arrfield_max + " characters.";
							setFieldFocus();
						}
						// min > 0 and max is empty = true
						else if ( arrfield_len < arrfield_min && !arrfield_max ) {
							errors += "\n\n\u00F7 " + arrfield_label + " - must be at least " + arrfield_min + " characters.";
							setFieldFocus();
						}
						// min is empty and max > 0 = true
						else if ( arrfield_len > arrfield_max && !arrfield_min ) {
							errors += "\n\n\u00F7 " + arrfield_label + " - must be less than " + (arrfield_max + 1) + " characters.";
							setFieldFocus();
						}
					}
					else if ( !arrfield_len && arrfield_req == 1) {
						// form field contains data = false
						errors += "\n\n\u00F7 " + arrfield_label + " - is blank. (required)";
						setFieldFocus();
					}
				}
				// ---------------------------------------------------------------------------------------------------------- //
				// -----------------------------------  end  - min/max validation function ---------------------------------- //
				// ---------------------------------------------------------------------------------------------------------- //

				// ---------------------------------------------------------------------------------------------------------- //
				// --------------------------------------- start - pattern validation --------------------------------------- //
				// ---------------------------------------------------------------------------------------------------------- //
				function checkPattern(arrfield_val, arrfield_label, arrfield_type, arrfield_el, perrors) {
					var resultStr 	= "";				// Stores validation pattern matching boolean result
					var patternStr = "";				// Stores regexp pattern to match user input against
					var formatStr 	= "";				// Stores examples of acceptable user input to display in error messages

					// Get Pattern to validate user input against
					if ( arrfield_type == "string" ) {							// Regexp pattern for string characters
						patternStr =  /[^\<\>\{\}]+/;
						formatStr = "( script tags not allowed )";
					}
					else if ( arrfield_type == "text") {
						arrtemp = arrfield_val.replace(/[^\w-]/g,"");			// Regexp pattern for text
						eval(arrfield_form + "." + arrfield_name + ".value = arrtemp");
					}
					else if ( arrfield_type == "stext") {
						arrtemp = arrfield_val.replace(/[^\w-\s]/g,"");			// Regexp pattern for text includes (space)
						eval(arrfield_form + "." + arrfield_name + ".value = arrtemp");
					}
					else if ( arrfield_type == "integer") {						// Regexp pattern for integer, digits only
						patternStr = /^[0-9]*$/;
						formatStr = "( 0-9 )";
					}
					else if ( arrfield_type == "number") {						// Regexp pattern for numbers, includes  ( . )
						patternStr = /^[\d]{1,10}[.|]?[\d]{1,3}|(\d)$/;
						formatStr = "( 12345, 123.45 )";
					}
					else if ( arrfield_type == "domain" ) {
						patternStr = /^[\w_-]+(\.[\w_-]{2,3})?\.\w{2,4}$/;		// Regexp pattern for domains, allows domain.co.uk, domain.com.mx, domain.info, domain.com
						formatStr = "( my-domain.com, domain.co.uk )";
					}
					else if ( arrfield_type == "silo_domain" ) {
						patternStr = /^[\w_-]+(\.[\w_-]{2,3})?\.\w{2,4}(\/[\w_-]+)*$/;		// Regexp pattern for domains + folders
						formatStr = "( my-domain.com/Folder, domain.co.uk/Folder1/Folder2 )";
					}
					else if ( arrfield_type == "email" ) {						// Regexp pattern for email addresses
						patternStr = /[\w_-]+(\.[\w_-]+)*@[\w_-]+(\.[\w_-]+)*\.\w{2,3}/;
						formatStr = "( name@site.com )";
					}
					else if ( arrfield_type == "money" ) {						// Regexp pattern for money
						patternStr = /^(\d{0,3})*(,\d{0,3})*(,\d{0,3})*\.\d{2,3}|[$]?[\d]*(\d{0,3})*(,\d{0,3})*(,\d{0,3})*\.\d{2,3}$/;
						formatStr = "( $9,999.99 - $9,999.999 - 99.99 - 99.999 - 999 )";
					}
					else if ( arrfield_type == "zip") {							// Regexp pattern for usa & international zip codes
						patternStr = /^(\d{5}((|-)-\d{4})?)|[\w\d]{2,5}(-|.)? [\w\d]{2,5}|[\w\d]{2,5}[?][\w\d]{2,5}$/;
						formatStr = "( US, Canada, and UK postal codes allowed )";
					}
					else if ( arrfield_type == "date" ) {						// Regexp pattern for dates
						patternStr = /^\d{1,2}(\-|\/|\.)\d{1,2}\1\d{4}$/;
						formatStr = "( mm-dd-yyyy )";
					}

					if ( patternStr ) {
						resultStr = patternStr.test(arrfield_val);
						if ( !resultStr ) {
							// Debug Output string
							if (debugValid) { alert("\nlabel = " + arrfield_label + "\nresult = " + resultStr); }
							if ( arrfield_len > 0 && arrfield_req < 2 ) {
								perrors = "\n\n\u00F7\u00F7\u00F7 " + arrfield_label + " - " + arrfield_type + " invalid format " + formatStr + ".";
								setFieldFocus();
							} else { perrors = ""; }
							errors = errors + perrors;
						}
					}
				}
				function checkOtherTypes(arrfield_val, arrfield_label, arrfield_type, arrfield_el, perrors) {
					if ( arrfield_type == "ccMonth") {					// Regexp pattern for integer, digits only
						//alert("ccMonth = " + ccMonthNum);
						function checkccMonth() { if ( arrfield_val <= ccMonthNum && arrfield_val < ccYearNum) { return false; } else { return true; } }
						checkccMonth();
						if ( !checkccMonth() ) {
							if ( arrfield_req == 1 ) {
								errors += "\n\n\u00F7\u00F7\u00F7 " + arrfield_label + " is invalid, it must be at least 1 month in future.\n\u00A0\u00A0\u00A0\u00A0 ( purchase date = 01/01/1900 | expiration date = 02/01/1900 )";
								setFieldFocus();
							} else { errors += ""; }
						}
					}
					if ( arrfield_type == "ccYear") {						// Regexp pattern for numbers, includes  ( . )
						function checkccYear() { if ( arrfield_val < ccYearNum && arrfield_val <= ccMonthNum ) { return false; } else { return true; } }
						checkccYear();
						if ( !checkccYear() ) {
							if ( arrfield_req == 1 ) {
								errors += "\n\n\u00F7\u00F7\u00F7 " + arrfield_label + " is invalid, it must be at least equal to current year and 1 month in future.\n\u00A0\u00A0\u00A0\u00A0 ( purchase date = 12/1900 | expiration date = 01/1901 )";
								setFieldFocus();
							} else { errors += ""; }
						}
					}
				}
				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
					if ( arrfield_len > 0 && arrfield_req < 2 ) {
						checkPattern(arrfield_val, arrfield_label, arrfield_type, arrfield_el, errors); 			 /* Validates data input */
						checkOtherTypes(arrfield_val, arrfield_label, arrfield_type, arrfield_el, errors); 		 /* Validates Form Elements input */
					}
				}
				// ---------------------------------------------------------------------------------------------------------- //
				// ---------------------------------------  end  - pattern validation --------------------------------------- //
				// ---------------------------------------------------------------------------------------------------------- //
				if ( arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select" ) {
					if ( arrfield_len > 0 && arrfield_req < 2 ) {
						checkContent(arrfield_val);
						if ( ffSpecFlag > 0 ) {
							// Updated 08/29/2007 - GAC
							arrfield_val = arrfield_val.replace(/(<script)+/ig,"");
							arrfield_val = arrfield_val.replace(/(\<\/script>)+/ig,"");
							arrfield_val = arrfield_val.replace(/(\<\%)+/ig,"");
							arrfield_val = arrfield_val.replace(/(\%\>)+/ig,"");
							arrfield_val = arrfield_val.replace(/(\<\?)+/ig,"");
							arrfield_val = arrfield_val.replace(/(\?\>)+/ig,"");
							errors += "\n\n** Illegal script tags removed from  '" + arrfield_label + "'  field.";
							eval(arrfield_form + "." + arrfield_name + ".value = arrfield_val");					// populate field with new value
							setFieldFocus();
						}
					}
				}
			}
		}
	}
	// ---------------------------------------------------------------------------------------------------------- //
	// ---------------------------------------  end  - loop through array --------------------------------------- //
	// ---------------------------------------------------------------------------------------------------------- //

	// ---------------------------------------------------------------------------------------------------------- //
	// --------------------------------------- start - display error messages ----------------------------------- //
	// ---------------------------------------------------------------------------------------------------------- //
	if ( errors ) {
		errheader ="Please complete the following:";
		alert(errheader + errors);
		identify = "";
		returnVal = false;
		if (arrfield_type != "radio" && arrfield_type != "checkbox" && arrfield_type != "select") {
			eval(ffField);
		}
	}
	else {  returnVal = true;  }
	// ---------------------------------------------------------------------------------------------------------- //
	// ---------------------------------------  end  - display error messages ----------------------------------- //
	// ---------------------------------------------------------------------------------------------------------- //
}