text: /*
   * FuncUnit - 2.0.4
   * http://funcunit.com
   * Copyright (c) 2013 Bitovi
   * Tue, 19 Nov 2013 20:58:56 GMT
   * Licensed MIT */
  
  /*
   * Syn - 3.3.1
   * 
   * Copyright (c) 2013 Bitovi
   * Tue, 08 Oct 2013 00:20:41 GMT
   * Licensed MIT */
  
  !function(window) {
  
  // ## synthetic.js
  var __m2 = (function(){
  	//allow for configuration of Syn
  	var opts = window.Syn ? window.Syn : {};
  
  	var extend = function( d, s ) {
  		var p;
  		for (p in s) {
  			d[p] = s[p];
  		}
  		return d;
  	},
  		// only uses browser detection for key events
  		browser = {
  			msie: !! (window.attachEvent && !window.opera),
  			opera: !! window.opera,
  			webkit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
  			safari: navigator.userAgent.indexOf('AppleWebKit/') > -1 && navigator.userAgent.indexOf('Chrome/') === -1,
  			gecko: navigator.userAgent.indexOf('Gecko') > -1,
  			mobilesafari: !! navigator.userAgent.match(/Apple.*Mobile.*Safari/),
  			rhino: navigator.userAgent.match(/Rhino/) && true
  		},
  		createEventObject = function( type, options, element ) {
  			var event = element.ownerDocument.createEventObject();
  			return extend(event, options);
  		},
  		data = {},
  		id = 1,
  		expando = "_synthetic" + new Date().getTime(),
  		bind, unbind, key = /keypress|keyup|keydown/,
  		page = /load|unload|abort|error|select|change|submit|reset|focus|blur|resize|scroll/,
  		//this is maintained so we can click on html and blur the active element
  		activeElement,
  
  		/**
  		 * @class Syn
  		 * @download funcunit/dist/syn.js
  		 * @test funcunit/synthetic/qunit.html
  		 * Syn is used to simulate user actions.  It creates synthetic events and
  		 * performs their default behaviors.
  		 * 
  		 * <h2>Basic Use</h2>
  		 * The following clicks an input element with <code>id='description'</code>
  		 * and then types <code>'Hello World'</code>.
  		 * 
  		 @codestart
  		 Syn.click({},'description')
  		 .type("Hello World")
  		 @codeend
  		 * <h2>User Actions and Events</h2>
  		 * <p>Syn is typically used to simulate user actions as opposed to triggering events. Typing characters
  		 * is an example of a user action.  The keypress that represents an <code>'a'</code>
  		 * character being typed is an example of an event. 
  		 * </p>
  		 * <p>
  		 *   While triggering events is supported, it's much more useful to simulate actual user behavior.  The 
  		 *   following actions are supported by Syn:
  		 * </p>
  		 * <ul>
  		 *   <li><code>[Syn.prototype.click click]</code> - a mousedown, focus, mouseup, and click.</li>
  		 *   <li><code>[Syn.prototype.dblclick dblclick]</code> - two <code>click!</code> events followed by a <code>dblclick</code>.</li>
  		 *   <li><code>[Syn.prototype.key key]</code> - types a single character (keydown, keypress, keyup).</li>
  		 *   <li><code>[Syn.prototype.type type]</code> - types multiple characters into an element.</li>
  		 *   <li><code>[Syn.prototype.move move]</code> - moves the mouse from one position to another (triggering mouseover / mouseouts).</li>
  		 *   <li><code>[Syn.prototype.drag drag]</code> - a mousedown, followed by mousemoves, and a mouseup.</li>
  		 * </ul>
  		 * All actions run asynchronously.  
  		 * Click on the links above for more 
  		 * information on how to use the specific action.
  		 * <h2>Asynchronous Callbacks</h2>
  		 * Actions don't complete immediately. This is almost 
  		 * entirely because <code>focus()</code> 
  		 * doesn't run immediately in IE.
  		 * If you provide a callback function to Syn, it will 
  		 * be called after the action is completed.
  		 * <br/>The following checks that "Hello World" was entered correctly: 
  		 @codestart
  		 Syn.click({},'description')
  		 .type("Hello World", function(){
  		 
  		 ok("Hello World" == document.getElementById('description').value)  
  		 })
  		 @codeend
  		 <h2>Asynchronous Chaining</h2>
  		 <p>You might have noticed the [Syn.prototype.then then] method.  It provides chaining
  		 so you can do a sequence of events with a single (final) callback.
  		 </p><p>
  		 If an element isn't provided to then, it uses the previous Syn's element.
  		 </p>
  		 The following does a lot of stuff before checking the result:
  		 @codestart
  		 Syn.type('ice water','title')
  		 .type('ice and water','description')
  		 .click({},'create')
  		 .drag({to: 'favorites'},'newRecipe',
  		 function(){
  		 ok($('#newRecipe').parents('#favorites').length);
  		 })
  		 @codeend
  		 
  		 <h2>jQuery Helper</h2>
  		 If jQuery is present, Syn adds a triggerSyn helper you can use like:
  		 @codestart
  		 $("#description").triggerSyn("type","Hello World");
  		 @codeend
  		 * <h2>Key Event Recording</h2>
  		 * <p>Every browser has very different rules for dispatching key events.  
  		 * As there is no way to feature detect how a browser handles key events,
  		 * synthetic uses a description of how the browser behaves generated
  		 * by a recording application.  </p>
  		 * <p>
  		 * If you want to support a browser not currently supported, you can
  		 * record that browser's key event description and add it to
  		 * <code>Syn.key.browsers</code> by it's navigator agent.
  		 * </p>
  		 @codestart
  		 Syn.key.browsers["Envjs\ Resig/20070309 PilotFish/1.2.0.10\1.6"] = {
  		 'prevent':
  		 {"keyup":[],"keydown":["char","keypress"],"keypress":["char"]},
  		 'character':
  		 { ... }
  		 }
  		 @codeend
  		 * <h2>Limitations</h2>
  		 * Syn fully supports IE 6+, FF 3+, Chrome, Safari, Opera 10+.
  		 * With FF 1+, drag / move events are only partially supported. They will
  		 * not trigger mouseover / mouseout events.<br/>
  		 * Safari crashes when a mousedown is triggered on a select.  Syn will not 
  		 * create this event.
  		 * <h2>Contributing to Syn</h2>
  		 * Have we missed something? We happily accept patches.  The following are 
  		 * important objects and properties of Syn:
  		 * <ul>
  		 * 	<li><code>Syn.create</code> - contains methods to setup, convert options, and create an event of a specific type.</li>
  		 *  <li><code>Syn.defaults</code> - default behavior by event type (except for keys).</li>
  		 *  <li><code>Syn.key.defaults</code> - default behavior by key.</li>
  		 *  <li><code>Syn.keycodes</code> - supported keys you can type.</li>
  		 * </ul>
  		 * <h2>Roll Your Own Functional Test Framework</h2>
  		 * <p>Syn is really the foundation of JavaScriptMVC's functional testing framework - [FuncUnit].
  		 *   But, we've purposely made Syn work without any dependencies in the hopes that other frameworks or 
  		 *   testing solutions can use it as well.
  		 * </p>
  		 * @constructor 
  		 * Creates a synthetic event on the element.
  		 * @param {Object} type
  		 * @param {Object} options
  		 * @param {Object} element
  		 * @param {Object} callback
  		 * @return Syn
  		 */
  		Syn = function( type, options, element, callback ) {
  			return (new Syn.init(type, options, element, callback));
  		};
  
  		Syn.config = opts;
  
  	bind = function( el, ev, f ) {
  		return el.addEventListener ? el.addEventListener(ev, f, false) : el.attachEvent("on" + ev, f);
  	};
  	unbind = function( el, ev, f ) {
  		return el.addEventListener ? el.removeEventListener(ev, f, false) : el.detachEvent("on" + ev, f);
  	};
  
  	/**
  	 * @Static
  	 */
  	extend(Syn, {
  		/**
  		 * Creates a new synthetic event instance
  		 * @hide
  		 * @param {Object} type
  		 * @param {Object} options
  		 * @param {Object} element
  		 * @param {Object} callback
  		 */
  		init: function( type, options, element, callback ) {
  			var args = Syn.args(options, element, callback),
  				self = this;
  			this.queue = [];
  			this.element = args.element;
  
  			//run event
  			if ( typeof this[type] === "function" ) {
  				this[type](args.options, args.element, function( defaults, el ) {
  					args.callback && args.callback.apply(self, arguments);
  					self.done.apply(self, arguments);
  				});
  			} else {
  				this.result = Syn.trigger(type, args.options, args.element);
  				args.callback && args.callback.call(this, args.element, this.result);
  			}
  		},
  		jquery: function( el, fast ) {
  			if ( window.FuncUnit && window.FuncUnit.jQuery ) {
  				return window.FuncUnit.jQuery;
  			}
  			if ( el ) {
  				return Syn.helpers.getWindow(el).jQuery || window.jQuery;
  			}
  			else {
  				return window.jQuery;
  			}
  		},
  		/**
  		 * Returns an object with the args for a Syn.
  		 * @hide
  		 * @return {Object}
  		 */
  		args: function() {
  			var res = {},
  				i = 0;
  			for ( ; i < arguments.length; i++ ) {
  				if ( typeof arguments[i] === 'function' ) {
  					res.callback = arguments[i];
  				} else if ( arguments[i] && arguments[i].jquery ) {
  					res.element = arguments[i][0];
  				} else if ( arguments[i] && arguments[i].nodeName ) {
  					res.element = arguments[i];
  				} else if ( res.options && typeof arguments[i] === 'string' ) { //we can get by id
  					res.element = document.getElementById(arguments[i]);
  				}
  				else if ( arguments[i] ) {
  					res.options = arguments[i];
  				}
  			}
  			return res;
  		},
  		click: function( options, element, callback ) {
  			Syn('click!', options, element, callback);
  		},
  		/**
  		 * @attribute defaults
  		 * Default actions for events.  Each default function is called with this as its 
  		 * element.  It should return true if a timeout 
  		 * should happen after it.  If it returns an element, a timeout will happen
  		 * and the next event will happen on that element.
  		 */
  		defaults: {
  			focus: function() {
  				if (!Syn.support.focusChanges ) {
  					var element = this,
  						nodeName = element.nodeName.toLowerCase();
  					Syn.data(element, "syntheticvalue", element.value);
  
  					//TODO, this should be textarea too
  					//and this might be for only text style inputs ... hmmmmm ....
  					if ( nodeName === "input" || nodeName === "textarea" ) {
  						bind(element, "blur", function() {
  							if ( Syn.data(element, "syntheticvalue") != element.value ) {
  
  								Syn.trigger("change", {}, element);
  							}
  							unbind(element, "blur", arguments.callee);
  						});
  
  					}
  				}
  			},
  			submit: function() {
  				Syn.onParents(this, function( el ) {
  					if ( el.nodeName.toLowerCase() === 'form' ) {
  						el.submit();
  						return false;
  					}
  				});
  			}
  		},
  		changeOnBlur: function( element, prop, value ) {
  
  			bind(element, "blur", function() {
  				if ( value !== element[prop] ) {
  					Syn.trigger("change", {}, element);
  				}
  				unbind(element, "blur", arguments.callee);
  			});
  
  		},
  		/**
  		 * Returns the closest element of a particular type.
  		 * @hide
  		 * @param {Object} el
  		 * @param {Object} type
  		 */
  		closest: function( el, type ) {
  			while ( el && el.nodeName.toLowerCase() !== type.toLowerCase() ) {
  				el = el.parentNode;
  			}
  			return el;
  		},
  		/**
  		 * adds jQuery like data (adds an expando) and data exists FOREVER :)
  		 * @hide
  		 * @param {Object} el
  		 * @param {Object} key
  		 * @param {Object} value
  		 */
  		data: function( el, key, value ) {
  			var d;
  			if (!el[expando] ) {
  				el[expando] = id++;
  			}
  			if (!data[el[expando]] ) {
  				data[el[expando]] = {};
  			}
  			d = data[el[expando]];
  			if ( value ) {
  				data[el[expando]][key] = value;
  			} else {
  				return data[el[expando]][key];
  			}
  		},
  		/**
  		 * Calls a function on the element and all parents of the element until the function returns
  		 * false.
  		 * @hide
  		 * @param {Object} el
  		 * @param {Object} func
  		 */
  		onParents: function( el, func ) {
  			var res;
  			while ( el && res !== false ) {
  				res = func(el);
  				el = el.parentNode;
  			}
  			return el;
  		},
  		//regex to match focusable elements
  		focusable: /^(a|area|frame|iframe|label|input|select|textarea|button|html|object)$/i,
  		/**
  		 * Returns if an element is focusable
  		 * @hide
  		 * @param {Object} elem
  		 */
  		isFocusable: function( elem ) {
  			var attributeNode;
  
  			// IE8 Standards doesn't like this on some elements
  			if(elem.getAttributeNode){
  				attributeNode = elem.getAttributeNode("tabIndex")
  			}
  
  			return this.focusable.test(elem.nodeName) || 
  				   (attributeNode && attributeNode.specified) && 
  				    Syn.isVisible(elem);
  		},
  		/**
  		 * Returns if an element is visible or not
  		 * @hide
  		 * @param {Object} elem
  		 */
  		isVisible: function( elem ) {
  			return (elem.offsetWidth && elem.offsetHeight) || (elem.clientWidth && elem.clientHeight);
  		},
  		/**
  		 * Gets the tabIndex as a number or null
  		 * @hide
  		 * @param {Object} elem
  		 */
  		tabIndex: function( elem ) {
  			var attributeNode = elem.getAttributeNode("tabIndex");
  			return attributeNode && attributeNode.specified && (parseInt(elem.getAttribute('tabIndex')) || 0);
  		},
  		bind: bind,
  		unbind: unbind,
  		browser: browser,
  		//some generic helpers
  		helpers: {
  			createEventObject: createEventObject,
  			createBasicStandardEvent: function( type, defaults, doc ) {
  				var event;
  				try {
  					event = doc.createEvent("Events");
  				} catch (e2) {
  					event = doc.createEvent("UIEvents");
  				} finally {
  					event.initEvent(type, true, true);
  					extend(event, defaults);
  				}
  				return event;
  			},
  			inArray: function( item, array ) {
  				var i =0;
  				for ( ; i < array.length; i++ ) {
  					if ( array[i] === item ) {
  						return i;
  					}
  				}
  				return -1;
  			},
  			getWindow: function( element ) {
  				if(element.ownerDocument){
  					return element.ownerDocument.defaultView || element.ownerDocument.parentWindow;
  				}
  			},
  			extend: extend,
  			scrollOffset: function( win , set) {
  				var doc = win.document.documentElement,
  					body = win.document.body;
  				if(set){
  					window.scrollTo(set.left, set.top);
  					
  				} else { 
  					return {
  						left: (doc && doc.scrollLeft || body && body.scrollLeft || 0) + (doc.clientLeft || 0),
  						top: (doc && doc.scrollTop || body && body.scrollTop || 0) + (doc.clientTop || 0)
  					};
  				}
  				
  			},
  			scrollDimensions: function(win){
  				var doc = win.document.documentElement,
  					body = win.document.body,
  					docWidth = doc.clientWidth,
  					docHeight = doc.clientHeight,
  					compat = win.document.compatMode === "CSS1Compat";
  				
  				return {
  					height: compat && docHeight ||
  						body.clientHeight || docHeight,
  					width: compat && docWidth ||
  						body.clientWidth || docWidth
  				};
  			},
  			addOffset: function( options, el ) {
  				var jq = Syn.jquery(el),
  					off;
  				if ( typeof options === 'object' && options.clientX === undefined && options.clientY === undefined && options.pageX === undefined && options.pageY === undefined && jq ) {
  					el = jq(el);
  					off = el.offset();
  					options.pageX = off.left + el.width() / 2;
  					options.pageY = off.top + el.height() / 2;
  				}
  			}
  		},
  		// place for key data
  		key: {
  			ctrlKey: null,
  			altKey: null,
  			shiftKey: null,
  			metaKey: null
  		},
  		//triggers an event on an element, returns true if default events should be run
  		/**
  		 * Dispatches an event and returns true if default events should be run.
  		 * @hide
  		 * @param {Object} event
  		 * @param {Object} element
  		 * @param {Object} type
  		 * @param {Object} autoPrevent
  		 */
  		dispatch: function( event, element, type, autoPrevent ) {
  
  			// dispatchEvent doesn't always work in IE (mostly in a popup)
  			if ( element.dispatchEvent && event ) {
  				var preventDefault = event.preventDefault,
  					prevents = autoPrevent ? -1 : 0;
  
  				//automatically prevents the default behavior for this event
  				//this is to protect agianst nasty browser freezing bug in safari
  				if ( autoPrevent ) {
  					bind(element, type, function( ev ) {
  						ev.preventDefault();
  						unbind(this, type, arguments.callee);
  					});
  				}
  
  
  				event.preventDefault = function() {
  					prevents++;
  					if (++prevents > 0 ) {
  						preventDefault.apply(this, []);
  					}
  				};
  				element.dispatchEvent(event);
  				return prevents <= 0;
  			} else {
  				try {
  					window.event = event;
  				} catch (e) {}
  				//source element makes sure element is still in the document
  				return element.sourceIndex <= 0 || (element.fireEvent && element.fireEvent('on' + type, event));
  			}
  		},
  		/**
  		 * @attribute
  		 * @hide
  		 * An object of eventType -> function that create that event.
  		 */
  		create: {
  			//-------- PAGE EVENTS ---------------------
  			page: {
  				event: function( type, options, element ) {
  					var doc = Syn.helpers.getWindow(element).document || document,
  						event;
  					if ( doc.createEvent ) {
  						event = doc.createEvent("Events");
  
  						event.initEvent(type, true, true);
  						return event;
  					}
  					else {
  						try {
  							event = createEventObject(type, options, element);
  						}
  						catch (e) {}
  						return event;
  					}
  				}
  			},
  			// unique events
  			focus: {
  				event: function( type, options, element ) {
  					Syn.onParents(element, function( el ) {
  						if ( Syn.isFocusable(el) ) {
  							if ( el.nodeName.toLowerCase() !== 'html' ) {
  								el.focus();
  								activeElement = el;
  							}
  							else if ( activeElement ) {
  								// TODO: The HTML element isn't focasable in IE, but it is
  								// in FF.  We should detect this and do a true focus instead
  								// of just a blur
  								var doc = Syn.helpers.getWindow(element).document;
  								if ( doc !== window.document ) {
  									return false;
  								} else if ( doc.activeElement ) {
  									doc.activeElement.blur();
  									activeElement = null;
  								} else {
  									activeElement.blur();
  									activeElement = null;
  								}
  
  
  							}
  							return false;
  						}
  					});
  					return true;
  				}
  			}
  		},
  		/**
  		 * @attribute support
  		 * 
  		 * Feature detected properties of a browser's event system.
  		 * Support has the following properties:
  		 * 
  		 *   - `backspaceWorks` - typing a backspace removes a character
  		 *   - `clickChanges` - clicking on an option element creates a change event.
  		 *   - `clickSubmits` - clicking on a form button submits the form.
  		 *   - `focusChanges` - focus/blur creates a change event.
  		 *   - `keypressOnAnchorClicks` - Keying enter on an anchor triggers a click.
  		 *   - `keypressSubmits` - enter key submits
  		 *   - `keyCharacters` - typing a character shows up
  		 *   - `keysOnNotFocused` - enters keys when not focused.
  		 *   - `linkHrefJS` - An achor's href JavaScript is run.
  		 *   - `mouseDownUpClicks` - A mousedown followed by mouseup creates a click event.
  		 *   - `mouseupSubmits` - a mouseup on a form button submits the form.
  		 *   - `radioClickChanges` - clicking a radio button changes the radio.
  		 *   - `tabKeyTabs` - A tab key changes tabs.
  		 *   - `textareaCarriage` - a new line in a textarea creates a carriage return.
  		 *   
  		 * 
  		 */
  		support: {
  			clickChanges: false,
  			clickSubmits: false,
  			keypressSubmits: false,
  			mouseupSubmits: false,
  			radioClickChanges: false,
  			focusChanges: false,
  			linkHrefJS: false,
  			keyCharacters: false,
  			backspaceWorks: false,
  			mouseDownUpClicks: false,
  			tabKeyTabs: false,
  			keypressOnAnchorClicks: false,
  			optionClickBubbles: false,
  			ready: 0
  		},
  		/**
  		 * Creates a synthetic event and dispatches it on the element.  
  		 * This will run any default actions for the element.
  		 * Typically you want to use Syn, but if you want the return value, use this.
  		 * @param {String} type
  		 * @param {Object} options
  		 * @param {HTMLElement} element
  		 * @return {Boolean} true if default events were run, false if otherwise.
  		 */
  		trigger: function( type, options, element ) {
  			options || (options = {});
  
  			var create = Syn.create,
  				setup = create[type] && create[type].setup,
  				kind = key.test(type) ? 'key' : (page.test(type) ? "page" : "mouse"),
  				createType = create[type] || {},
  				createKind = create[kind],
  				event, ret, autoPrevent, dispatchEl = element;
  
  			//any setup code?
  			Syn.support.ready === 2 && setup && setup(type, options, element);
  
  			autoPrevent = options._autoPrevent;
  			//get kind
  			delete options._autoPrevent;
  
  			if ( createType.event ) {
  				ret = createType.event(type, options, element);
  			} else {
  				//convert options
  				options = createKind.options ? createKind.options(type, options, element) : options;
  
  				if (!Syn.support.changeBubbles && /option/i.test(element.nodeName) ) {
  					dispatchEl = element.parentNode; //jQuery expects clicks on select
  				}
  
  				//create the event
  				event = createKind.event(type, options, dispatchEl);
  
  				//send the event
  				ret = Syn.dispatch(event, dispatchEl, type, autoPrevent);
  			}
  			
  			ret && Syn.support.ready === 2 && Syn.defaults[type] && Syn.defaults[type].call(element, options, autoPrevent);
  			return ret;
  		},
  		eventSupported: function( eventName ) {
  			var el = document.createElement("div");
  			eventName = "on" + eventName;
  
  			var isSupported = (eventName in el);
  			if (!isSupported ) {
  				el.setAttribute(eventName, "return;");
  				isSupported = typeof el[eventName] === "function";
  			}
  			el = null;
  
  			return isSupported;
  		}
  
  	});
  	/**
  	 * @Prototype
  	 */
  	extend(Syn.init.prototype, {
  		/**
  		 * @function then
  		 * <p>
  		 * Then is used to chain a sequence of actions to be run one after the other.
  		 * This is useful when many asynchronous actions need to be performed before some
  		 * final check needs to be made.
  		 * </p>
  		 * <p>The following clicks and types into the <code>id='age'</code> element and then checks that only numeric characters can be entered.</p>
  		 * <h3>Example</h3>
  		 * @codestart
  		 * Syn('click',{},'age')
  		 *   .then('type','I am 12',function(){
  		 *   equals($('#age').val(),"12")  
  		 * })
  		 * @codeend
  		 * If the element argument is undefined, then the last element is used.
  		 * 
  		 * @param {String} type The type of event or action to create: "_click", "_dblclick", "_drag", "_type".
  		 * @param {Object} options Optiosn to pass to the event.
  		 * @param {String|HTMLElement} [element] A element's id or an element.  If undefined, defaults to the previous element.
  		 * @param {Function} [callback] A function to callback after the action has run, but before any future chained actions are run.
  		 */
  		then: function( type, options, element, callback ) {
  			if ( Syn.autoDelay ) {
  				this.delay();
  			}
  			var args = Syn.args(options, element, callback),
  				self = this;
  
  
  			//if stack is empty run right away
  			//otherwise ... unshift it
  			this.queue.unshift(function( el, prevented ) {
  
  				if ( typeof this[type] === "function" ) {
  					this.element = args.element || el;
  					this[type](args.options, this.element, function( defaults, el ) {
  						args.callback && args.callback.apply(self, arguments);
  						self.done.apply(self, arguments);
  					});
  				} else {
  					this.result = Syn.trigger(type, args.options, args.element);
  					args.callback && args.callback.call(this, args.element, this.result);
  					return this;
  				}
  			})
  			return this;
  		},
  		/**
  		 * Delays the next command a set timeout.
  		 * @param {Number} [timeout]
  		 * @param {Function} [callback]
  		 */
  		delay: function( timeout, callback ) {
  			if ( typeof timeout === 'function' ) {
  				callback = timeout;
  				timeout = null;
  			}
  			timeout = timeout || 600;
  			var self = this;
  			this.queue.unshift(function() {
  				setTimeout(function() {
  					callback && callback.apply(self, [])
  					self.done.apply(self, arguments);
  				}, timeout);
  			});
  			return this;
  		},
  		done: function( defaults, el ) {
  			el && (this.element = el);
  			if ( this.queue.length ) {
  				this.queue.pop().call(this, this.element, defaults);
  			}
  
  		},
  		/**
  		 * @function click
  		 * Clicks an element by triggering a mousedown, 
  		 * mouseup, 
  		 * and a click event.
  		 * <h3>Example</h3>
  		 * @codestart
  		 * Syn.click({},'create',function(){
  		 *   //check something
  		 * })
  		 * @codeend
  		 * You can also provide the coordinates of the click.  
  		 * If jQuery is present, it will set clientX and clientY
  		 * for you.  Here's how to set it yourself:
  		 * @codestart
  		 * Syn.click(
  		 *     {clientX: 20, clientY: 100},
  		 *     'create',
  		 *     function(){
  		 *       //check something
  		 *     })
  		 * @codeend
  		 * You can also provide pageX and pageY and Syn will convert it for you.
  		 * @param {Object} options
  		 * @param {HTMLElement} element
  		 * @param {Function} callback
  		 */
  		"_click": function( options, element, callback, force ) {
  			Syn.helpers.addOffset(options, element);
  			Syn.trigger("mousedown", options, element);
  
  			//timeout is b/c IE is stupid and won't call focus handlers
  			setTimeout(function() {
  				Syn.trigger("mouseup", options, element);
  				if (!Syn.support.mouseDownUpClicks || force ) {
  					Syn.trigger("click", options, element);
  					callback(true);
  				} else {
  					//we still have to run the default (presumably)
  					Syn.create.click.setup('click', options, element);
  					Syn.defaults.click.call(element);
  					//must give time for callback
  					setTimeout(function() {
  						callback(true);
  					}, 1);
  				}
  
  			}, 1);
  		},
  		/**
  		 * Right clicks in browsers that support it (everyone but opera).
  		 * @param {Object} options
  		 * @param {Object} element
  		 * @param {Object} callback
  		 */
  		"_rightClick": function( options, element, callback ) {
  			Syn.helpers.addOffset(options, element);
  			var mouseopts = extend(extend({}, Syn.mouse.browser.right.mouseup), options);
  
  			Syn.trigger("mousedown", mouseopts, element);
  
  			//timeout is b/c IE is stupid and won't call focus handlers
  			setTimeout(function() {
  				Syn.trigger("mouseup", mouseopts, element);
  				if ( Syn.mouse.browser.right.contextmenu ) {
  					Syn.trigger("contextmenu", extend(extend({}, Syn.mouse.browser.right.contextmenu), options), element);
  				}
  				callback(true);
  			}, 1);
  		},
  		/**
  		 * @function dblclick
  		 * Dblclicks an element.  This runs two [Syn.prototype.click click] events followed by
  		 * a dblclick on the element.
  		 * <h3>Example</h3>
  		 * @codestart
  		 * Syn.dblclick({},'open')
  		 * @codeend
  		 * @param {Object} options
  		 * @param {HTMLElement} element
  		 * @param {Function} callback
  		 */
  		"_dblclick": function( options, element, callback ) {
  			Syn.helpers.addOffset(options, element);
  			var self = this;
  			this._click(options, element, function() {
  				setTimeout(function() {
  					self._click(options, element, function() {
  						Syn.trigger("dblclick", options, element);
  						callback(true);
  					}, true);
  				}, 2);
  
  			});
  		}
  	});
  
  	var actions = ["click", "dblclick", "move", "drag", "key", "type", 'rightClick'],
  		makeAction = function( name ) {
  			Syn[name] = function( options, element, callback ) {
  				return Syn("_" + name, options, element, callback);
  			};
  			Syn.init.prototype[name] = function( options, element, callback ) {
  				return this.then("_" + name, options, element, callback);
  			};
  		},
  		i = 0;
  
  	for ( ; i < actions.length; i++ ) {
  		makeAction(actions[i]);
  	}
  
  	
  
  	return Syn;
  })();
  
  // ## mouse.js
  var __m3 = (function(Syn) {
  //handles mosue events
  
  	var h = Syn.helpers,
  		getWin = h.getWindow;
  
  	Syn.mouse = {};
  	h.extend(Syn.defaults, {
  		mousedown: function( options ) {
  			Syn.trigger("focus", {}, this)
  		},
  		click: function() {
  			// prevents the access denied issue in IE if the click causes the element to be destroyed
  			var element = this, href, type, radioChanged, nodeName, scope;
  			try {
  				href = element.href;
  				type = element.type;
  				createChange = Syn.data(element, "createChange");
  				radioChanged = Syn.data(element, "radioChanged");
  				scope = getWin(element);
  				nodeName = element.nodeName.toLowerCase();
  			} catch (e) {
  				return;
  			}
  			//get old values
  			
  			//this code was for restoring the href attribute to prevent popup opening
  			//if ((href = Syn.data(element, "href"))) {
  			//	element.setAttribute('href', href)
  			//}
  
  			//run href javascript
  			if (!Syn.support.linkHrefJS && /^\s*javascript:/.test(href) ) {
  				//eval js
  				var code = href.replace(/^\s*javascript:/, "")
  
  				//try{
  				if ( code != "//" && code.indexOf("void(0)") == -1 ) {
  					if ( window.selenium ) {
  						eval("with(selenium.browserbot.getCurrentWindow()){" + code + "}")
  					} else {
  						eval("with(scope){" + code + "}")
  					}
  				}
  			}
  
  			//submit a form
  			if (!(Syn.support.clickSubmits) && (nodeName == "input" && type == "submit") || nodeName == 'button' ) {
  
  				var form = Syn.closest(element, "form");
  				if ( form ) {
  					Syn.trigger("submit", {}, form)
  				}
  
  			}
  			//follow a link, probably needs to check if in an a.
  			if ( nodeName == "a" && element.href && !/^\s*javascript:/.test(href) ) {
  				scope.location.href = href;
  
  			}
  
  			//change a checkbox
  			if ( nodeName == "input" && type == "checkbox" ) {
  
  				//if(!Syn.support.clickChecks && !Syn.support.changeChecks){
  				//	element.checked = !element.checked;
  				//}
  				if (!Syn.support.clickChanges ) {
  					Syn.trigger("change", {}, element);
  				}
  			}
  
  			//change a radio button
  			if ( nodeName == "input" && type == "radio" ) { // need to uncheck others if not checked
  				if ( radioChanged && !Syn.support.radioClickChanges ) {
  					Syn.trigger("change", {}, element);
  				}
  			}
  			// change options
  			if ( nodeName == "option" && createChange ) {
  				Syn.trigger("change", {}, element.parentNode); //does not bubble
  				Syn.data(element, "createChange", false)
  			}
  		}
  	})
  
  	//add create and setup behavior for mosue events
  	h.extend(Syn.create, {
  		mouse: {
  			options: function( type, options, element ) {
  				var doc = document.documentElement,
  					body = document.body,
  					center = [options.pageX || 0, options.pageY || 0],
  					//browser might not be loaded yet (doing support code)
  					left = Syn.mouse.browser && Syn.mouse.browser.left[type],
  					right = Syn.mouse.browser && Syn.mouse.browser.right[type];
  				return h.extend({
  					bubbles: true,
  					cancelable: true,
  					view: window,
  					detail: 1,
  					screenX: 1,
  					screenY: 1,
  					clientX: options.clientX || center[0] - (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0),
  					clientY: options.clientY || center[1] - (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0),
  					ctrlKey: !! Syn.key.ctrlKey,
  					altKey: !! Syn.key.altKey,
  					shiftKey: !! Syn.key.shiftKey,
  					metaKey: !! Syn.key.metaKey,
  					button: left && left.button != null ? left.button : right && right.button || (type == 'contextmenu' ? 2 : 0),
  					relatedTarget: document.documentElement
  				}, options);
  			},
  			event: function( type, defaults, element ) { //Everyone Else
  				var doc = getWin(element).document || document
  				if ( doc.createEvent ) {
  					var event;
  
  					try {
  						event = doc.createEvent('MouseEvents');
  						event.initMouseEvent(type, defaults.bubbles, defaults.cancelable, defaults.view, defaults.detail, defaults.screenX, defaults.screenY, defaults.clientX, defaults.clientY, defaults.ctrlKey, defaults.altKey, defaults.shiftKey, defaults.metaKey, defaults.button, defaults.relatedTarget);
  					} catch (e) {
  						event = h.createBasicStandardEvent(type, defaults, doc)
  					}
  					event.synthetic = true;
  					return event;
  				} else {
  					var event;
  					try {
  						event = h.createEventObject(type, defaults, element)
  					}
  					catch (e) {}
  
  					return event;
  				}
  
  			}
  		},
  		click: {
  			setup: function( type, options, element ) {
  				var nodeName = element.nodeName.toLowerCase(),
  					type;
  
  				//we need to manually 'check' in browser that can't check
  				//so checked has the right value
  				if (!Syn.support.clickChecks && !Syn.support.changeChecks && nodeName === "input" ) {
  					type = element.type.toLowerCase(); //pretty sure lowercase isn't needed
  					if ( type === 'checkbox' ) {
  						element.checked = !element.checked;
  					}
  					if ( type === "radio" ) {
  						//do the checks manually 
  						if (!element.checked ) { //do nothing, no change
  							try {
  								Syn.data(element, "radioChanged", true);
  							} catch (e) {}
  							element.checked = true;
  						}
  					}
  				}
  
  				if ( nodeName == "a" && element.href && !/^\s*javascript:/.test(element.href) ) {
  
  					//save href
  					Syn.data(element, "href", element.href)
  
  					//remove b/c safari/opera will open a new tab instead of changing the page
  					// this has been removed because newer versions don't have this problem
  					//element.setAttribute('href', 'javascript://')
  					//however this breaks scripts using the href
  					//we need to listen to this and prevent the default behavior
  					//and run the default behavior ourselves. Boo!
  				}
  				//if select or option, save old value and mark to change
  				if (/option/i.test(element.nodeName) ) {
  					var child = element.parentNode.firstChild,
  						i = -1;
  					while ( child ) {
  						if ( child.nodeType == 1 ) {
  							i++;
  							if ( child == element ) break;
  						}
  						child = child.nextSibling;
  					}
  					if ( i !== element.parentNode.selectedIndex ) {
  						//shouldn't this wait on triggering
  						//change?
  						element.parentNode.selectedIndex = i;
  						Syn.data(element, "createChange", true)
  					}
  				}
  
  			}
  		},
  		mousedown: {
  			setup: function( type, options, element ) {
  				var nn = element.nodeName.toLowerCase();
  				//we have to auto prevent default to prevent freezing error in safari
  				if ( Syn.browser.safari && (nn == "select" || nn == "option") ) {
  					options._autoPrevent = true;
  				}
  			}
  		}
  	});
  	//do support code
  	(function() {
  		if (!document.body ) {
  			setTimeout(arguments.callee, 1)
  			return;
  		}
  		var oldSynth = window.__synthTest;
  		window.__synthTest = function() {
  			Syn.support.linkHrefJS = true;
  		}
  		var div = document.createElement("div"),
  			checkbox, submit, form, input, select;
  
  		div.innerHTML = "<form id='outer'>" + "<input name='checkbox' type='checkbox'/>" + "<input name='radio' type='radio' />" + "<input type='submit' name='submitter'/>" + "<input type='input' name='inputter'/>" + "<input name='one'>" + "<input name='two'/>" + "<a href='javascript:__synthTest()' id='synlink'></a>" + "<select><option></option></select>" + "</form>";
  		document.documentElement.appendChild(div);
  		form = div.firstChild
  		checkbox = form.childNodes[0];
  		submit = form.childNodes[2];
  		select = form.getElementsByTagName('select')[0]
  
  		checkbox.checked = false;
  		checkbox.onchange = function() {
  			Syn.support.clickChanges = true;
  		}
  
  		Syn.trigger("click", {}, checkbox)
  		Syn.support.clickChecks = checkbox.checked;
  
  		checkbox.checked = false;
  
  		Syn.trigger("change", {}, checkbox);
  
  		Syn.support.changeChecks = checkbox.checked;
  
  		form.onsubmit = function( ev ) {
  			if ( ev.preventDefault ) ev.preventDefault();
  			Syn.support.clickSubmits = true;
  			return false;
  		}
  		Syn.trigger("click", {}, submit)
  
  
  
  		form.childNodes[1].onchange = function() {
  			Syn.support.radioClickChanges = true;
  		}
  		Syn.trigger("click", {}, form.childNodes[1])
  
  
  		Syn.bind(div, 'click', function() {
  			Syn.support.optionClickBubbles = true;
  			Syn.unbind(div, 'click', arguments.callee)
  		})
  		Syn.trigger("click", {}, select.firstChild)
  
  
  		Syn.support.changeBubbles = Syn.eventSupported('change');
  
  		//test if mousedown followed by mouseup causes click (opera), make sure there are no clicks after this
  		var clicksCount = 0
  		div.onclick = function() {
  			Syn.support.mouseDownUpClicks = true;
  			//we should use this to check for opera potentially, but would
  			//be difficult to remove element correctly
  			//Syn.support.mouseDownUpRepeatClicks = (2 == (++clicksCount))
  		}
  		Syn.trigger("mousedown", {}, div)
  		Syn.trigger("mouseup", {}, div)
  
  		//setTimeout(function(){
  		//	Syn.trigger("mousedown",{},div)
  		//	Syn.trigger("mouseup",{},div)
  		//},1)
  
  		document.documentElement.removeChild(div);
  
  		//check stuff
  		window.__synthTest = oldSynth;
  		Syn.support.ready++;
  	})();
  	return Syn;
  })(__m2);
  
  // ## browsers.js
  var __m4 = (function(Syn) {
  	Syn.key.browsers = {
  		webkit : {
  			'prevent':
  			 {"keyup":[],"keydown":["char","keypress"],"keypress":["char"]},
  			'character':
  			 {"keydown":[0,"key"],"keypress":["char","char"],"keyup":[0,"key"]},
  			'specialChars':
  			 {"keydown":[0,"char"],"keyup":[0,"char"]},
  			'navigation':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'special':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'tab':
  			 {"keydown":[0,"char"],"keyup":[0,"char"]},
  			'pause-break':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'caps':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'escape':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'num-lock':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'scroll-lock':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'print':
  			 {"keyup":[0,"key"]},
  			'function':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'\r':
  			 {"keydown":[0,"key"],"keypress":["char","key"],"keyup":[0,"key"]}
  		},
  		gecko : {
  			'prevent':
  			 {"keyup":[],"keydown":["char"],"keypress":["char"]},
  			'character':
  			 {"keydown":[0,"key"],"keypress":["char",0],"keyup":[0,"key"]},
  			'specialChars':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]},
  			'navigation':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]},
  			'special':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'\t':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]},
  			'pause-break':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]},
  			'caps':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'escape':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]},
  			'num-lock':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'scroll-lock':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'print':
  			 {"keyup":[0,"key"]},
  			'function':
  			 {"keydown":[0,"key"],"keyup":[0,"key"]},
  			'\r':
  			 {"keydown":[0,"key"],"keypress":[0,"key"],"keyup":[0,"key"]}
  		},
  		msie : {
  			'prevent':{"keyup":[],"keydown":["char","keypress"],"keypress":["char"]},
  			'character':{"keydown":[null,"key"],"keypress":[null,"char"],"keyup":[null,"key"]},
  			'specialChars':{"keydown":[null,"char"],"keyup":[null,"char"]},
  			'navigation':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'special':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'tab':{"keydown":[null,"char"],"keyup":[null,"char"]},
  			'pause-break':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'caps':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'escape':{"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]},
  			'num-lock':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'scroll-lock':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'print':{"keyup":[null,"key"]},
  			'function':{"keydown":[null,"key"],"keyup":[null,"key"]},
  			'\r':{"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]}	
  		},
  		opera : {
  			'prevent':
  			 {"keyup":[],"keydown":[],"keypress":["char"]},
  			'character':
  			 {"keydown":[null,"key"],"keypress":[null,"char"],"keyup":[null,"key"]},
  			'specialChars':
  			 {"keydown":[null,"char"],"keypress":[null,"char"],"keyup":[null,"char"]},
  			'navigation':
  			 {"keydown":[null,"key"],"keypress":[null,"key"]},
  			'special':
  			 {"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]},
  			'tab':
  			 {"keydown":[null,"char"],"keypress":[null,"char"],"keyup":[null,"char"]},
  			'pause-break':
  			 {"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]},
  			'caps':
  			 {"keydown":[null,"key"],"keyup":[null,"key"]},
  			'escape':
  			 {"keydown":[null,"key"],"keypress":[null,"key"]},
  			'num-lock':
  			 {"keyup":[null,"key"],"keydown":[null,"key"],"keypress":[null,"key"]},
  			'scroll-lock':
  			 {"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]},
  			'print':
  			 {},
  			'function':
  			 {"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]},
  			'\r':
  			 {"keydown":[null,"key"],"keypress":[null,"key"],"keyup":[null,"key"]}	
  		}
  	};
  	
  	Syn.mouse.browsers = {
  		webkit : {"right":{"mousedown":{"button":2,"which":3},"mouseup":{"button":2,"which":3},"contextmenu":{"button":2,"which":3}},
  		          "left":{"mousedown":{"button":0,"which":1},"mouseup":{"button":0,"which":1},"click":{"button":0,"which":1}}},
  		opera: {"right":{"mousedown":{"button":2,"which":3},"mouseup":{"button":2,"which":3}},
  		        "left":{"mousedown":{"button":0,"which":1},"mouseup":{"button":0,"which":1},"click":{"button":0,"which":1}}},
  		msie: {	"right":{"mousedown":{"button":2},"mouseup":{"button":2},"contextmenu":{"button":0}},
  				"left":{"mousedown":{"button":1},"mouseup":{"button":1},"click":{"button":0}}},
  		chrome : {"right":{"mousedown":{"button":2,"which":3},"mouseup":{"button":2,"which":3},"contextmenu":{"button":2,"which":3}},
  				  "left":{"mousedown":{"button":0,"which":1},"mouseup":{"button":0,"which":1},"click":{"button":0,"which":1}}},
  		gecko: {"left":{"mousedown":{"button":0,"which":1},"mouseup":{"button":0,"which":1},"click":{"button":0,"which":1}},
  		        "right":{"mousedown":{"button":2,"which":3},"mouseup":{"button":2,"which":3},"contextmenu":{"button":2,"which":3}}}
  	}
  	
  	//set browser
  	Syn.key.browser = 
  	(function(){
  		if(Syn.key.browsers[window.navigator.userAgent]){
  			return Syn.key.browsers[window.navigator.userAgent];
  		}
  		for(var browser in Syn.browser){
  			if(Syn.browser[browser] && Syn.key.browsers[browser]){
  				return Syn.key.browsers[browser]
  			}
  		}
  		return Syn.key.browsers.gecko;
  	})();
  	
  	Syn.mouse.browser = 
  	(function(){
  		if(Syn.mouse.browsers[window.navigator.userAgent]){
  			return Syn.mouse.browsers[window.navigator.userAgent];
  		}
  		for(var browser in Syn.browser){
  			if(Syn.browser[browser] && Syn.mouse.browsers[browser]){
  				return Syn.mouse.browsers[browser]
  			}
  		}
  		return Syn.mouse.browsers.gecko;
  	})();
  	return Syn;
  })(__m2, __m3);
  
  // ## key.js
  var __m5 = (function(Syn) {
  	var h = Syn.helpers,
  
  		// gets the selection of an input or textarea
  		getSelection = function( el ) {
  			// use selectionStart if we can
  			if ( el.selectionStart !== undefined ) {
  				// this is for opera, so we don't have to focus to type how we think we would
  				if ( document.activeElement && document.activeElement != el && el.selectionStart == el.selectionEnd && el.selectionStart == 0 ) {
  					return {
  						start: el.value.length,
  						end: el.value.length
  					};
  				}
  				return {
  					start: el.selectionStart,
  					end: el.selectionEnd
  				}
  			} else {
  				//check if we aren't focused
  				try {
  					//try 2 different methods that work differently (IE breaks depending on type)
  					if ( el.nodeName.toLowerCase() == 'input' ) {
  						var real = h.getWindow(el).document.selection.createRange(),
  							r = el.createTextRange();
  						r.setEndPoint("EndToStart", real);
  
  						var start = r.text.length
  						return {
  							start: start,
  							end: start + real.text.length
  						}
  					}
  					else {
  						var real = h.getWindow(el).document.selection.createRange(),
  							r = real.duplicate(),
  							r2 = real.duplicate(),
  							r3 = real.duplicate();
  						r2.collapse();
  						r3.collapse(false);
  						r2.moveStart('character', -1)
  						r3.moveStart('character', -1)
  						//select all of our element
  						r.moveToElementText(el)
  						//now move our endpoint to the end of our real range
  						r.setEndPoint('EndToEnd', real);
  						var start = r.text.length - real.text.length,
  							end = r.text.length;
  						if ( start != 0 && r2.text == "" ) {
  							start += 2;
  						}
  						if ( end != 0 && r3.text == "" ) {
  							end += 2;
  						}
  						//if we aren't at the start, but previous is empty, we are at start of newline
  						return {
  							start: start,
  							end: end
  						}
  					}
  				} catch (e) {
  					return {
  						start: el.value.length,
  						end: el.value.length
  					};
  				}
  			}
  		},
  		// gets all focusable elements
  		getFocusable = function( el ) {
  			var document = h.getWindow(el).document,
  				res = [];
  
  			var els = document.getElementsByTagName('*'),
  				len = els.length;
  
  			for ( var i = 0; i < len; i++ ) {
  				Syn.isFocusable(els[i]) && els[i] != document.documentElement && res.push(els[i])
  			}
  			return res;
  
  
  		};
  	/**
  	 * @add Syn static
  	 */
  	h.extend(Syn, {
  		/**
  		 * @attribute
  		 * A list of the keys and their keycodes codes you can type.
  		 * You can add type keys with
  		 * @codestart
  		 * Syn('key','delete','title');
  		 * 
  		 * //or 
  		 * 
  		 * Syn('type','One Two Three[left][left][delete]','title')
  		 * @codeend
  		 * 
  		 * The following are a list of keys you can type:
  		 * @codestart text
  		 * \b        - backspace
  		 * \t        - tab
  		 * \r        - enter
  		 * ' '       - space
  		 * a-Z 0-9   - normal characters
  		 * /!@#$*,.? - All other typeable characters
  		 * page-up   - scrolls up
  		 * page-down - scrolls down
  		 * end       - scrolls to bottom
  		 * home      - scrolls to top
  		 * insert    - changes how keys are entered
  		 * delete    - deletes the next character
  		 * left      - moves cursor left
  		 * right     - moves cursor right
  		 * up        - moves the cursor up
  		 * down      - moves the cursor down
  		 * f1-12     - function buttons
  		 * shift, ctrl, alt - special keys
  		 * pause-break      - the pause button
  		 * scroll-lock      - locks scrolling
  		 * caps      - makes caps
  		 * escape    - escape button
  		 * num-lock  - allows numbers on keypad
  		 * print     - screen capture
  		 * @codeend
  		 */
  		keycodes: {
  			//backspace
  			'\b': 8,
  
  			//tab
  			'\t': 9,
  
  			//enter
  			'\r': 13,
  
  			//special
  			'shift': 16,
  			'ctrl': 17,
  			'alt': 18,
  
  			//weird
  			'pause-break': 19,
  			'caps': 20,
  			'escape': 27,
  			'num-lock': 144,
  			'scroll-lock': 145,
  			'print': 44,
  
  			//navigation
  			'page-up': 33,
  			'page-down': 34,
  			'end': 35,
  			'home': 36,
  			'left': 37,
  			'up': 38,
  			'right': 39,
  			'down': 40,
  			'insert': 45,
  			'delete': 46,
  
  			//normal characters
  			' ': 32,
  			'0': 48,
  			'1': 49,
  			'2': 50,
  			'3': 51,
  			'4': 52,
  			'5': 53,
  			'6': 54,
  			'7': 55,
  			'8': 56,
  			'9': 57,
  			'a': 65,
  			'b': 66,
  			'c': 67,
  			'd': 68,
  			'e': 69,
  			'f': 70,
  			'g': 71,
  			'h': 72,
  			'i': 73,
  			'j': 74,
  			'k': 75,
  			'l': 76,
  			'm': 77,
  			'n': 78,
  			'o': 79,
  			'p': 80,
  			'q': 81,
  			'r': 82,
  			's': 83,
  			't': 84,
  			'u': 85,
  			'v': 86,
  			'w': 87,
  			'x': 88,
  			'y': 89,
  			'z': 90,
  			//normal-characters, numpad
  			'num0': 96,
  			'num1': 97,
  			'num2': 98,
  			'num3': 99,
  			'num4': 100,
  			'num5': 101,
  			'num6': 102,
  			'num7': 103,
  			'num8': 104,
  			'num9': 105,
  			'*': 106,
  			'+': 107,
  			'-': 109,
  			'.': 110,
  			//normal-characters, others
  			'/': 111,
  			';': 186,
  			'=': 187,
  			',': 188,
  			'-': 189,
  			'.': 190,
  			'/': 191,
  			'`': 192,
  			'[': 219,
  			'\\': 220,
  			']': 221,
  			"'": 222,
  
  			//ignore these, you shouldn't use them
  			'left window key': 91,
  			'right window key': 92,
  			'select key': 93,
  
  
  			'f1': 112,
  			'f2': 113,
  			'f3': 114,
  			'f4': 115,
  			'f5': 116,
  			'f6': 117,
  			'f7': 118,
  			'f8': 119,
  			'f9': 120,
  			'f10': 121,
  			'f11': 122,
  			'f12': 123
  		},
  
  		// what we can type in
  		typeable: /input|textarea/i,
  
  		// selects text on an element
  		selectText: function( el, start, end ) {
  			if ( el.setSelectionRange ) {
  				if (!end ) {
  					el.focus();
  					el.setSelectionRange(start, start);
  				} else {
  					el.selectionStart = start;
  					el.selectionEnd = end;
  				}
  			} else if ( el.createTextRange ) {
  				//el.focus();
  				var r = el.createTextRange();
  				r.moveStart('character', start);
  				end = end || start;
  				r.moveEnd('character', end - el.value.length);
  
  				r.select();
  			}
  		},
  		getText: function( el ) {
  			//first check if the el has anything selected ..
  			if ( Syn.typeable.test(el.nodeName) ) {
  				var sel = getSelection(el);
  				return el.value.substring(sel.start, sel.end)
  			}
  			//otherwise get from page
  			var win = Syn.helpers.getWindow(el);
  			if ( win.getSelection ) {
  				return win.getSelection().toString();
  			}
  			else if ( win.document.getSelection ) {
  				return win.document.getSelection().toString()
  			}
  			else {
  				return win.document.selection.createRange().text;
  			}
  		},
  		getSelection: getSelection
  	});
  
  	h.extend(Syn.key, {
  		// retrieves a description of what events for this character should look like
  		data: function( key ) {
  			//check if it is described directly
  			if ( Syn.key.browser[key] ) {
  				return Syn.key.browser[key];
  			}
  			for ( var kind in Syn.key.kinds ) {
  				if ( h.inArray(key, Syn.key.kinds[kind]) > -1 ) {
  					return Syn.key.browser[kind]
  				}
  			}
  			return Syn.key.browser.character
  		},
  
  		//returns the special key if special
  		isSpecial: function( keyCode ) {
  			var specials = Syn.key.kinds.special;
  			for ( var i = 0; i < specials.length; i++ ) {
  				if ( Syn.keycodes[specials[i]] == keyCode ) {
  					return specials[i];
  				}
  			}
  		},
  		/**
  		 * @hide
  		 * gets the options for a key and event type ...
  		 * @param {Object} key
  		 * @param {Object} event
  		 */
  		options: function( key, event ) {
  			var keyData = Syn.key.data(key);
  
  			if (!keyData[event] ) {
  				//we shouldn't be creating this event
  				return null;
  			}
  
  			var charCode = keyData[event][0],
  				keyCode = keyData[event][1],
  				result = {};
  
  			if ( keyCode == 'key' ) {
  				result.keyCode = Syn.keycodes[key]
  			} else if ( keyCode == 'char' ) {
  				result.keyCode = key.charCodeAt(0)
  			} else {
  				result.keyCode = keyCode;
  			}
  
  			if ( charCode == 'char' ) {
  				result.charCode = key.charCodeAt(0)
  			} else if ( charCode !== null ) {
  				result.charCode = charCode;
  			}
  
  			// all current browsers have which property to normalize keyCode/charCode
  			if(result.keyCode){
  				result.which = result.keyCode;
  			} else {
  				result.which = result.charCode;
  			}
  
  
  			return result
  		},
  		//types of event keys
  		kinds: {
  			special: ["shift", 'ctrl', 'alt', 'caps'],
  			specialChars: ["\b"],
  			navigation: ["page-up", 'page-down', 'end', 'home', 'left', 'up', 'right', 'down', 'insert', 'delete'],
  			'function': ['f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10', 'f11', 'f12']
  		},
  		//returns the default function
  		// some keys have default functions
  		// some 'kinds' of keys have default functions
  		getDefault: function( key ) {
  			//check if it is described directly
  			if ( Syn.key.defaults[key] ) {
  				return Syn.key.defaults[key];
  			}
  			for ( var kind in Syn.key.kinds ) {
  				if ( h.inArray(key, Syn.key.kinds[kind]) > -1 && Syn.key.defaults[kind] ) {
  					return Syn.key.defaults[kind];
  				}
  			}
  			return Syn.key.defaults.character
  		},
  		// default behavior when typing
  		defaults: {
  			'character': function( options, scope, key, force, sel ) {
  				if (/num\d+/.test(key) ) {
  					key = key.match(/\d+/)[0]
  				}
  
  				if ( force || (!Syn.support.keyCharacters && Syn.typeable.test(this.nodeName)) ) {
  					var current = this.value,
  						before = current.substr(0, sel.start),
  						after = current.substr(sel.end),
  						character = key;
  
  					this.value = before + character + after;
  					//handle IE inserting \r\n
  					var charLength = character == "\n" && Syn.support.textareaCarriage ? 2 : character.length;
  					Syn.selectText(this, before.length + charLength)
  				}
  			},
  			'c': function( options, scope, key, force, sel ) {
  				if ( Syn.key.ctrlKey ) {
  					Syn.key.clipboard = Syn.getText(this)
  				} else {
  					Syn.key.defaults.character.apply(this, arguments);
  				}
  			},
  			'v': function( options, scope, key, force, sel ) {
  				if ( Syn.key.ctrlKey ) {
  					Syn.key.defaults.character.call(this, options, scope, Syn.key.clipboard, true, sel);
  				} else {
  					Syn.key.defaults.character.apply(this, arguments);
  				}
  			},
  			'a': function( options, scope, key, force, sel ) {
  				if ( Syn.key.ctrlKey ) {
  					Syn.selectText(this, 0, this.value.length)
  				} else {
  					Syn.key.defaults.character.apply(this, arguments);
  				}
  			},
  			'home': function() {
  				Syn.onParents(this, function( el ) {
  					if ( el.scrollHeight != el.clientHeight ) {
  						el.scrollTop = 0;
  						return false;
  					}
  				})
  			},
  			'end': function() {
  				Syn.onParents(this, function( el ) {
  					if ( el.scrollHeight != el.clientHeight ) {
  						el.scrollTop = el.scrollHeight;
  						return false;
  					}
  				})
  			},
  			'page-down': function() {
  				//find the first parent we can scroll
  				Syn.onParents(this, function( el ) {
  					if ( el.scrollHeight != el.clientHeight ) {
  						var ch = el.clientHeight
  						el.scrollTop += ch;
  						return false;
  					}
  				})
  			},
  			'page-up': function() {
  				Syn.onParents(this, function( el ) {
  					if ( el.scrollHeight != el.clientHeight ) {
  						var ch = el.clientHeight
  						el.scrollTop -= ch;
  						return false;
  					}
  				})
  			},
  			'\b': function( options, scope, key, force, sel ) {
  				//this assumes we are deleting from the end
  				if (!Syn.support.backspaceWorks && Syn.typeable.test(this.nodeName) ) {
  					var current = this.value,
  						before = current.substr(0, sel.start),
  						after = current.substr(sel.end);
  
  					if ( sel.start == sel.end && sel.start > 0 ) {
  						//remove a character
  						this.value = before.substring(0, before.length - 1) + after
  						Syn.selectText(this, sel.start - 1)
  					} else {
  						this.value = before + after;
  						Syn.selectText(this, sel.start)
  					}
  
  					//set back the selection
  				}
  			},
  			'delete': function( options, scope, key, force, sel ) {
  				if (!Syn.support.backspaceWorks && Syn.typeable.test(this.nodeName) ) {
  					var current = this.value,
  						before = current.substr(0, sel.start),
  						after = current.substr(sel.end);
  					if ( sel.start == sel.end && sel.start <= this.value.length - 1 ) {
  						this.value = before + after.substring(1)
  					} else {
  						this.value = before + after;
  
  					}
  					Syn.selectText(this, sel.start)
  				}
  			},
  			'\r': function( options, scope, key, force, sel ) {
  
  				var nodeName = this.nodeName.toLowerCase()
  				// submit a form
  				if (nodeName == 'input' ) {
  					Syn.trigger("change", {}, this);
  				}
  				
  				if (!Syn.support.keypressSubmits && nodeName == 'input' ) {
  					var form = Syn.closest(this, "form");
  					if ( form ) {
  						Syn.trigger("submit", {}, form);
  					}
  
  				}
  				//newline in textarea
  				if (!Syn.support.keyCharacters && nodeName == 'textarea' ) {
  					Syn.key.defaults.character.call(this, options, scope, "\n", undefined, sel)
  				}
  				// 'click' hyperlinks
  				if (!Syn.support.keypressOnAnchorClicks && nodeName == 'a' ) {
  					Syn.trigger("click", {}, this);
  				}
  			},
  			// 
  			// Gets all focusable elements.  If the element (this)
  			// doesn't have a tabindex, finds the next element after.
  			// If the element (this) has a tabindex finds the element 
  			// with the next higher tabindex OR the element with the same
  			// tabindex after it in the document.
  			// @return the next element
  			// 
  			'\t': function( options, scope ) {
  				// focusable elements
  				var focusEls = getFocusable(this),
  					// the current element's tabindex
  					tabIndex = Syn.tabIndex(this),
  					// will be set to our guess for the next element
  					current = null,
  					// the next index we care about
  					currentIndex = 1000000000,
  					// set to true once we found 'this' element
  					found = false,
  					i = 0,
  					el,
  					//the tabindex of the tabable element we are looking at
  					elIndex, firstNotIndexed, prev;
  				orders = [];
  				for (; i < focusEls.length; i++ ) {
  					orders.push([focusEls[i], i]);
  				}
  				var sort = function( order1, order2 ) {
  					var el1 = order1[0],
  						el2 = order2[0],
  						tab1 = Syn.tabIndex(el1) || 0,
  						tab2 = Syn.tabIndex(el2) || 0;
  					if ( tab1 == tab2 ) {
  						return order1[1] - order2[1]
  					} else {
  						if ( tab1 == 0 ) {
  							return 1;
  						} else if ( tab2 == 0 ) {
  							return -1;
  						} else {
  							return tab1 - tab2;
  						}
  					}
  				}
  				orders.sort(sort);
  				//now find current
  				for ( i = 0; i < orders.length; i++ ) {
  					el = orders[i][0];
  					if ( this == el ) {
  						if (!Syn.key.shiftKey ) {
  							current = orders[i + 1][0];
  							if (!current ) {
  								current = orders[0][0]
  							}
  						} else {
  							current = orders[i - 1][0];
  							if (!current ) {
  								current = orders[focusEls.length - 1][0]
  							}
  						}
  
  					}
  				}
  
  				//restart if we didn't find anything
  				if (!current ) {
  					current = firstNotIndexed;
  				}
  				current && current.focus();
  				return current;
  			},
  			'left': function( options, scope, key, force, sel ) {
  				if ( Syn.typeable.test(this.nodeName) ) {
  					if ( Syn.key.shiftKey ) {
  						Syn.selectText(this, sel.start == 0 ? 0 : sel.start - 1, sel.end)
  					} else {
  						Syn.selectText(this, sel.start == 0 ? 0 : sel.start - 1)
  					}
  				}
  			},
  			'right': function( options, scope, key, force, sel ) {
  				if ( Syn.typeable.test(this.nodeName) ) {
  					if ( Syn.key.shiftKey ) {
  						Syn.selectText(this, sel.start, sel.end + 1 > this.value.length ? this.value.length : sel.end + 1)
  					} else {
  						Syn.selectText(this, sel.end + 1 > this.value.length ? this.value.length : sel.end + 1)
  					}
  				}
  			},
  			'up': function() {
  				if (/select/i.test(this.nodeName) ) {
  
  					this.selectedIndex = this.selectedIndex ? this.selectedIndex - 1 : 0;
  					//set this to change on blur?
  				}
  			},
  			'down': function() {
  				if (/select/i.test(this.nodeName) ) {
  					Syn.changeOnBlur(this, "selectedIndex", this.selectedIndex)
  					this.selectedIndex = this.selectedIndex + 1;
  					//set this to change on blur?
  				}
  			},
  			'shift': function() {
  				return null;
  			},
  			'ctrl': function() {
  				return null;
  			}
  		}
  	});
  
  
  	h.extend(Syn.create, {
  		keydown: {
  			setup: function( type, options, element ) {
  				if ( h.inArray(options, Syn.key.kinds.special) != -1 ) {
  					Syn.key[options + "Key"] = element;
  				}
  			}
  		},
  		keypress: {
  			setup: function( type, options, element ) {
  				// if this browsers supports writing keys on events
  				// but doesn't write them if the element isn't focused
  				// focus on the element (ignored if already focused)
  				if ( Syn.support.keyCharacters && !Syn.support.keysOnNotFocused ) {
  					element.focus()
  				}
  			}
  		},
  		keyup: {
  			setup: function( type, options, element ) {
  				if ( h.inArray(options, Syn.key.kinds.special) != -1 ) {
  					Syn.key[options + "Key"] = null;
  				}
  			}
  		},
  		key: {
  			// return the options for a key event
  			options: function( type, options, element ) {
  				//check if options is character or has character
  				options = typeof options != "object" ? {
  					character: options
  				} : options;
  
  				//don't change the orignial
  				options = h.extend({}, options)
  				if ( options.character ) {
  					h.extend(options, Syn.key.options(options.character, type));
  					delete options.character;
  				}
  
  				options = h.extend({
  					ctrlKey: !! Syn.key.ctrlKey,
  					altKey: !! Syn.key.altKey,
  					shiftKey: !! Syn.key.shiftKey,
  					metaKey: !! Syn.key.metaKey
  				}, options)
  
  				return options;
  			},
  			// creates a key event
  			event: function( type, options, element ) { //Everyone Else
  				var doc = h.getWindow(element).document || document;
  				if ( doc.createEvent ) {
  					var event;
  
  					try {
  
  						event = doc.createEvent("KeyEvents");
  						event.initKeyEvent(type, true, true, window, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.keyCode, options.charCode);
  					}
  					catch (e) {
  						event = h.createBasicStandardEvent(type, options, doc);
  					}
  					event.synthetic = true;
  					return event;
  				}
  				else {
  					var event;
  					try {
  						event = h.createEventObject.apply(this, arguments);
  						h.extend(event, options)
  					}
  					catch (e) {}
  
  					return event;
  				}
  			}
  		}
  	});
  
  	var convert = {
  		"enter": "\r",
  		"backspace": "\b",
  		"tab": "\t",
  		"space": " "
  	}
  
  	/**
  	 * @add Syn prototype
  	 */
  	h.extend(Syn.init.prototype, {
  		/**
  		 * @function key
  		 * Types a single key.  The key should be
  		 * a string that matches a 
  		 * [Syn.static.keycodes].
  		 * 
  		 * The following sends a carridge return
  		 * to the 'name' element.
  		 * @codestart
  		 * Syn.key('\r','name')
  		 * @codeend
  		 * For each character, a keydown, keypress, and keyup is triggered if
  		 * appropriate.
  		 * @param {String} options
  		 * @param {HTMLElement} [element]
  		 * @param {Function} [callback]
  		 * @return {HTMLElement} the element currently focused.
  		 */
  		_key: function( options, element, callback ) {
  			//first check if it is a special up
  			if (/-up$/.test(options) && h.inArray(options.replace("-up", ""), Syn.key.kinds.special) != -1 ) {
  				Syn.trigger('keyup', options.replace("-up", ""), element)
  				callback(true, element);
  				return;
  			}
  
  			// keep reference to current activeElement
  			var activeElement = h.getWindow(element).document.activeElement,			
  				caret = Syn.typeable.test(element.nodeName) && getSelection(element),
  				key = convert[options] || options,
  				// should we run default events
  				runDefaults = Syn.trigger('keydown', key, element),
  
  				// a function that gets the default behavior for a key
  				getDefault = Syn.key.getDefault,
  
  				// how this browser handles preventing default events
  				prevent = Syn.key.browser.prevent,
  
  				// the result of the default event
  				defaultResult,
  				
  				keypressOptions = Syn.key.options(key, 'keypress');
  
  
  				if ( runDefaults ) {
  					//if the browser doesn't create keypresses for this key, run default
  					if (!keypressOptions ) {
  						defaultResult = getDefault(key).call(element, keypressOptions, h.getWindow(element), key, undefined, caret)
  					} else {
  						//do keypress
  						// check if activeElement changed b/c someone called focus in keydown
  						if( activeElement !== h.getWindow(element).document.activeElement ) {
  							element = h.getWindow(element).document.activeElement;
  						}
  						
  						runDefaults = Syn.trigger('keypress', keypressOptions, element)
  						if ( runDefaults ) {
  							defaultResult = getDefault(key).call(element, keypressOptions, h.getWindow(element), key, undefined, caret)
  						}
  					}
  				} else {
  					//canceled ... possibly don't run keypress
  					if ( keypressOptions && h.inArray('keypress', prevent.keydown) == -1 ) {
  						// check if activeElement changed b/c someone called focus in keydown
  						if( activeElement !== h.getWindow(element).document.activeElement ) {
  							element = h.getWindow(element).document.activeElement;
  						}
  						
  						Syn.trigger('keypress', keypressOptions, element)
  					}
  				}
  				if ( defaultResult && defaultResult.nodeName ) {
  					element = defaultResult
  				}
  
  				if ( defaultResult !== null ) {
  					setTimeout(function() {
  						Syn.trigger('keyup', Syn.key.options(key, 'keyup'), element)
  						callback(runDefaults, element)
  					}, 1)
  				} else {
  					callback(runDefaults, element)
  				}
  
  
  				//do mouseup
  				return element;
  			// is there a keypress? .. if not , run default
  			// yes -> did we prevent it?, if not run ...
  		},
  		/**
  		 * @function type
  		 * Types sequence of [Syn.key key actions].  Each
  		 * character is typed, one at a type.
  		 * Multi-character keys like 'left' should be
  		 * enclosed in square brackents.
  		 * 
  		 * The following types 'JavaScript MVC' then deletes the space.
  		 * @codestart
  		 * Syn.type('JavaScript MVC[left][left][left]\b','name')
  		 * @codeend
  		 * 
  		 * Type is able to handle (and move with) tabs (\t).  
  		 * The following simulates tabing and entering values in a form and 
  		 * eventually submitting the form.
  		 * @codestart
  		 * Syn.type("Justin\tMeyer\t27\tjustinbmeyer@gmail.com\r")
  		 * @codeend
  		 * @param {String} options the text to type
  		 * @param {HTMLElement} [element] an element or an id of an element
  		 * @param {Function} [callback] a function to callback
  		 */
  		_type: function( options, element, callback ) {
  			//break it up into parts ...
  			//go through each type and run
  			var parts = options.match(/(\[[^\]]+\])|([^\[])/g),
  				self = this,
  				runNextPart = function( runDefaults, el ) {
  					var part = parts.shift();
  					if (!part ) {
  						callback(runDefaults, el);
  						return;
  					}
  					el = el || element;
  					if ( part.length > 1 ) {
  						part = part.substr(1, part.length - 2)
  					}
  					self._key(part, el, runNextPart)
  				}
  
  				runNextPart();
  
  		}
  	});
  
  	if(!Syn.config.support) {
  		//do support code
  		!function() {
  			if (!document.body ) {
  				setTimeout(arguments.callee, 1)
  				return;
  			}
  
  			var div = document.createElement("div"),
  				checkbox, submit, form, input, submitted = false,
  				anchor, textarea, inputter;
  
  			div.innerHTML = "<form id='outer'>" + 
  							"<input name='checkbox' type='checkbox'/>" + 
  							"<input name='radio' type='radio' />" + 
  							"<input type='submit' name='submitter'/>" + 
  							"<input type='input' name='inputter'/>" + 
  							"<input name='one'>" + 
  							"<input name='two'/>" + 
  							"<a href='#abc'></a>" + 
  							"<textarea>1\n2</textarea>" +
  							"</form>";
  
  			document.documentElement.appendChild(div);
  			form = div.firstChild;
  			checkbox = form.childNodes[0];
  			submit = form.childNodes[2];
  			anchor = form.getElementsByTagName("a")[0];
  			textarea = form.getElementsByTagName("textarea")[0];
  			inputter = form.childNodes[3];
  
  			form.onsubmit = function( ev ) {
  				if ( ev.preventDefault ) ev.preventDefault();
  				Syn.support.keypressSubmits = true;
  				ev.returnValue = false;
  				return false;
  			};
  			// Firefox 4 won't write key events if the element isn't focused
  			inputter.focus();
  			Syn.trigger("keypress", "\r", inputter);
  
  
  			Syn.trigger("keypress", "a", inputter);
  			Syn.support.keyCharacters = inputter.value == "a";
  
  
  			inputter.value = "a";
  			Syn.trigger("keypress", "\b", inputter);
  			Syn.support.backspaceWorks = inputter.value == "";
  
  
  
  			inputter.onchange = function() {
  				Syn.support.focusChanges = true;
  			}
  			inputter.focus();
  			Syn.trigger("keypress", "a", inputter);
  			form.childNodes[5].focus(); // this will throw a change event
  			Syn.trigger("keypress", "b", inputter);
  			Syn.support.keysOnNotFocused = inputter.value == "ab";
  
  			//test keypress \r on anchor submits
  			Syn.bind(anchor, "click", function( ev ) {
  				if ( ev.preventDefault ) ev.preventDefault();
  				Syn.support.keypressOnAnchorClicks = true;
  				ev.returnValue = false;
  				return false;
  			})
  			Syn.trigger("keypress", "\r", anchor);
  
  			Syn.support.textareaCarriage = textarea.value.length == 4;
  			
  			document.documentElement.removeChild(div);
  
  			Syn.support.ready++;
  		}();
  	}
  	else {
  		Syn.helpers.extend(Syn.support, Syn.config.support);
  	}
  
  	return Syn;
  })(__m2, __m4);
  
  // ## drag/drag.js
  var __m6 = (function(Syn) {
  	
  	// check if elementFromPageExists
  	(function() {
  
  		// document body has to exists for this test
  		if (!document.body ) {
  			setTimeout(arguments.callee, 1)
  			return;
  		}
  		var div = document.createElement('div')
  		document.body.appendChild(div);
  		Syn.helpers.extend(div.style, {
  			width: "100px",
  			height: "10000px",
  			backgroundColor: "blue",
  			position: "absolute",
  			top: "10px",
  			left: "0px",
  			zIndex: 19999
  		});
  		document.body.scrollTop = 11;
  		if (!document.elementFromPoint ) {
  			return;
  		}
  		var el = document.elementFromPoint(3, 1)
  		if ( el == div ) {
  			Syn.support.elementFromClient = true;
  		}
  		else {
  			Syn.support.elementFromPage = true;
  		}
  		document.body.removeChild(div);
  		document.body.scrollTop = 0;
  	})();
  
  
  	//gets an element from a point
  	var elementFromPoint = function( point, element ) {
  		var clientX = point.clientX,
  			clientY = point.clientY,
  			win = Syn.helpers.getWindow(element),
  			el;
  
  
  
  		if ( Syn.support.elementFromPage ) {
  			var off = Syn.helpers.scrollOffset(win);
  			clientX = clientX + off.left; //convert to pageX
  			clientY = clientY + off.top; //convert to pageY
  		}
  		el = win.document.elementFromPoint ? win.document.elementFromPoint(clientX, clientY) : element;
  		if ( el === win.document.documentElement && (point.clientY < 0 || point.clientX < 0) ) {
  			return element;
  		} else {
  			return el;
  		}
  	},
  		//creates an event at a certain point
  		createEventAtPoint = function( event, point, element ) {
  			var el = elementFromPoint(point, element)
  			Syn.trigger(event, point, el || element)
  			return el;
  		},
  		// creates a mousemove event, but first triggering mouseout / mouseover if appropriate
  		mouseMove = function( point, element, last ) {
  			var el = elementFromPoint(point, element)
  			if ( last != el && el && last ) {
  				var options = Syn.helpers.extend({}, point);
  				options.relatedTarget = el;
  				Syn.trigger("mouseout", options, last);
  				options.relatedTarget = last;
  				Syn.trigger("mouseover", options, el);
  			}
  
  			Syn.trigger("mousemove", point, el || element)
  			return el;
  		},
  		// start and end are in clientX, clientY
  		startMove = function( start, end, duration, element, callback ) {
  			var startTime = new Date(),
  				distX = end.clientX - start.clientX,
  				distY = end.clientY - start.clientY,
  				win = Syn.helpers.getWindow(element),
  				current = elementFromPoint(start, element),
  				cursor = win.document.createElement('div'),
  				calls = 0;
  			move = function() {
  				//get what fraction we are at
  				var now = new Date(),
  					scrollOffset = Syn.helpers.scrollOffset(win),
  					fraction = (calls == 0 ? 0 : now - startTime) / duration,
  					options = {
  						clientX: distX * fraction + start.clientX,
  						clientY: distY * fraction + start.clientY
  					};
  				calls++;
  				if ( fraction < 1 ) {
  					Syn.helpers.extend(cursor.style, {
  						left: (options.clientX + scrollOffset.left + 2) + "px",
  						top: (options.clientY + scrollOffset.top + 2) + "px"
  					})
  					current = mouseMove(options, element, current)
  					setTimeout(arguments.callee, 15)
  				}
  				else {
  					current = mouseMove(end, element, current);
  					win.document.body.removeChild(cursor)
  					callback();
  				}
  			}
  			Syn.helpers.extend(cursor.style, {
  				height: "5px",
  				width: "5px",
  				backgroundColor: "red",
  				position: "absolute",
  				zIndex: 19999,
  				fontSize: "1px"
  			})
  			win.document.body.appendChild(cursor)
  			move();
  		},
  		startDrag = function( start, end, duration, element, callback ) {
  			createEventAtPoint("mousedown", start, element);
  			startMove(start, end, duration, element, function() {
  				createEventAtPoint("mouseup", end, element);
  				callback();
  			})
  		},
  		center = function( el ) {
  			var j = Syn.jquery()(el),
  				o = j.offset();
  			return {
  				pageX: o.left + (j.outerWidth() / 2),
  				pageY: o.top + (j.outerHeight() / 2)
  			}
  		},
  		convertOption = function( option, win, from ) {
  			var page = /(\d+)[x ](\d+)/,
  				client = /(\d+)X(\d+)/,
  				relative = /([+-]\d+)[xX ]([+-]\d+)/
  				//check relative "+22x-44"
  				if ( typeof option == 'string' && relative.test(option) && from ) {
  					var cent = center(from),
  						parts = option.match(relative);
  					option = {
  						pageX: cent.pageX + parseInt(parts[1]),
  						pageY: cent.pageY + parseInt(parts[2])
  					}
  				}
  				if ( typeof option == 'string' && page.test(option) ) {
  					var parts = option.match(page)
  					option = {
  						pageX: parseInt(parts[1]),
  						pageY: parseInt(parts[2])
  					}
  				}
  				if ( typeof option == 'string' && client.test(option) ) {
  					var parts = option.match(client)
  					option = {
  						clientX: parseInt(parts[1]),
  						clientY: parseInt(parts[2])
  					}
  				}
  				if ( typeof option == 'string' ) {
  					option = Syn.jquery()(option, win.document)[0];
  				}
  				if ( option.nodeName ) {
  					option = center(option)
  				}
  				if ( option.pageX ) {
  					var off = Syn.helpers.scrollOffset(win);
  					option = {
  						clientX: option.pageX - off.left,
  						clientY: option.pageY - off.top
  					}
  				}
  				return option;
  		},
  		// if the client chords are not going to be visible ... scroll the page so they will be ...
  		adjust = function(from, to, win){
  			if(from.clientY < 0){
  				var off = Syn.helpers.scrollOffset(win);
  				var dimensions = Syn.helpers.scrollDimensions(win),
  					top = off.top + (from.clientY) - 100,
  					diff = top - off.top
  				
  				// first, lets see if we can scroll 100 px
  				if( top > 0){
  					
  				} else {
  					top =0;
  					diff = -off.top;
  				}
  				from.clientY = from.clientY - diff;
  				to.clientY = to.clientY - diff;
  				Syn.helpers.scrollOffset(win,{top: top, left: off.left});
  				
  				//throw "out of bounds!"
  			}
  		}
  		/**
  		 * @add Syn prototype
  		 */
  		Syn.helpers.extend(Syn.init.prototype, {
  			/**
  			 * @function move
  			 * Moves the cursor from one point to another.  
  			 * 
  			 * ### Quick Example
  			 * 
  			 * The following moves the cursor from (0,0) in
  			 * the window to (100,100) in 1 second.
  			 * 
  			 *     Syn.move(
  			 *          {
  			 *            from: {clientX: 0, clientY: 0},
  			 *            to: {clientX: 100, clientY: 100},
  			 *            duration: 1000
  			 *          },
  			 *          document.document)
  			 * 
  			 * ## Options
  			 * 
  			 * There are many ways to configure the endpoints of the move.
  			 * 
  			 * ### PageX and PageY
  			 * 
  			 * If you pass pageX or pageY, these will get converted
  			 * to client coordinates.
  			 * 
  			 *     Syn.move(
  			 *          {
  			 *            from: {pageX: 0, pageY: 0},
  			 *            to: {pageX: 100, pageY: 100}
  			 *          },
  			 *          document.document)
  			 * 
  			 * ### String Coordinates
  			 * 
  			 * You can set the pageX and pageY as strings like:
  			 * 
  			 *     Syn.move(
  			 *          {
  			 *            from: "0x0",
  			 *            to: "100x100"
  			 *          },
  			 *          document.document)
  			 * 
  			 * ### Element Coordinates
  			 * 
  			 * If jQuery is present, you can pass an element as the from or to option
  			 * and the coordinate will be set as the center of the element.
  			 
  			 *     Syn.move(
  			 *          {
  			 *            from: $(".recipe")[0],
  			 *            to: $("#trash")[0]
  			 *          },
  			 *          document.document)
  			 * 
  			 * ### Query Strings
  			 * 
  			 * If jQuery is present, you can pass a query string as the from or to option.
  			 * 
  			 * Syn.move(
  			 *      {
  			 *        from: ".recipe",
  			 *        to: "#trash"
  			 *      },
  			 *      document.document)
  			 *    
  			 * ### No From
  			 * 
  			 * If you don't provide a from, the element argument passed to Syn is used.
  			 * 
  			 *     Syn.move(
  			 *          { to: "#trash" },
  			 *          'myrecipe')
  			 * 
  			 * ### Relative
  			 * 
  			 * You can move the drag relative to the center of the from element.
  			 * 
  			 *     Syn.move("+20 +30", "myrecipe");
  			 * 
  			 * @param {Object} options options to configure the drag
  			 * @param {HTMLElement} from the element to move
  			 * @param {Function} callback a callback that happens after the drag motion has completed
  			 */
  			_move: function( options, from, callback ) {
  				//need to convert if elements
  				var win = Syn.helpers.getWindow(from),
  					fro = convertOption(options.from || from, win, from),
  					to = convertOption(options.to || options, win, from);
  				
  				options.adjust !== false && adjust(fro, to, win);
  				startMove(fro, to, options.duration || 500, from, callback);
  
  			},
  			/**
  			 * @function drag
  			 * Creates a mousedown and drags from one point to another.  
  			 * Check out [Syn.prototype.move move] for API details.
  			 * 
  			 * @param {Object} options
  			 * @param {Object} from
  			 * @param {Object} callback
  			 */
  			_drag: function( options, from, callback ) {
  				//need to convert if elements
  				var win = Syn.helpers.getWindow(from),
  					fro = convertOption(options.from || from, win, from),
  					to = convertOption(options.to || options, win, from);
  
  				options.adjust !== false && adjust(fro, to, win);
  				startDrag(fro, to, options.duration || 500, from, callback);
  
  			}
  		})
  	return Syn;
  })(__m2);
  
  // ## syn.js
  var __m1 = (function(Syn){
  	window.Syn = Syn;
  
  	return Syn;
  })(__m2, __m3, __m4, __m5, __m6);
  
  }(window);
  !function(window) {
  
  // ## browser/init.js
  var __m5 = (function(jQuery) {
  	var FuncUnit = window.FuncUnit || {};
  
  	jQuery.sub = function() {
  		function jQuerySub( selector, context ) {
  			return new jQuerySub.fn.init( selector, context );
  		}
  		jQuery.extend( true, jQuerySub, this );
  		jQuerySub.superclass = this;
  		jQuerySub.fn = jQuerySub.prototype = this();
  		jQuerySub.fn.constructor = jQuerySub;
  		jQuerySub.sub = this.sub;
  		jQuerySub.fn.init = function init( selector, context ) {
  			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
  				context = jQuerySub( context );
  			}
  
  			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
  		};
  		jQuerySub.fn.init.prototype = jQuerySub.fn;
  		var rootjQuerySub = jQuerySub(document);
  		return jQuerySub;
  	};
  
  	FuncUnit.jQuery = jQuery;
  	return FuncUnit;
  })(jQuery);
  
  // ## browser/core.js
  var __m3 = (function(jQuery, oldFuncUnit) {
  	var FuncUnit = oldFuncUnit.jQuery.sub();
  	var origFuncUnit = FuncUnit;
  	// override the subbed init method
  	// context can be an object with frame and forceSync:
  	// - a number or string: this is a frame name/number, and means only do a sync query
  	// - true: means force the query to be sync only
  	FuncUnit = function( selector, frame ) {
  		// if you pass true as context, this will avoid doing a synchronous query
  		var frame,
  			forceSync, 
  			isSyncOnly = false;
  		
  		if(frame && frame.forceSync){
  			forceSync = frame.forceSync;
  		}
  		
  		if(frame && typeof frame.frame !== "undefined"){ // its passed as an object
  			frame = frame.frame;
  		}
  		
  		isSyncOnly = typeof forceSync === "boolean"? forceSync: isSyncOnly;
  		// if its a function, just run it in the queue
  		if(typeof selector == "function"){
  			return FuncUnit.wait(0, selector);
  		}
  		// if the app window already exists, adjust the params (for the sync return value)
  		this.selector = selector;
  		// run this method in the queue also
  		if(isSyncOnly === true){
  			var collection = performSyncQuery(selector, frame);
  			return collection;
  		} else { // do both
  			performAsyncQuery(selector, frame, this);
  			var collection = performSyncQuery(selector, frame);
  			return collection;
  		}
  	}
  
  
  	
  	var getContext = function(context){
  			if (typeof context === "number" || typeof context === "string") {
  				// try to get the context from an iframe in the funcunit document
  				var sel = (typeof context === "number" ? "iframe:eq(" + context + ")" : "iframe[name='" + context + "']"),
  					frames = new origFuncUnit.fn.init(sel, FuncUnit.win.document.documentElement, true);
  				var frame = (frames.length ? frames.get(0).contentWindow : FuncUnit.win).document.documentElement;
  				
  			} else {
  				frame = FuncUnit.win.document.documentElement;
  			}
  			return frame;
  		},
  		performAsyncQuery = function(selector, frame, self){
  			FuncUnit.add({
  				method: function(success, error){
  					this.frame = frame;
  					if (FuncUnit.win) {
  						frame = getContext(frame);
  					}
  					this.selector = selector;
  					this.bind = new origFuncUnit.fn.init( selector, frame, true );
  					success();
  					return this;
  				},
  				error: "selector failed: " + selector,
  				type: "query"
  			});
  		},
  		performSyncQuery = function(selector, frame){
  			var origFrame = frame;
  			if (FuncUnit.win) {
  				frame = getContext(frame);
  			}
  			var obj = new origFuncUnit.fn.init( selector, frame, true );
  			obj.frame = origFrame;
  			return obj;
  		}
  	
  	oldFuncUnit.jQuery.extend(FuncUnit, oldFuncUnit, origFuncUnit)
  	FuncUnit.prototype = origFuncUnit.prototype;
  	return FuncUnit;
  })(jQuery, __m5);
  
  // ## browser/adapters/jasmine.js
  var __m7 = (function(FuncUnit) {
  	if(window.jasmine) {
  		var paused = false;
  		FuncUnit.unit = {
  			pauseTest:function(){
  				paused = true;
  				waitsFor(function(){
  					return paused === false;
  				}, 60000)
  			},
  			resumeTest: function(){
  				paused = false;
  			},
  			assertOK: function(assertion, message){
  				expect(assertion).toBeTruthy();
  			},
  			equiv: function(expected, actual){
  				return jasmine.getEnv().equals_(expected, actual)
  			}
  		}
  		return FuncUnit;
  	}
  })(__m3);
  
  // ## browser/adapters/qunit.js
  var __m8 = (function(FuncUnit) {
  	if(window.QUnit) {
  		FuncUnit.unit = {
  		pauseTest:function(){
  			stop();
  		},
  		resumeTest: function(){
  			start();
  		},
  		assertOK: function(assertion, message){
  			ok(assertion, message)
  		},
  		equiv: function(expected, actual){
  			return QUnit.equiv(expected, actual);
  		}
  	}
  	}
  })(__m3);
  
  // ## browser/adapters/adapters.js
  var __m6 = (function() {})(__m7, __m8);
  
  // ## browser/open.js
  var __m9 = (function($, FuncUnit) {
  	if(FuncUnit.frameMode){
  		var ifrm = document.createElement("iframe");
  		ifrm.id = 'funcunit_app';
  		document.body.insertBefore(ifrm, document.body.firstChild);
  	}
  
  var confirms = [], 
  	prompts = [], 
  	currentDocument,
  	currentHref,
  	// pointer to the popup window
  	appWin, 
  	lookingForNewDocument = false,
  	urlWithoutHash = function(url){
  		return url.replace(/\#.*$/, "");
  	},
  	// returns true if url matches current window's url
  	isCurrentPage = function(url){
  		var pathname = urlWithoutHash(FuncUnit.win.location.pathname),
  			href = urlWithoutHash(FuncUnit.win.location.href),
  			url = urlWithoutHash(url);
  		// must strip off hash from URLs
  		if( pathname === url || href === url ){
  			return true;
  		}
  		return false;
  	};
  /**
   * @add FuncUnit
   */
  //
  $.extend(FuncUnit,{
  	// open is a method
  
  	/**
       * @parent utilities
       * @function FuncUnit.open F.open()
       * @signature `open(path, success, timeout)`
       *
  	 * Opens a page.  It will error if the page can't be opened before timeout. If a URL begins with "//", pages are opened 
  	 * from the FuncUnit root (the root folder where funcunit is located)
  	 * ### Example
       *
       * @codestart
       * F.open("//app/app.html")
       * @codeend
  	 * 
  	 * @param {String} path a full or partial url to open.
  	 * @param {Function} success
  	 * @param {Number} timeout
       * @return {undefined}
  	 */
  	open: function( path, success, timeout ) {
  		if(typeof success != 'function'){
  			timeout = success;
  			success = undefined;
  		}
  		FuncUnit.add({
  			method: function(success, error){ //function that actually does stuff, if this doesn't call success by timeout, error will be called, or can call error itself
  				if(typeof path === "string"){
  					var fullPath = FuncUnit.getAbsolutePath(path);
  					FuncUnit._open(fullPath, error);
  					FuncUnit._onload(function(){
  						success()
  					}, error);
  				} else {
  					FuncUnit.win = path;
  					success();
  				}
  			},
  			success: success,
  			error: "Page " + path + " not loaded in time!",
  			timeout: timeout || 30000
  		});
  	},
  	_open: function(url){
  		FuncUnit.win = appWin;
  		hasSteal = false;
  		// this will determine if this is supposed to open within a frame
  		FuncUnit.frame =  $('#funcunit_app').length? $('#funcunit_app')[0]: null;
  	
  		// if the first time ..
  		if (newPage) {
  			if(FuncUnit.frame){
  				FuncUnit.win = FuncUnit.frame.contentWindow;
  				FuncUnit.win.location = url;
  			}
  			else{
  				// giving a large height forces it to not open in a new tab and just opens to the window's height
  				var width = $(window).width();
  				FuncUnit.win = window.open(url, "funcunit",  "height=1000,toolbar=yes,status=yes,width="+width/2+",left="+width/2);
  				// This is mainly for opera. Other browsers will hit the unload event and close the popup.
  				// This block breaks in IE (which never reaches it) because after closing a window, it throws access 
  				// denied any time you try to access it, even after reopening.
  				if(FuncUnit.win.___FUNCUNIT_OPENED) {
  					FuncUnit.win.close();
  					FuncUnit.win = window.open(url, "funcunit",  "height=1000,toolbar=yes,status=yes,left="+width/2);
  				}
  				
  				
  				if(!FuncUnit.win){
  					throw "Could not open a popup window.  Your popup blocker is probably on.  Please turn it off and try again";
  				}
  			}
  			appWin = FuncUnit.win;
  		}
  		// otherwise, change the frame's url
  		else {
  			lookingForNewDocument = true;
  			if(isCurrentPage(url)){
  				/*Sometimes readyState does not correctly reset itself, so we remove the
  				body from the document we are navigating away from, which will get set again
  				when the page has reloaded*/
  				FuncUnit.win.document.body.parentNode.removeChild(FuncUnit.win.document.body);
  				// set the hash and reload
  				FuncUnit.win.location.hash = url.split('#')[1] || '';
  				FuncUnit.win.location.reload(true);
  			} else {
  				// setting the location forces a reload; IE freaks out if you try to do both
  				FuncUnit.win.location = url;
  			}
  			// setting to null b/c opera uses the same document
  			currentDocument = null;
  		}
  		lookingForNewDocument = true;
  	},
  	/**
  	 * @parent utilities
       * @function FuncUnit.confirm F.confirm()
       * @signature `confirm(answer)`
       *
  	 * When a browser's native confirm dialog is used, this method is used to repress the dialog and simulate
  	 * clicking OK or Cancel.  Alerts are repressed by default in FuncUnit application windows.
       *
  	 * @codestart
  	 * F.confirm(true);
  	 * @codeend
       *
  	 * @param {Boolean} answer true if you want to click OK, false otherwise
       * @return {undefined}
  	 */
  	confirm: function(answer){
  		confirms.push(!!answer)
  	},
  	/**
  	 * @parent utilities
       * @function FuncUnit.prompt F.prompt()
       * @signature `prompt(answer)`
       *
  	 * When a browser's native prompt dialog is used, this method is used to repress the dialog and simulate 
  	 * clicking typing something into the dialog.
  	 * @codestart
  	 * F.prompt("Harry Potter");
  	 * @codeend
  	 * @param {String} answer Whatever you want to simulate a user typing in the prompt box
       * @return {undefined}
  	 */
  	prompt: function(answer){
  		prompts.push(answer)
  	},
  	_opened: function(){
  		if (!this._isOverridden("alert")) {
  			FuncUnit.win.alert = function(){}
  		}
  		
  		if (!this._isOverridden("confirm")) {
  			FuncUnit.win.confirm = function(){
  				var res = confirms.shift();
  				return res;
  			}
  		}
  		
  		if (!this._isOverridden("prompt")) {
  			FuncUnit.win.prompt = function(){
  				return prompts.shift();
  			}
  		}
  	},
  	_isOverridden:function(type) {
  		return !(/(native code)|(source code not available)/.test(FuncUnit.win[type]));
  	},
  	_onload: function(success, error){
  		// saver reference to success
  		loadSuccess = function(){
  			if(FuncUnit.win.steal){
  				hasSteal = true;
  			}
  			// called when load happens ... here we check for steal
  			// console.log("success", (FuncUnit.win.steal && FuncUnit.win.steal.isReady) || !hasSteal, 
  				// "isReady", (FuncUnit.win.steal && FuncUnit.win.steal.isReady));
  			if((FuncUnit.win.steal && FuncUnit.win.steal.isReady) || !hasSteal){
  				success();
  			}else{
  				setTimeout(arguments.callee, 200)
  			}
  				
  		}
  		
  		// we only need to do this setup stuff once ...
  		if (!newPage) {
  			return;
  		}
  		newPage = false;
  		
  		if (FuncUnit.support.readystate)
  		{
  			poller();
  		}
  		else {
  			unloadLoader();
  		}
  		
  	},
  	/**
  	 * @hide
  	 * @parent utilities
  	 * Gets a path
  	 * @param {String} path
  	 */
  	getAbsolutePath: function( path ) {
  		if ( /^\/\//.test(path) ){
  			path = path.substr(2);
  		}
  		return path;
  	},
  	/**
  	 * @parent utilities
  	 * @property {window} FuncUnit.win F.win()
  	 * Use this to refer to the window of the application page.
  	 * @codestart
  	 *F(F.window).innerWidth(function(w){
  	 *   ok(w > 1000, "window is more than 1000 px wide")
  	 * })
  	 * @codeend
  	 */
  	win: window,
  	// for feature detection
  	support: {
  		readystate: "readyState" in document
  	},
  	/**
  	 * @parent utilities
       * @function FuncUnit.eval F.eval()
       * @signature `eval(str)`
       *
  	 * Used to evaluate code in the application page.
  	 * @param {String} str the code to evaluate
  	 * @return {Object} the result of the evaluated code
  	 */
  	eval: function(str){
  		return FuncUnit.win.eval(str)
  	},
  	// return true if document is currently loaded, false if its loading
  	// actions check this
  	documentLoaded: function(){
  		var loaded = FuncUnit.win.document.readyState === "complete" && 
  				     FuncUnit.win.location.href != "about:blank" &&
  				     FuncUnit.win.document.body;
  		return loaded;
  	},
  	// return true if new document found
  	checkForNewDocument: function(){
  		var documentFound = false;
  
  		// right after setting a new hash and reloading, IE barfs on this occassionally (only the first time)
  		try {
  			documentFound = ((FuncUnit.win.document !== currentDocument && // new document 
  							!FuncUnit.win.___FUNCUNIT_OPENED) // hasn't already been marked loaded
  							// covers opera case after you click a link, since document doesn't change in opera
  							|| (currentHref != FuncUnit.win.location.href)) && // url is different 
  							FuncUnit.documentLoaded(); // fully loaded
  		} catch(e){}
  		if(documentFound){
  			// reset flags
  			lookingForNewDocument = false;
  			currentDocument = FuncUnit.win.document;
  			currentHref = FuncUnit.win.location.href;
  			
  			// mark it as opened
  			FuncUnit.win.___FUNCUNIT_OPENED = true;
  			// reset confirm, prompt, alert
  			FuncUnit._opened();
  		}
  		
  		return documentFound;
  	}
  });
  
  	//don't do any of this if in rhino
  	if (navigator.userAgent.match(/Rhino/)) {
  		return;	
  	}
  	
  	
  	var newPage = true, 
  		hasSteal = false,
  		unloadLoader, 
  		loadSuccess, 
  		firstLoad = true,
  		onload = function(){
  			FuncUnit.win.document.documentElement.tabIndex = 0;
  			setTimeout(function(){
  				FuncUnit.win.focus();
  				var ls = loadSuccess
  				loadSuccess = null;
  				if (ls) {
  					ls();
  				}
  			}, 0);
  			Syn.unbind(FuncUnit.win, "load", onload);
  		},
  		onunload = function(){
  			FuncUnit.stop = true;
  			removeListeners();
  			setTimeout(unloadLoader, 0)
  			
  		},
  		removeListeners = function(){
  			Syn.unbind(FuncUnit.win, "unload", onunload);
  			Syn.unbind(FuncUnit.win, "load", onload);
  		}
  	unloadLoader = function(){
  		if(!firstLoad) // dont remove the first run, fixes issue in FF 3.6
  			removeListeners();
  		
  		Syn.bind(FuncUnit.win, "load", onload);
  		
  		//listen for unload to re-attach
  		Syn.bind(FuncUnit.win, "unload", onunload)
  	}
  	
  	//check for window location change, documentChange, then readyState complete -> fire load if you have one
  	var newDocument = false, 
  		poller = function(){
  			var ls;
  			
  			if (lookingForNewDocument && FuncUnit.checkForNewDocument() ) {
  				
  				ls = loadSuccess;
  				
  				loadSuccess = null;
  				if (ls) {
  					FuncUnit.win.focus();
  					FuncUnit.win.document.documentElement.tabIndex = 0;
  					
  					ls();
  				}
  			}
  			
  		setTimeout(arguments.callee, 500)
  	}
  
  	// All browsers except Opera close the app window on a reload.  This is to fix the case the URL to be opened 
  	// has a hash.  In this case, window.open doesn't cause a reload if you reuse an existing popup, so we need to close.
  	$(window).unload(function(){
  		if(FuncUnit.win && FuncUnit.win !== window.top) {
  			FuncUnit.win.close();
  		}
  	});
  
  	return FuncUnit;
  })(jQuery, __m3);
  
  // ## browser/actions.js
  var __m10 = (function($, FuncUnit, Syn) {
  	window.Syn = Syn;
  	/**
  	 * @add FuncUnit
  	 */
  	var clicks = [
  	// methods
  	/**
       *
  	 * @function FuncUnit.prototype.click .click()
       * @parent actions
       * @signature `click(options [,success])`
       *
  	 * Clicks an element.  This uses [Syn.prototype.click] to issue a:
  	 * <ul>
  	 * 	<li><code>mousedown</code></li>
  	 *  <li><code>focus</code> - if the element is focusable</li>
  	 *  <li><code>mouseup</code></li>
  	 *  <li><code>click</code></li>
  	 * </ul>
  	 * If no clientX/Y or pageX/Y is provided as options, the click happens at the 
  	 * center of the element.
  	 * <p>For a right click or double click use [FuncUnit.prototype.rightClick] or
  	 *   [FuncUnit.prototype.dblclick].</p>
  	 * <h3>Example</h3>
  	 * @codestart
  	 * //clicks the bar element
  	 *F("#bar").click()
  	 * @codeend
  	 * @param {Object} [options] options to pass to the click event.  Typically, this is clientX/Y or pageX/Y:
  	 * @codestart
  	 * $('#foo').click({pageX: 200, pageY: 100});
  	 * @codeend
  	 * You can pass it any of the serializable parameters you'd send to 
  	 * [http://developer.mozilla.org/en/DOM/event.initMouseEvent initMouseEvent], but command keys are 
  	 * controlled by [FuncUnit.prototype.type].
       *
  	 * @param {Function} [success] a callback that runs after the click, but before the next action.
  	 * @return {funcUnit} returns the funcunit object for chaining.
  	 */
  	'click',
  	/**
       * @function FuncUnit.prototype.dblclick .dblclick()
       * @parent actions
       * @signature `dblclick(options [,success])`
       *
  	 * Double clicks an element by [FuncUnit.prototype.click clicking] it twice and triggering a dblclick event.
  	 * @param {Object} options options to add to the mouse events.  This works
  	 * the same as [FuncUnit.prototype.click]'s options.
  	 * @param {Function} [success] a callback that runs after the double click, but before the next action.
  	 * @return {funcUnit} returns the funcunit object for chaining.
  	 */
  	'dblclick',
  	/**
       * @function FuncUnit.prototype.rightClick .rightClick()
       * @parent actions
       * @signature `rightClick(options [,success])`
  	 * Right clicks an element.  This typically results in a contextmenu event for browsers that
  	 * support it.
  	 * @param {Object} options options to add to the mouse events.  This works
  	 * the same as [FuncUnit.prototype.click]'s options.
  	 * @param {Function} [success] a callback that runs after the click, but before the next action.
  	 * @return {funcUnit} returns the funcunit object for chaining.
  	 */
  	'rightClick'],
  		makeClick = function(name){
  			FuncUnit.prototype[name] = function(options, success){
  				this._addExists();
  				if(typeof options == 'function'){
  					success = options;
  					options = {};
  				}
  				var selector = this.selector;
  				FuncUnit.add({
  					method: function(success, error){
  						options = options || {};
  						Syn("_" + name, options, this.bind[0],success);
  					},
  					success: success,
  					error: "Could not " + name + " '" + this.selector+"'",
  					bind: this,
  					type: "action"
  				});
  				return this;
  			}
  		}
  	
  	for(var i=0; i < clicks.length; i++){
  		makeClick(clicks[i])
  	}
  	
  	$.extend(FuncUnit.prototype, {
  		// perform check even if last queued item is a wait beacuse certain waits don't guarantee the element is visible (like text)
  		_addExists: function(){
  			this.exists(false);
  		},
  		/**
           * @function FuncUnit.prototype.type .type()
           * @parent actions
           * @signature `type(text [,success])`
           *
  		 * Types text into an element.  This makes use of [Syn.type] and works in 
  		 * a very similar way.
  		 * <h3>Quick Examples</h3>
  		 * @codestart
  		 * //types hello world
  		 *F('#bar').type('hello world')
  		 * 
  		 * //submits a form by typing \r
  		 *F("input[name=age]").type("27\r")
  		 * 
  		 * //types FuncUnit, then deletes the Unit
  		 *F('#foo').type("FuncUnit\b\b\b\b")
  		 * 
  		 * //types JavaScriptMVC, then removes the MVC
  		 *F('#zar').type("JavaScriptMVC[left][left][left]"+
  		 *                      "[delete][delete][delete]")
  		 *          
  		 * //types JavaScriptMVC, then selects the MVC and
  		 * //deletes it
  		 *F('#zar').type("JavaScriptMVC[shift]"+
  		 *                "[left][left][left]"+
  		 *                "[shift-up][delete]")
  		 * @codeend
  		 *
  		 * <h2>Characters</h2>
  		 * 
  		 * For a list of the characters you can type, check [Syn.keycodes].
  		 * 
  		 * @param {String} text the text you want to type
  		 * @param {Function} [success] a callback that is run after typing, but before the next action.
  		 * @return {FuncUnit} returns the funcUnit object for chaining.
  		 */
  		type: function( text, success ) {
  			this._addExists();
  			// when you type in something you have to click on it first
  			this.click();
  			var selector = this.selector;
  			// type("") is a shortcut for clearing out a text input
  			if(text === ""){
  				text = "[ctrl]a[ctrl-up]\b"
  			}
  			FuncUnit.add({
  				method : function(success, error){
  					Syn("_type", text, this.bind[0], success);
  					
  				},
  				success : success,
  				error : "Could not type " + text + " into " + this.selector,
  				bind : this,
  				type: "action"
  			});
  			return this;
  		},
  		trigger: function(evName, success){
  			this._addExists();
  			FuncUnit.add({
  				method : function(success, error){
  					// need to use the page's jquery to trigger events
  					FuncUnit.win.jQuery(this.bind.selector).trigger(evName)
  					success()
  				},
  				success : success,
  				error : "Could not trigger " + evName,
  				bind : this,
  				type: "action"
  			});
  			return this;
  		},
  		/**
           * @function FuncUnit.prototype.drag .drag()
           * @parent actions
           * @signature `drag(options [,success])`
  		 * Drags an element into another element or coordinates.  
  		 * This takes the same paramameters as [Syn.prototype.move move].
  		 * @param {String|Object} options A selector or coordinates describing the motion of the drag.
  		 * <h5>Options as a Selector</h5>
  		 * Passing a string selector to drag the mouse.  The drag runs to the center of the element
  		 * matched by the selector.  The following drags from the center of #foo to the center of #bar.
  		 * @codestart
  		 *F('#foo').drag('#bar') 
  		 * @codeend
  		 * <h5>Options as Coordinates</h5>
  		 * You can pass in coordinates as clientX and clientY:
  		 * @codestart
  		 *F('#foo').drag('100x200') 
  		 * @codeend
  		 * Or as pageX and pageY
  		 * @codestart
  		 *F('#foo').drag('100X200') 
  		 * @codeend
  		 * Or relative to the start position
  		 *F('#foo').drag('+10 +20')
  		 * <h5>Options as an Object</h5>
  		 * You can configure the duration, start, and end point of a drag by passing in a json object.
  		 * @codestart
  		 * //drags from 0x0 to 100x100 in 2 seconds
  		 *F('#foo').drag({
  		 *   from: "0x0",
  		 *   to: "100x100",
  		 *   duration: 2000
  		 * }) 
  		 * @codeend
  		 * @param {Function} [success] a callback that runs after the drag, but before the next action.
  		 * @return {funcUnit} returns the funcunit object for chaining.
  		 */
  		drag: function( options, success ) {
  			this._addExists();
  			if(typeof options == 'string'){
  				options = {to: options}
  			}
  			options.from = this.selector;
  	
  			var selector = this.selector;
  			FuncUnit.add({
  				method: function(success, error){
  					Syn("_drag", options, this.bind[0],success);
  				},
  				success: success,
  				error: "Could not drag " + this.selector,
  				bind: this,
  				type: "action"
  			})
  			return this;
  		},
  		/**
           * @function FuncUnit.prototype.move .move()
           * @parent actions
           * @signature `move(options [,success])`
  		 * Moves an element into another element or coordinates.  This will trigger mouseover
  		 * mouseouts accordingly.
  		 * This takes the same paramameters as [Syn.prototype.move move].
  		 * @param {String|Object} options A selector or coordinates describing the motion of the move.
  		 * <h5>Options as a Selector</h5>
  		 * Passing a string selector to move the mouse.  The move runs to the center of the element
  		 * matched by the selector.  The following moves from the center of #foo to the center of #bar.
  		 * @codestart
  		 *F('#foo').move('#bar') 
  		 * @codeend
  		 * <h5>Options as Coordinates</h5>
  		 * You can pass in coordinates as clientX and clientY:
  		 * @codestart
  		 *F('#foo').move('100x200') 
  		 * @codeend
  		 * Or as pageX and pageY
  		 * @codestart
  		 *F('#foo').move('100X200') 
  		 * @codeend
  		 * Or relative to the start position
  		 *F('#foo').move('+10 +20')
  		 * <h5>Options as an Object</h5>
  		 * You can configure the duration, start, and end point of a move by passing in a json object.
  		 * @codestart
  		 * //drags from 0x0 to 100x100 in 2 seconds
  		 *F('#foo').move({
  		 *   from: "0x0",
  		 *   to: "100x100",
  		 *   duration: 2000
  		 * }) 
  		 * @codeend
  		 * @param {Function} [success] a callback that runs after the drag, but before the next action.
  		 * @return {funcUnit} returns the funcunit object for chaining.
  		 */
  		move: function( options, success ) {
  			this._addExists();
  			if(typeof options == 'string'){
  				options = {to: options}
  			}
  			options.from = this.selector;
  	
  			var selector = this.selector;
  			FuncUnit.add({
  				method: function(success, error){
  					Syn("_move", options, this.bind[0], success);
  				},
  				success: success,
  				error: "Could not move " + this.selector,
  				bind: this,
  				type: "action"
  			});
  			return this;
  		},
  		/**
           * @function FuncUnit.prototype.scroll .scroll()
           * @parent actions
           * @signature `scroll(direction, amount, success)`
  		 * Scrolls an element in a particular direction by setting the scrollTop or srollLeft.
  		 * @param {String} direction "left" or "top"
  		 * @param {Number} amount number of pixels to scroll
  		 * @param {Function} success
  		 */
  		scroll: function( direction, amount, success ) {
  			this._addExists();
  			var selector = this.selector,
  				direction;
  			if (direction == "left" || direction == "right") {
  				direction = "Left";
  			} else if (direction == "top" || direction == "bottom") {
  				direction = "Top";
  			}
  			FuncUnit.add({
  				method: function(success, error){
  					this.bind.each(function(i, el){
  						this["scroll" + direction] = amount;
  					})
  					success();
  				},
  				success: success,
  				error: "Could not scroll " + this.selector,
  				bind: this,
  				type: "action"
  			});
  			return this;
  		}
  	})
  	return FuncUnit;
  })(jQuery, __m3, Syn);
  
  // ## browser/getters.js
  var __m11 = (function($, FuncUnit) {
  	
  	/**
  	 * @add FuncUnit
  	 */
  	//list of jQuery functions we want, number is argument index
  	//for wait instead of getting value
  	FuncUnit.funcs = {
  	// methods
  	/**
       * @function FuncUnit.prototype.size .size()
       * @parent dimensions
       * @signature `size([size] [,timeout] [,success] [,message])`
  	 * Gets the number of elements matched by the selector or
  	 * waits until the the selector is size.  You can also 
  	 * provide a function that continues to the next action when
  	 * it returns true.
  	 * @codestart
  	 *F(".recipe").size() //gets the number of recipes
  	 * 
  	 *F(".recipe").size(2) //waits until there are 2 recipes
  	 * 
  	 * //waits until size is count
  	 *F(".recipe").size(function(size){
  	 *   return size == count;
  	 * })
  	 * @codeend
  	 * @param {Number|Function} [size] number or a checking function.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {Number} if the size parameter is not provided, size returns the number
  	 * of elements matched.
  	 */
  	'size' : 0,
  	/**
       * @function FuncUnit.prototype.attr .attr()
       * @parent manipulation
       * @signature `attr(data, value [,timeout] [,success] [,message])`
  	 * Gets the value of an attribute from an element or waits until the attribute
  	 * equals the attr param.
  	 * @codestart
  	 * //waits until the abc attribute == some
  	 *F("#something").attr("abc","some") 
  	 * @codeend
  	 * @param {String} data The attribute to get, or wait for.
  	 * @param {String|Function} value If provided uses this as a check before continuing to the next action
       *
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {Object} if the attr parameter is not provided, returns
  	 * the attribute.
  	 */
  	'attr' : 1, 
  	/**
       * @function FuncUnit.prototype.hasClass .hasClass()
       * @parent css
       * @signature `hasClass(className [,value] [,timeout] [,success] [,message])`
  	 * @codestart
  	 * //returns if the element has the class in its className
  	 *F("#something").hasClass("selected");
  	 *
  	 * //waits until #something has selected in its className
  	 *F("#something").hasClass("selected",true);
  	 * 
  	 * //waits until #something does not have selected in its className
  	 *F("#something").hasClass("selected",false);
  	 * @codeend
  	 * @param {String} className The part of the className to search for.
  	 * @param {Boolean|Function} [value] If provided uses this as a check before continuing to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {Boolean|funcUnit} if the value parameter is not provided, returns
  	 * if the className is found in the element's className.  If a value paramters is provided, returns funcUnit for chaining.
  	 */
  	'hasClass' : 1, //makes wait
  	/**
       * @function FuncUnit.prototype.html .html()
       * @parent manipulation
       * @signature `html([html] [,timeout] [,success] [,message])`
  	 * Gets the [http://api.jquery.com/html/ html] from an element or waits until the html is a certain value.
  	 * @codestart
  	 * //checks foo's html has "JupiterJS"
  	 * ok( /JupiterJS/.test(F('#foo').html() ) )
  	 * 
  	 * //waits until foo's html has JupiterJS
  	 *F('#foo').html(/JupiterJS/)
  	 * 
  	 * //waits until foo's html is JupiterJS
  	 *F('#foo').html("JupiterJS")
  	 * @codeend
  	 * 
  	 * @param {String|Function} [html] If provided uses this as a check before continuing to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the html parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
  	 */
  	'html' : 0, 
  	/**
       * @function FuncUnit.prototype.text .text()
       * @parent manipulation
       * @signature `text([text] [,timeout] [,success] [,message])`
  	 * Gets the [http://api.jquery.com/text/ text] from an element or waits until the text is a certain value.
  	 * @codestart
  	 * //checks foo's text has "JupiterJS"
  	 * ok( /JupiterJS/.test(F('#foo').text() ) )
  	 * 
  	 * //waits until bar's text has JupiterJS
  	 *F('#foo').text(/JupiterJS/)
  	 * 
  	 * //waits until bar's text is JupiterJS
  	 *F('#foo').text("JupiterJS")
  	 * @codeend
  	 * 
  	 * @param {String|Function} [text] If provided uses this as a check before continuing to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the text parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
  	 */
  	'text' : 0, 
  	/**
       * @function FuncUnit.prototype.val .val()
       * @parent manipulation
       * @signature `val([val] [,timeout] [,success] [,message])`
  	 * Gets the [http://api.jquery.com/val/ val] from an element or waits until the val is a certain value.
  	 * @codestart
  	 * //checks foo's val has "JupiterJS"
  	 * ok( /JupiterJS/.test(F('input#foo').val() ) )
  	 * 
  	 * //waits until bar's val has JupiterJS
  	 *F('input#foo').val(/JupiterJS/)
  	 * 
  	 * //waits until bar's val is JupiterJS
  	 *F('input#foo').val("JupiterJS")
  	 * @codeend
  	 * 
  	 * @param {String|Function} [val] If provided uses this as a check before continuing to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the val parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
  	 */
  	'val' : 0, 
  	/**
       * @function FuncUnit.prototype.css .css()
       * @parent css
       * @signature `css(prop [,val] [,timeout] [,success] [,message])`
  	 * Gets a [http://api.jquery.com/css/ css] property from an element or waits until the property is 
  	 * a specified value.
  	 * @codestart
  	 * // gets the color
  	 *F("#foo").css("color")
  	 * 
  	 * // waits until the color is red
  	 *F("#foo").css("color","red") 
  	 * @codeend
  	 * 
  	 * @param {String} prop A css property to get or wait until it is a specified value.
  	 * @param {String|Function} [val] If provided uses this as a check before continuing to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the val parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the css of the selector.
  	 */
  	'css': 1, 
  	'prop': 1, 
  	/**
       * @function FuncUnit.prototype.offset .offset()
       * @parent dimensions
       * @signature `offset([offset] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/offset/ offset] or waits until 
  	 * the offset is a specified value.
  	 * @codestart
  	 * // gets the offset
  	 *F("#foo").offset();
  	 * 
  	 * // waits until the offset is 100, 200
  	 *F("#foo").offset({top: 100, left: 200}) 
  	 * @codeend
  	 * 
  	 * @param {Object|Function} [offset] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the offset parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the css of the selector.
  	 */
  	'offset' : 0,
  	/**
       * @function FuncUnit.prototype.position .position()
       * @parent dimensions
       * @signature `position([position] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/position/ position] or waits until 
  	 * the position is a specified value.
  	 * @codestart
  	 * // gets the position
  	 *F("#foo").position();
  	 * 
  	 * // waits until the position is 100, 200
  	 *F("#foo").position({top: 100, left: 200}) 
  	 * @codeend
  	 * 
  	 * @param {Object|Function} [position] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if the position parameter is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the offset of the selector.
  	 */
  	'position' : 0,
  	/**
       * @function FuncUnit.prototype.scrollTop .scrollTop()
       * @parent dimensions
       * @signature `scrollTop([scrollTop] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/scrollTop/ scrollTop] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the scrollTop
  	 *F("#foo").scrollTop();
  	 * 
  	 * // waits until the scrollTop is 100
  	 *F("#foo").scrollTop(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [scrollTop] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if scrollTop is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the scrollTop of the selector.
  	 */ 
  	'scrollTop' : 0, 
  	/**
       * @function FuncUnit.prototype.scrollLeft .scrollLeft()
       * @parent dimensions
       * @signature `scrollLeft([scrollLeft] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/scrollLeft/ scrollLeft] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the scrollLeft
  	 *F("#foo").scrollLeft();
  	 * 
  	 * // waits until the scrollLeft is 100
  	 *F("#foo").scrollLeft(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [scrollLeft] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if scrollLeft is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the scrollLeft of the selector.
  	 */ 
  	'scrollLeft' : 0, 
  	/**
       * @function FuncUnit.prototype.height .height()
       * @parent dimensions
       * @signature `height([height] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/height/ height] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the height
  	 *F("#foo").height();
  	 * 
  	 * // waits until the height is 100
  	 *F("#foo").height(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [height] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if height is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the height of the selector.
  	 */
  	'height' : 0, 
  	/**
       * @function FuncUnit.prototype.width .width()
       * @parent dimensions
       * @signature `width([width] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/width/ width] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the width
  	 *F("#foo").width();
  	 * 
  	 * // waits until the width is 100
  	 *F("#foo").width(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [width] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if width is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the width of the selector.
  	 */
  	'width' : 0, 
  	/**
       * @function FuncUnit.prototype.innerHeight .innerHeight()
       * @parent dimensions
       * @signature `innerHeight([innerHeight] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/innerHeight/ innerHeight] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the innerHeight
  	 *F("#foo").innerHeight();
  	 * 
  	 * // waits until the innerHeight is 100
  	 *F("#foo").innerHeight(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [innerHeight] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if innerHeight is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the innerHeight of the selector.
  	 */
  	'innerHeight' : 0, 
  	/**
       * @function FuncUnit.prototype.innerWidth .innerWidth()
       * @parent dimensions
       * @signature `innerWidth([innerWidth] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/innerWidth/ innerWidth] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the innerWidth
  	 *F("#foo").innerWidth();
  	 * 
  	 * // waits until the innerWidth is 100
  	 *F("#foo").innerWidth(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [innerWidth] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if innerWidth is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the innerWidth of the selector.
  	 */
  	'innerWidth' : 0, 
  	/**
       * @function FuncUnit.prototype.outerHeight .outerHeight()
       * @parent dimensions
       * @signature `outerHeight([outerHeight] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/outerHeight/ outerHeight] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the outerHeight
  	 *F("#foo").outerHeight();
  	 * 
  	 * // waits until the outerHeight is 100
  	 *F("#foo").outerHeight(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [outerHeight] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if outerHeight is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the outerHeight of the selector.
  	 */
  	'outerHeight' : 0, 
  	/**
       * @function FuncUnit.prototype.outerWidth .outerWidth()
       * @parent dimensions
       * @signature `outerWidth([outerWidth] [,timeout] [,success] [,message])`
  	 * Gets an element's [http://api.jquery.com/outerWidth/ outerWidth] or waits until 
  	 * it equals a specified value.
  	 * @codestart
  	 * // gets the outerWidth
  	 *F("#foo").outerWidth();
  	 * 
  	 * // waits until the outerWidth is 100
  	 *F("#foo").outerWidth(100) 
  	 * @codeend
  	 * 
  	 * @param {Number|Function} [outerWidth] If provided uses this as a check before continuing to the next action.  Or you can 
  	 * provide a function that returns true to continue to the next action.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {String|funcUnit} if outerWidth is provided, 
  	 * returns the funcUnit selector for chaining, otherwise returns the outerWidth of the selector.
  	 */
  	'outerWidth' : 0}
  	
  	
  	//makes a jQuery like command.
  	FuncUnit.makeFunc = function(fname, argIndex){
  		var orig = FuncUnit.fn[fname];
  		//makes a read / wait function
  		FuncUnit.prototype[fname] = function(){
  			//assume last arg is success
  			var args = FuncUnit.makeArray(arguments), 
  				isWait = args.length > argIndex,
  				success,
  				self = this;
  			
  			args.unshift(this.selector,this.frame,fname)
  			if(isWait){
  				//get the args greater and equal to argIndex
  				var tester = args[argIndex+3],
  					timeout = args[argIndex+4],
  					success = args[argIndex+5],
  					message = args[argIndex+6],
  					testVal = tester,
  					errorMessage = "waiting for "+fname +" on " + this.selector,
  					frame = this.frame,
  					logMessage = "Checking "+fname+" on '"+this.selector+"'",
  					ret;
  				
  				// can pass in an object or list of arguments
  				if(typeof tester == 'object' && !(tester instanceof RegExp)){
  					timeout = tester.timeout;
  					success = tester.success;
  					message = tester.message;
  					if(tester.errorMessage){
  						errorMessage = tester.errorMessage
  					}
  					if(typeof tester.logMessage !== "undefined"){
  						logMessage = tester.logMessage
  					}
  					tester = tester.condition;
  				}
  				if(typeof timeout == 'function'){
  					success = timeout;
  					message = success;
  					timeout = undefined;
  				}
  				if(typeof timeout == 'string'){
  					message = timeout;
  					timeout = undefined;
  					success = undefined;
  				}
  				if(typeof message !== 'string'){
  					message = undefined;
  				}
  				args.splice(argIndex+3, args.length- argIndex - 3);
  				
  				if(typeof tester != 'function'){
  					errorMessage += " !== "+testVal
  					tester = function(val){
  						return FuncUnit.unit.equiv(val, testVal) || 
  							(testVal instanceof RegExp && testVal.test(val) );
  					}
  				}
  				if(message){
  					errorMessage = message;
  				}
  				FuncUnit.repeat({
  					method : function(print){
  						// keep getting new collection because the page might be updating, we need to keep re-checking
  						if(this.bind.prevObject && this.bind.prevTraverser){
  							var prev = this.bind;
  							this.bind = this.bind.prevObject[this.bind.prevTraverser](this.bind.prevTraverserSelector)
  							this.bind.prevTraverser = prev.prevTraverser;
  							this.bind.prevTraverserSelector = prev.prevTraverserSelector;
  						} else {
  							// pass false so it will only do one synchronous request
  							this.bind =F(this.selector, {
  								frame: frame, 
  								forceSync: true
  							})
  						}
  						if(logMessage){
  							print(logMessage)
  						}
  						var methodArgs = [];
  						// might need an argument
  						if(argIndex > 0){
  							methodArgs.push(args[3]);
  						}
  						// lazy flag to ignore the getter error below
  						FuncUnit._ignoreGetterError = true;
  						ret = this.bind[fname].apply(this.bind, methodArgs)
  						FuncUnit._ignoreGetterError = false;
  						
  						var passed = tester.call(this.bind, ret);
  						
  						// unless this is a "size" command, require size to be non-zero (don't pass through if there's no elements)
  						if(this.bind.length === 0 && fname !== "size"){
  							passed = false;
  						}
  						
  						if(passed){
  							// if document is still loading
  							if(!FuncUnit.documentLoaded()){
  								passed = false;
  							} else {
  								// after every successful wait, check for a new document (if someone clicked a link), 
  								// and overwrite alert/confirm/prompt
  								// TODO this creates a potential race if a new document is loaded but its steal isn't ready...should poll
  								FuncUnit.checkForNewDocument();
  							}
  						}
  						return passed;
  					},
  					success : function(){
  						if(message){
  							FuncUnit.unit.assertOK(true, message)
  						}
  						success && success.apply(this, arguments);
  					},
  					error : function(){
  						var msg = errorMessage;
  						if(ret){
  							msg += ", actual value: "+ret;
  						}
  						FuncUnit.unit.assertOK(false, msg);
  					},
  					timeout : timeout,
  					bind: this,
  					type: "wait"
  				})
  				return this;
  			}else{
  				// throw a warning if user tries to use a getter after the start of the test (if there are other async methods)
  				if(!FuncUnit._ignoreGetterError && !FuncUnit._incallback && FuncUnit._haveAsyncQueries()){
  					console && console.error("You can't run getters after actions and waits. Please put your getters in a callback or at the beginning of the test.")
  				}
  				// just call the original jQ method
  				var methodArgs = [];
  				if(argIndex > 0){
  					methodArgs.push(args[3]);
  				}
  				return orig.apply(this, methodArgs);
  			}
  		}
  	}
  	
  	for (var prop in FuncUnit.funcs) {
  		FuncUnit.makeFunc(prop, FuncUnit.funcs[prop]);
  	}
  
  	return FuncUnit;
  })(jQuery, __m3);
  
  // ## browser/traversers.js
  var __m12 = (function($, FuncUnit){
  
  /**
   * @add FuncUnit
   */
  // prototype
  //do traversers
  var traversers = [
  	/**
       * @function FuncUnit.prototype.closest .closest()
       * @parent traversal
       * @signature `closest()`
  	 * Asynchronous version of jQuery's closest.  Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().closest(".bar").visible();
  	 * @codeend
       * @param {string} selector
  	 */
  	"closest",
  	/**
  	 * @function FuncUnit.prototype.next .next()
       * @parent traversal
       * @signature `next()`
  	 * Asynchronous version of next. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().next().visible();
  	 * @codeend
  	 */
  	"next",
  	/**
       * @function FuncUnit.prototype.prev .prev()
       * @parent traversal
       * @signature `prev()`
  	 * Asynchronous version of prev. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().prev().visible();
  	 * @codeend
  	 */
  	"prev",
  	/**
       * @function FuncUnit.prototype.siblings .siblings()
       * @parent traversal
       * @signature `siblings()`
  	 * Asynchronous version of siblings. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().siblings().visible();
  	 * @codeend
  	 */
  	"siblings",
  	/**
       * @function FuncUnit.prototype.last .last()
       * @parent traversal
       * @signature `last()`
  	 * Asynchronous version of last. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().last().visible();
  	 * @codeend
  	 */
  	"last",
  	/**
       * @function FuncUnit.prototype.first .first()
       * @parent traversal
       * @signature `first()`
  	 * Asynchronous version of first. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().first().visible();
  	 * @codeend
  	 */
  	"first", 
  	/**
       * @function FuncUnit.prototype.find .find()
       * @parent traversal
       * @signature `find()`
  	 * Asynchronous version of find. Performs the exact same functionality as the jQuery method 
  	 * but adds itself to the queue.
  	 * 
  	 * @codestart
  	 * // after the click, filter the collection, then wait for result to be visible
  	 *F(".foo").click().find(".bar").visible();
  	 * @codeend
       * @param {string} selector
  	 */
  	"find"
  ],
  	makeTraverser = function(name){
  		var orig = FuncUnit.prototype[name];
  		FuncUnit.prototype[name] = function(selector){
  			var args = arguments;
  			// find is called (with "this" as document) from FuncUnit.fn.init, so in this case don't queue it up, just run the regular find
  			if (FuncUnit.win && this[0] && this[0].parentNode && this[0].parentNode.nodeType !== 9) { // document nodes are 9
  				FuncUnit.add({
  					method: function(success, error){
  						// adjust the collection by using the real traverser method
  						var newBind = orig.apply(this.bind, args);
  						newBind.prevTraverser = name;
  						newBind.prevTraverserSelector = selector;
  						success(newBind)
  					},
  					error: "Could not traverse: " + name + " " + selector,
  					bind: this
  				});
  			}
  			return orig.apply(this, arguments);
  		}
  	};
  for(var i  =0; i < traversers.length; i++){
  	makeTraverser(traversers[i]);
  }
  
  return FuncUnit;
  })(jQuery, __m3);
  
  // ## browser/queue.js
  var __m13 = (function(FuncUnit) {
  	/**
  	 * @add FuncUnit
  	 */
  	/**
  	 * True when we are in a callback function (something we pass to a FuncUnit plugin).
  	 */
  	FuncUnit._incallback = false;
  	//where we should add things in a callback
  	var currentPosition = 0,
  		startedQueue = false;
  
  	/**
       * @property FuncUnit.speed F.speed()
       * @parent utilities
  	 * A global speed setting for actions. Defaults to 0 milliseconds.
  	 */
  	FuncUnit.speed = 0;
  	/**
       * @property FuncUnit.timeout F.timeout()
       * @parent utilities
  	 * A global timeout value for wait commands.  Defaults to 10 seconds.
  	 */
  	FuncUnit.timeout = 10000;
  	/**
  	 * @hide
  	 * @property FuncUnit._queue _queue
     * @parent utilities
  	 * A queue of methods.  Each method in the queue are run in order.  After the method is complete, it 
  	 * calls FuncUnit._done, which pops the next method off the queue and runs it.
  	 */
  	FuncUnit._queue = [];
  	/**
  	 * @hide
  	 * Logic that determines if this next query needs to be sync, or if we can optimize it.
  	 * Returns false if there are actual actions in the queue, returns true if the only queued methods are 
  	 * S methods. If the only method is an S query, remove it from the queue.
  	 */
  	FuncUnit._needSyncQuery = function(){
  		// if only method is query, need sync
  		if(FuncUnit._queue.length === 1){
  			if(FuncUnit._queue[0].type === "query"){
  				FuncUnit._queue = [];
  				return true;
  			}
  		}
  		// if empty queue, need sync
  		if(FuncUnit._queue.length === 0){
  			return true;
  		}
  		return false
  	}
  	/**
  	 * @hide
  	 * Return last item in the queue.
  	 */
  	FuncUnit._lastQueuedItem = function(){
  		if(!FuncUnit._queue.length){
  			return null;
  		}
  		return FuncUnit._queue[FuncUnit._queue.length-1];
  	}
  	/**
  	 * @hide
  	 * Return true if there are already async methods queued.  If true, getters need throw errors.
  	 */
  	FuncUnit._haveAsyncQueries = function(){
  		for(var i=0; i < FuncUnit._queue.length; i++){
  			if(FuncUnit._queue[i].type === "action" || FuncUnit._queue[i].type === "wait")
  				return true;
  		}
  		return false;
  	}
  	FuncUnit.
  	/**
       * @parent utilities
       * @function FuncUnit.add F.add()
       * @signature `add(handler)`
  	 * Adds a function to the queue.
  	 * @param {Object} handler An object that contains the method to run along with other properties:
  
   - method : the method to be called.  It will be provided a success and error function to call
   - success : an optional callback to be called after the function is done
   - error : an error message if the command fails
   - timeout : the time until success should be called
   - bind : an object that will be 'this' of the success
   - type: the type of method (optional)
  
  	 */
  	add = function(handler){
  		//if we are in a callback, add to the current position
  		if (FuncUnit._incallback) {
  			FuncUnit._queue.splice(currentPosition, 0, handler);
  			currentPosition++;
  		}
  		else {
  			//add to the end
  			FuncUnit._queue.push(handler);
  		}
  		//if our queue has just started, stop qunit
  		//call done to call the next command
          if (FuncUnit._queue.length == 1 && ! FuncUnit._incallback) {
  			FuncUnit.unit.pauseTest();
      		setTimeout(FuncUnit._done, 13)
          }
  	}
  	var currentEl;
  	/**
       * @hide
       * @parent utilities
       * @function FuncUnit._done _done
       * @signature `_done(handler)`
       *
  	 * Every queued method calls this when its complete.  It gets the next function from the queue and calls it.
  	 * @param {Object} el the current jQuery collection
  	 * @param {Object} selector
  	 */
  	FuncUnit._done = function(el, selector){
  		var next, 
  			timer,
  			speed = FuncUnit.speed || 0;
  
  		// TODO: we need to clarify the easing api
  		if(FuncUnit.speed === 'slow'){
  			speed = 500;
  		}
  		if (FuncUnit._queue.length > 0) {
  			next = FuncUnit._queue.shift();
  			currentPosition = 0;
  			// set a timer that will error
  			
  			//call next method
  			setTimeout(function(){
  				timer = setTimeout(function(){
  						next.stop && next.stop();
  						if(typeof next.error === "function"){
  							next.error();
  						} else {
  							FuncUnit.unit.assertOK(false, next.error);
  						}
  						FuncUnit._done();
  					}, 
  					(next.timeout || FuncUnit.timeout) + speed)
  				// if the last successful method had a collection, save it
  				if(el && el.jquery){
  					currentEl = el;
  				}
  				// make the new collection the last successful collection
  				if(currentEl){
  					next.bind = currentEl;
  				}
  				next.selector = selector;
  				next.method(	//success
  					function(el){
  						if(el && el.jquery){
  							next.bind = el;
  						}
  						//make sure we don't create an error
  						clearTimeout(timer);
  						
  						//mark in callback so the next set of add get added to the front
  						
  						FuncUnit._incallback = true;
  						if (next.success) {
  							// callback's "this" is the collection
  							next.success.apply(next.bind, arguments);
  						}
  						FuncUnit._incallback = false;
  						
  						
  						FuncUnit._done(next.bind, next.selector);
  					}, //error
  					function(message){
  						clearTimeout(timer);
  						FuncUnit.unit.assertOK(false, message);
  						FuncUnit._done();
  					})
  				
  				
  			}, speed);
  			
  		}
  		else {
  			FuncUnit.unit.resumeTest();
  		}
  	}
  
  	return FuncUnit;
  })(__m3);
  
  // ## browser/waits.js
  var __m14 = (function($, FuncUnit) {
  /**
   * @add FuncUnit
   */
  FuncUnit.
  /**
   *
   * @function FuncUnit.wait F.wait()
   * @parent waits
   * @signature `wait(time, success)`
   * Waits a timeout before running the next command.  Wait is an action and gets 
   * added to the queue.
   * @codestart
   * F.wait(100, function(){
   *   equals(F('#foo').innerWidth(), 100, "innerWidth is 100");
   * })
   * @codeend
   * @param {Number} [time] The timeout in milliseconds.  Defaults to 5000.
   * @param {Function} [success] A callback that will run 
   * 		after the wait has completed, 
   * 		but before any more queued actions.
   */
  wait = function(time, success){
  	if(typeof time == 'function'){
  		success = time;
  		time = undefined;
  	}
  	time = time != null ? time : 5000
  	FuncUnit.add({
  		method : function(success, error){
  			setTimeout(success, time)
  		},
  		success : success,
  		error : "Couldn't wait!",
  		timeout : time + 1000
  	});
  	return this;
  }
  
  FuncUnit.
  /**
   * @function FuncUnit.branch F.branch()
   * @parent waits
   * @signature `branch(check1, success1, check2, success2)`
   * Uses 2 checker methods to see which success function to call.  This is a way to conditionally
   * run one method if you're unsure about the conditions of your page, without causing a test
   * failure.  For example, this is useful for login steps, if you're not sure whether the app
   * is logged in.
   *
   * @codestart
   *   F.branch(function(){
   *    	return (F("#exists").size() > 0);
   *    }, function(){
   *    	ok(true, "found exists")
   *    }, function(){
   *    	return (F("#notexists").size() > 0);
   *    }, function(){
   *    	ok(false, "found notexists")
   *    });
   * @codeend
   *
   * @param {Function} check1 a checker function that, if it returns true, causes success1 to be called
   * @param {Function} success1 a function that runs when check1 returns true
   * @param {Function} check2 a checker function that, if it returns true, causes success2 to be called
   * @param {Function} success2 a function that runs when check2 returns true
   * @param {Number} timeout if neither checker returns true before this timeout, the test fails
   */
  branch = function(check1, success1, check2, success2, timeout){
  	FuncUnit.repeat({
  		method : function(print){
  			print("Running a branch statement")
  			if(check1()){
  				success1();
  				return true;
  			}
  			if(check2()){
  				success2();
  				return true;
  			}
  		},
  		error : "no branch condition was ever true",
  		timeout : timeout,
  		type: "branch"
  	})
  }
  
  /**
   *
   * @function FuncUnit.repeat F.repeat()
   * @parent waits
   * @signature `repeat()`
   * Takes a function that will be called over and over until it is successful.
   * method : function(){},
  	success : success,
  	error : errorMessage,
  	timeout : timeout,
  	bind: this
   */
  FuncUnit.repeat = function(options){
  	
  	var interval,
  		stopped = false	,
  		stop = function(){
  			clearTimeout(interval)
  			stopped = true;
  		};
  	FuncUnit.add({
  		method : function(success, error){
  			options.bind = this.bind;
  			options.selector = this.selector;
  			var printed = false,
  				print = function(msg){
  					if(!printed){
  						printed = true;
  					}
  				}
  			interval = setTimeout(function(){
  				var result = null;
  				try {
  					result = options.method(print)
  				} 
  				catch (e) {
  					//should we throw this too error?
  				}
  				
  				if (result) {
  					success(options.bind);
  				}else if(!stopped){
  					interval = setTimeout(arguments.callee, 10)
  				}
  				
  			}, 10);
  			
  			
  		},
  		success : options.success,
  		error : options.error,
  		timeout : options.timeout,
  		stop : stop,
  		bind : options.bind,
  		type: options.type
  	});
  	
  }
  
  
  /**
   *
   * @function FuncUnit.animationEnd F.animationEnd()
   * @parent waits
   * @signature `animationEnd()`
   * Waits until all animations in the page have completed.  Only works
   * if the tested page has jQuery present.
   */
  FuncUnit.animationEnd = function(){
  F("body").wait(200).size(function(){
  		return F.win.$(':animated').length === 0;
  	});
  };
  
  FuncUnit.animationsDone = FuncUnit.animationEnd;
  
  $.extend(FuncUnit.prototype, {
  	/**
       * @function FuncUnit.prototype.exists .exists()
       * @parent waits
       * @signature `exists([timeout] [,success] [,message])`
  	 * Waits until an element exists before running the next action.
  	 * @codestart
  	 * //waits until #foo exists before clicking it.
  	 *F("#foo").exists().click()
  	 * @codeend
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a success that is run after the selector exists, but before the next action.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {FuncUnit} returns the funcUnit for chaining. 
  	 */
  	exists: function( timeout, success, message ) {
  		var logMessage = "Waiting for '"+this.selector+"' to exist";
  		if(timeout === false){ // pass false to suppress this wait (make it not print any logMessage)
  			logMessage = false
  		}
  		return this.size({
  			condition: function(size){
  				return size > 0;
  			},
  			timeout: timeout,
  			success: success,
  			message: message,
  			errorMessage: "Exist failed: element with selector '"+this.selector+"' not found",
  			logMessage: logMessage
  		})
  	},
  	/**
       * @function FuncUnit.prototype.missing .missing()
       * @parent waits
       * @signature `missing([timeout] [,success] [,message])`
  	 * Waits until no elements are matched by the selector.  Missing is equivalent to calling
  	 * <code>.size(0, success);</code>
  	 * @codestart
  	 * //waits until #foo leaves before continuing to the next action.
  	 *F("#foo").missing()
  	 * @codeend
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that is run after the selector exists, but before the next action
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return {FuncUnit} returns the funcUnit for chaining. 
  	 */
  	missing: function( timeout,success, message ) {
  		return this.size(0, timeout, success, message)
  	},
  	/**
       * @function FuncUnit.prototype.visible .visible()
       * @parent waits
       * @signature `visible([timeout] [,success] [,message])`
  	 * Waits until the funcUnit selector is visible.  
  	 * @codestart
  	 * //waits until #foo is visible.
  	 *F("#foo").visible()
  	 * @codeend
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that runs after the funcUnit is visible, but before the next action.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return [funcUnit] returns the funcUnit for chaining.
  	 */
  	visible: function( timeout, success, message ) {
  		var self = this,
  			sel = this.selector,
  			ret;
  		return this.size(function(size){
  			return this.is(":visible") === true;
  		}, timeout, success, message)
  	},
  	/**
       * @function FuncUnit.prototype.invisible .invisible()
       * @parent waits
       * @signature `invisible([timeout] [,success] [,message])`
  	 * Waits until the selector is invisible.  
  	 * @codestart
  	 * //waits until #foo is invisible.
  	 *F("#foo").invisible()
  	 * @codeend
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that runs after the selector is invisible, but before the next action.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 * @return [funcUnit] returns the funcUnit selector for chaining.
  	 */
  	invisible: function( timeout, success, message ) {
  		var self = this,
  			sel = this.selector,
  			ret;
  		return this.size(function(size){
  			return this.is(":visible") === false;
  		}, timeout, success, message)
  	},
  	/**
       * @function FuncUnit.prototype.wait .wait()
       * @parent waits
       * @signature `wait([checker] [,timeout] [,success] [,message])`
       *
  	 * Waits until some condition is true before calling the next action.  Or if no checker function is provided, waits a 
  	 * timeout before calling the next queued method.  This can be used as a flexible wait condition to check various things in the tested page:
  	 * @codestart
  	 *F('#testData').wait(function(){
  	 * 	 return F.win.$(this).data('idval') === 1000;
  	 * }, "Data value matched");
  	 * @codeend
  	 * @param {Number|Function} [checker] a checking function.  It runs repeatedly until the condition becomes true or the timeout period passes.  
  	 * If a number is provided, a time in milliseconds to wait before running the next queued method.
  	 * @param {Number} [timeout] overrides FuncUnit.timeout.  If provided, the wait will fail if not completed before this timeout.
  	 * @param {Function} [success] a callback that will run after this action completes.
  	 * @param {String} [message] if provided, an assertion will be passed when this wait condition completes successfully
  	 */
  	wait: function( checker, timeout, success, message ) {
  		if(typeof checker === "number"){
  			timeout = checker;
  			FuncUnit.wait(timeout, success)
  			return this;	
  		} else {
  			return this.size(checker, timeout, success, message)
  		}
  	},
  	/**
       * @function FuncUnit.prototype.then .then()
       * @parent waits
       * @signature `then(success)`
  	 * Calls the success function after all previous asynchronous actions have completed.  Then
  	 * is called with the funcunit object.
  	 * @param {Function} success
  	 */
  	then : function(success){
  		var self = this;
  		FuncUnit.wait(0, function(){
  			success.call(this, this);
  		});
  		return this;
  	}
  })
  return FuncUnit;
  })(jQuery, __m3);
  
  // ## funcunit.js
  var __m1 = (function(Syn, FuncUnit) {
  	window.FuncUnit = window.S = window.F = FuncUnit;
  	
  	return FuncUnit;
  })(Syn, __m3, __m6, __m9, __m10, __m11, __m12, __m13, __m14);
  
  }(window);