navigator-js.js

this.navigatorjs = this.navigatorjs || {};

(function() {
	var AsynchResponders = function() {
		this._responders = [];
	};

	//PUBLIC API
	AsynchResponders.prototype = {
		getLength: function() {
			return this._responders.length;
		},

		isBusy: function() {
			return this.getLength() > 0;
		},

		hasResponder: function(responder) {
			return this._responders.indexOf(responder) != -1;
		},

		addResponder: function(responder) {
			this._responders.push(responder);
		},

		addResponders: function(additionalRespondersArray) {
			if (additionalRespondersArray && additionalRespondersArray instanceof Array && additionalRespondersArray.length) {
				this._responders = this._responders.concat(additionalRespondersArray);
			}
		},

		takeOutResponder: function(responder) {
			var index = this._responders.indexOf(responder);
			if (index != -1) {
				this._responders.splice(index, 1);
				return true;
			}

			return false;
		},

		reset: function() {
			if (this._responders.length > 0) {
				console.warn("Resetting too early? Still have responders marked for asynchronous tasks");
			}

			this._responders = [];
		}
	};

	navigatorjs.AsynchResponders = AsynchResponders;
}());;this.navigatorjs = this.navigatorjs || {};

(function($) {

	/**
	 * History manager for the navigatorjs.Navigator
	 * 
	 * @example 
	 *	<code>
	 *		
	 *		// Create the normal navigator
	 *		var navigator = new navigatorjs.Navigator();
	 *		
	 *		// Create the history and supply the navigator it should manage
	 *		var history = new navigatorjs.History(navigator);
	 *
	 *		// Navigate to states as you normally would
	 *		navigator.request('/my/state');
	 *		
	 *		// Go back in time
	 *		history.back();
	 *		
	 *	</code>
	 *
	 * @author Laurent van Dommelen
	 * @created 11 oct 2013
	 * 
	 * @param {navigatorjs.Navigator} navigator
	 */
	var History = function(navigator) {

		// Bind the methods to this scope
		navigatorjs.utils.AutoBind(this, this);

		// Initialize the instance
		this._initialize(navigator);
	};

	// Default max history length, don't change this, 
	// change the maxLength instance property
	History.MAX_HISTORY_LENGTH = 100;

	// Navigation direction types
	History.DIRECTION_BACK = -1;
	History.DIRECTION_NORMAL = 0;
	History.DIRECTION_FORWARD = 1;

	/**
	 * Instance properties
	 */
	History.prototype = {

		// The navigator it is controlling
		_navigator: null,

		// The history, last state is at start of Array
		_history: null,

		// The current position in history
		_historyPosition: 0,

		// The navigator doesn't know anything about going forward or back.
		// Therefore, we need to keep track of the direction.
		// This is changed when the forward or back methods are called.
		_navigationDirection: History.DIRECTION_NORMAL,

		// The max number of history states
		maxLength: History.MAX_HISTORY_LENGTH,

		/**
		 * Create the history manager. When navigating back and forword, the history is maintained. 
		 * It is truncated when navigating to a state naturally
		 * 
		 * @param {navigatorjs.Navigator} navigator
		 * @param {Object} [options]
		 */
		_initialize: function(navigator, options) {

			// Setup the options
			if (options) {
				this.maxLength = options.maxLength || this.maxLength;
			}

			// Create the history array containing the NavigationState objects
			this._history = [];

			// Listen to changes on the navigator
			this._navigator = navigator;
			this._navigator.on(navigatorjs.NavigatorEvent.STATE_CHANGED, this._handleStateChange);
		},

		/**
		 * Go back in the history
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {Boolean} Returns false if there was no previous state
		 */
		back: function(steps) {

			// Check if we know history
			if (this._historyPosition == this._history.length - 1) {
				return false;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Set the history position and navigate to it
			this._historyPosition = Math.min(this._history.length - 1, this._historyPosition + steps);
			this._navigationDirection = History.DIRECTION_BACK;
			this._navigateToCurrentHistoryPosition();
			return true;
		},

		/**
		 * Go forward in the history
		 * 
		 * @param {Number} [steps=1] The number of steps to go forward in history
		 * @return {Boolean} Returns false if there was no next state
		 */
		forward: function(steps) {
			if (this._historyPosition === 0) {
				return false;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Set the history position and navigate to it
			this._historyPosition = Math.max(0, this._historyPosition - steps);
			this._navigationDirection = History.DIRECTION_FORWARD;
			this._navigateToCurrentHistoryPosition();
			return true;
		},

		/**
		 * Go back in the history and return that NavigationState
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getPreviousState: function(steps) {

			// Cannot go beyond the first entry in history
			if (this._history.length === 0 || this._historyPosition == Math.max(0, this._history.length - 1)) {
				return null;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Fetch the requested state in history
			var position = Math.min(this._history.length - 1, Math.max(0, this._historyPosition + steps));
			return this._history[position];
		},

		/**
		 * Go forward in the history and return that NavigationState
		 * 
		 * @param {Number} [steps=1] The number of steps to go back in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getNextState: function(steps) {

			// Cannot look into the future
			if (this._history.length === 0 || this._historyPosition === 0) {
				return null;
			}

			// Set to 1 by default
			steps = steps || 1;

			// Fetch the requested state in history
			var position = Math.max(0, this._historyPosition - steps);
			return this._history[position];
		},

		/**
		 * Fetch the current NavigationState
		 * 
		 * @return {navigatorjs.NavigationState}
		 */
		getCurrentState: function() {
			return this._history[this._historyPosition] || null;
		},

		/**
		 * Clear the navigation history
		 */
		clearHistory: function() {
			this._history = [];
			this._historyPosition = 1;
		},

		/**
		 * Get the full history
		 * 
		 * @return {Array} List of navigatorjs.NavigationStates
		 */
		all: function() {
			return this._history;
		},

		/**
		 * Get the state by historyposition
		 * 
		 * @param {Number} position The position in history
		 * @return {navigatorjs.NavigationState} The found state or null if no state was found
		 */
		getStateByPosition: function (position) {
			if (position < 0 || position > this._history.length - 1) {
				return null;
			}
			return this._history[position];
		},

		/**
		 * Get the first occurence of a state in the history
		 * 
		 * @param {navigatorjs.NavigationState} state The NavigationState in history
		 * @return {Number} The found position or false if not found
		 */
		getPositionByState: function(state) {
			return this.getPositionByPath(state.getPath());
		},

		/**
		 * Find the first occurence of the path in the history
		 * 
		 * @param {String} path
		 * @return {Number} The index or false if not found
		 */
		getPositionByPath: function(path) {
			var count = this.getLength();
			for (var i = 0; i < count; i++) {
				if (this._history[i].getPath() == path) {
					return i;
				}
			}
			return false;
		},

		/**
		 * Get the number of items in the history
		 * 
		 * @return {Number}
		 */
		getLength: function() {
			return this._history.length;
		},

		/**
		 * Tell the navigator to go the current historyPosition
		 */
		_navigateToCurrentHistoryPosition: function() {
			var newState = this._history[this._historyPosition];
			this._navigator.request(newState);
		},

		/**
		 * Check what to do with the new state
		 *
		 * @param {Object} event
		 * @param {Object} update
		 */
		_handleStateChange: function(event, update) {
			var state = update.state;

			switch (this._navigationDirection) {

				case History.DIRECTION_BACK:
					this._navigationDirection = History.DIRECTION_NORMAL;
					break;

				case History.DIRECTION_NORMAL:

					// Strip every history state before current
					this._history.splice(0, this._historyPosition);

					// Add the state at the beginning of the history array
					this._history.unshift(state);
					this._historyPosition = 0;

					// Truncate the history to the max allowed items
					this._history.length = Math.min(this._history.length, this.maxLength);
					break;

				case History.DIRECTION_FORWARD:
					this._navigationDirection = History.DIRECTION_NORMAL;
					break;
			}
		}
	};

	// Copy the History object to the navigatorjs namespace
	navigatorjs.History = History;
}(jQuery));;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigationBehaviors = {};

/**
 * Will show when the state matches, will hide when it doesn't
 */
this.navigatorjs.NavigationBehaviors.SHOW = "show";
/**
 * Will hide when the state matches, even if it has a show on a higher level
 */
this.navigatorjs.NavigationBehaviors.HIDE = "hide";
/**
 * Will update before any show method gets called
 */
this.navigatorjs.NavigationBehaviors.UPDATE = "update";
/**
 * Will swap out and in, when the state is changed
 */
this.navigatorjs.NavigationBehaviors.SWAP = "swap";
/**
 * Will ask for validation of the state, if a state can't be validated, it is denied
 */
this.navigatorjs.NavigationBehaviors.VALIDATE = "validate";
/**
 * Will try to add all behaviors, based on the class properties of the responder
 */
this.navigatorjs.NavigationBehaviors.AUTO = "auto";
/**
 * Used for looping through when the AUTO behavior is used.
 */
this.navigatorjs.NavigationBehaviors.ALL_AUTO = ["show", "update", "swap", "validate"];;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigationResponderBehaviors = {};
this.navigatorjs.NavigationResponderBehaviors.IHasStateInitialization = {name: "IHasStateInitialization", methods: ["initializeByNavigator"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidation = {name: "IHasStateValidation", methods: ["validate"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationAsync = {name: "IHasStateValidationAsync", "extends": ["IHasStateValidation"], methods: ["prepareValidation"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationOptional = {name: "IHasStateValidationOptional", "extends": ["IHasStateValidation"], methods: ["willValidate"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateValidationOptionalAsync = {name: "IHasStateValidationOptionalAsync", "extends": ["IHasStateValidationAsync", "IHasStateValidationOptional"], methods: []};
this.navigatorjs.NavigationResponderBehaviors.IHasStateRedirection = {name: "IHasStateRedirection", "extends": ["IHasStateValidation"], methods: ["redirect"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateSwap = {name: "IHasStateSwap", methods: ["willSwapToState", "swapOut", "swapIn"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateTransition = {name: "IHasStateTransition", methods: ["transitionIn", "transitionOut"]};
this.navigatorjs.NavigationResponderBehaviors.IHasStateUpdate = {name: "IHasStateUpdate", methods: ["updateState"]};

this.navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface = function(object, interface) {
	if (object.navigatorBehaviors == undefined || !object.navigatorBehaviors instanceof Array) {
		//The input interface is not set on object's navigatorBehaviors.
		return false;
	}

	var inheritanceChain = navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(interface),
		methodsToBeImplemented = navigatorjs.NavigationResponderBehaviors.getInterfaceMethods(inheritanceChain),
		i, method,
		length = methodsToBeImplemented.length;

	for (i = 0; i < length; i++) {
		method = methodsToBeImplemented[i];

		if (object[method] == undefined || typeof object[method] !== 'function') {
			return false;
		}
	}

	return true;
};

this.navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain = function(interface, existingChain) {
	var chain = existingChain || [],
		extendsArray,
		extendingInterface,
		i, length,
		interfaceObject = navigatorjs.NavigationResponderBehaviors[interface];

	if (interfaceObject == undefined || typeof interfaceObject !== 'object') {
//		console.log('behaviorObject for interface is undefined ', interface );
		return chain;
	}

	chain.push(interface);
	extendsArray = interfaceObject["extends"];
	if (extendsArray == undefined) {
//		console.log('extendsArray for interface is undefined, the chain ends here ', interface, chain);
		return chain;
	}

	length = extendsArray.length;

	for (i = 0; i < length; i++) {
		extendingInterface = extendsArray[i];
		if (chain.indexOf(extendingInterface) == -1) {
			//We did not yet extend this interface, so continue to follow the chain
			navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(extendingInterface, chain);
		}
	}

	return chain;
};

this.navigatorjs.NavigationResponderBehaviors.getInterfaceMethods = function(interfaces) {
	if (interfaces == undefined || !interfaces instanceof Array) {
		//No valid input
		return [];
	}

	var combinedInterfacesChain = [],
		interface, i,
		length = interfaces.length,
		interfaceObject,
		interfaceMethods,
		j, methodsLength, method,
		methods = [];

	for (i = 0; i < length; i++) {
		interface = interfaces[i];
		navigatorjs.NavigationResponderBehaviors.getInterfaceInheritanceChain(interface, combinedInterfacesChain);
	}

	length = combinedInterfacesChain.length;
	for (i = 0; i < length; i++) {
		interface = combinedInterfacesChain[i];
		interfaceObject = navigatorjs.NavigationResponderBehaviors[interface];
		interfaceMethods = interfaceObject.methods;
		if (interfaceObject != undefined && typeof interfaceObject === 'object' && interfaceMethods != undefined && interfaceMethods instanceof Array) {
			methodsLength = interfaceMethods.length;
			for (j = 0; j < methodsLength; j++) {
				method = interfaceMethods[j];
				if (methods.indexOf(method) == -1) {
					methods.push(method);
				}
			}
		}
	}

	return methods;
};;this.navigatorjs = this.navigatorjs || {};

(function() {
	var NavigationState = function(pathStringOrArray) {
		this._path = '';

		if (pathStringOrArray instanceof Array) {
			this.setSegments(pathStringOrArray);
		} else {
			this.setPath(pathStringOrArray);
		}
	};

	NavigationState.make = function(stateOrPath) {
		return stateOrPath instanceof navigatorjs.NavigationState ? stateOrPath : new navigatorjs.NavigationState(stateOrPath);
	};

	NavigationState.prototype = {
		setPath: function(path) {
			this._path = '/' + path.toLowerCase() + '/';
			this._path = this._path.replace(new RegExp("[^-_/A-Za-z0-9* ]", "g"), "");
			this._path = this._path.replace(new RegExp("\/+", "g"), "/");
			this._path = this._path.replace(/\s+/g, "-");

			return this;
		},

		getPath: function() {
			return this._path;
		},

		setSegments: function(segments) {
			this.setPath(segments.join("/"));
		},

		getSegments: function() {
			var segments = this._path.split("/");

			segments.pop();
			segments.shift();

			return segments;
		},

		getSegment: function(index) {
			return this.getSegments()[index];
		},

		getFirstSegment: function() {
			return this.getSegment(0);
		},

		getLastSegment: function() {
			var segments = this.getSegments();
			return this.getSegment(segments.length - 1);
		},

		contains: function(foreignStateOrPathOrArray) {
			if(foreignStateOrPathOrArray instanceof Array) {
				var length = foreignStateOrPathOrArray.length,
					foreignStateOrPath;

				for(i=0; i<length; i++){
					foreignStateOrPath = foreignStateOrPathOrArray[i];
					if(this.contains(foreignStateOrPath)) {
						return true;
					}
				}

				return false;
			}

			foreignStateOrPath = foreignStateOrPathOrArray; //if we get this far, it is a state or path

			var foreignState = NavigationState.make(foreignStateOrPath),
				foreignSegments = foreignState.getSegments(),
				nativeSegments = this.getSegments(),
				foreignSegment, nativeSegment,
				i;

			if (foreignSegments.length > nativeSegments.length) {
				return false;
			}

			for (i = 0; i < foreignSegments.length; i++) {
				foreignSegment = foreignSegments[i];
				nativeSegment = nativeSegments[i];

				if (!(foreignSegment === "*" || nativeSegment === "*") && foreignSegment !== nativeSegment) {
					return false;
				}
			}

			return true;
		},

		equals: function(stateOrPathOrArray) {
			if(stateOrPathOrArray instanceof Array) {
				var i, length = stateOrPathOrArray.length,
					stateOrPath;

				for(i=0; i<length; i++){
					stateOrPath = stateOrPathOrArray[i];
					if(this.equals(stateOrPath)) {
						return true;
					}
				}

				return false;
			}

			stateOrPath = stateOrPathOrArray; //if we get this far, it is a state or path

			var state = NavigationState.make(stateOrPath),
				subtractedState = this.subtract(state);

			if (subtractedState === null) {
				return false;
			}

			return subtractedState.getSegments().length === 0;
		},

		subtract: function(operandStateOrPath) {
			var operand = NavigationState.make(operandStateOrPath),
				subtractedSegments;

			if (!this.contains(operand)) {
				return null;
			}

			subtractedSegments = this.getSegments();
			subtractedSegments.splice(0, operand.getSegments().length);

			return new navigatorjs.NavigationState(subtractedSegments);
		},

		append: function(stringOrState) {
			var path = stringOrState;
			if (stringOrState instanceof NavigationState) {
				path = stringOrState.getPath();
			}
			return this.setPath(this._path + path);
		},

		prepend: function(stringOrState) {
			var path = stringOrState;
			if (stringOrState instanceof NavigationState) {
				path = stringOrState.getPath();
			}
			return this.setPath(path + this._path);
		},

		hasWildcard: function() {
			return this.getPath().indexOf("*") != -1;
		},

		mask: function(sourceStateOrPath) {
			var sourceState = NavigationState.make(sourceStateOrPath),
				unmaskedSegments = this.getSegments(),
				sourceSegments = sourceState.getSegments(),
				length = Math.min(unmaskedSegments.length, sourceSegments.length),
				i;

			for (i = 0; i < length; i++) {
				if (unmaskedSegments[i] === "*") {
					unmaskedSegments[i] = sourceSegments[i];
				}
			}

			return new navigatorjs.NavigationState(unmaskedSegments);
		},

		clone: function() {
			return new navigatorjs.NavigationState(this._path);
		}
	};

	navigatorjs.NavigationState = NavigationState;
}());;this.navigatorjs = this.navigatorjs || {};

(function() {
	//
	var _$eventDispatcher = null;
	//internal namespaces
	var _flow = {};
	var _transition = {};
	var _validation = {};
	var _hidden = {};
	//
	var _currentState = null;
	var _previousState = null;
	var _defaultState = null;
	var _isTransitioning = false;
	//
	var _responders = null; //new navigatorjs.ResponderLists();
	var _respondersByID = null; //{};
	var _statusByResponderID = null; //{};
	var _redirects = null;
	var _disappearingAsynchResponders = null;
	var _appearingAsynchResponders = null;
	var _swappingAsynchResponders = null;
	var _validatingAsynchResponders = null;
	var _preparedValidatingAsynchRespondersStack = null;
	var _inlineRedirectionState = null;
	//
	var _asyncInvalidated = false;
	var _asyncValidated = false;
	var _asyncValidationOccurred = false;
	var _responderIDCount = 0;


	var _modify = function(addition, responder, pathsOrStates, behaviorString) {
		if (_relayModification(addition, responder, pathsOrStates, behaviorString)) {
			return;
		}

		// Using the path variable as dictionary key to break instance referencing.
		var path = navigatorjs.NavigationState.make(pathsOrStates).getPath(),
			list, matchingInterface;

		// Create, store and retrieve the list that matches the desired behavior.
		switch (behaviorString) {
			case navigatorjs.NavigationBehaviors.SHOW:
				matchingInterface = "IHasStateTransition";
				list = _responders.showByPath[path] = _responders.showByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.HIDE:
				matchingInterface = "IHasStateTransition";
				list = _responders.hideByPath[path] = _responders.hideByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.VALIDATE:
				matchingInterface = "IHasStateValidation";
				list = _responders.validateByPath[path] = _responders.validateByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.UPDATE:
				matchingInterface = "IHasStateUpdate";
				list = _responders.updateByPath[path] = _responders.updateByPath[path] || [];
				break;
			case navigatorjs.NavigationBehaviors.SWAP:
				matchingInterface = "IHasStateSwap";
				list = _responders.swapByPath[path] = _responders.swapByPath[path] || [];
				break;
			default:
				throw new Error("Unknown behavior: " + behaviorString);
		}

		//TODO: Build in more strict validation?
		if (!navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, matchingInterface)) {
			throw new Error("Responder " + responder + " should implement " + matchingInterface + " to respond to " + behaviorString);
		}
		if (addition) {
			// add
			if (list.indexOf(responder) < 0) {
				list.push(responder);

				if (responder.__navigatorjs == undefined) {
					//Create new hidden navigatorjs data
					_responderIDCount++;
					responder.__navigatorjs = {id: _responderIDCount};
					_respondersByID[responder.__navigatorjs.id] = responder;
				}

				// If the responder has no status yet, initialize it to UNINITIALIZED:
				_statusByResponderID[responder.__navigatorjs.id] = _statusByResponderID[responder.__navigatorjs.id] || navigatorjs.transition.TransitionStatus.UNINITIALIZED;
			} else {
				return;
			}
		} else {
			// remove
			var index = list.indexOf(responder);
			if (index >= 0) {
				list.splice(index, 1);

				delete _statusByResponderID[responder.__navigatorjs.id];
				delete _respondersByID[responder.__navigatorjs.id];
			} else {
				return;
			}

			if (matchingInterface == "IHasStateSwap" && _responders.swappedBefore[responder]) {
				// cleanup after the special swap case
				delete _responders.swappedBefore[responder];
			}
		}

		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
	};

	var _relayModification = function(addition, responder, pathsOrStates, behaviorString) {
		if (!responder) {
			throw new Error("add: responder is null");
		}

		var i, length;

		if (pathsOrStates instanceof Array) {
			length = pathsOrStates.length;
			for (i = 0; i < length; i++) {
				_modify(addition, responder, pathsOrStates[i], behaviorString);
			}
			return true;
		}

		behaviorString = behaviorString || navigatorjs.NavigationBehaviors.AUTO;
		if (behaviorString == navigatorjs.NavigationBehaviors.AUTO) {
			length = navigatorjs.NavigationBehaviors.ALL_AUTO.length;
			for (i = 0; i < length; i++) {
				try {
					_modify(addition, responder, pathsOrStates, navigatorjs.NavigationBehaviors.ALL_AUTO[i]);
				} catch (e) {
					// ignore 'should implement xyz' errors
				}
			}
			return true;
		}

		return false;
	};

	/**
	 * Check if there is a responder registered for a given state. Optionally check for implementation of a given
	 * interface. This allows you to check if there was something mapped to a state which implements
	 * "IHasStateValidationAsync" for example.
	 */
	var _hasRegisteredResponder = function(state, optionalInterface) {
		var i, length = _responders.all.length,
			j, respondersLength, responder,
			responders, respondersForPath, path;
		
		for(i=0; i<length; i++) {
			responders = _responders.all[i];
			for(path in responders) {
				if(state.equals(path)) {

					if(optionalInterface) {
						//Loop through all responders and check if it implements the given interface
						respondersForPath = responders[path];
						respondersLength = respondersForPath.length;
						for(j=0; j<respondersLength; j++) {
							responder = respondersForPath[j];
							if(navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, optionalInterface)) {
								return true;
							}
						}
					} else {
						return true;
					}

					return true;
				}
			}
		}

		return false;
	};

	var _request = function(pathOrState) {
		if (pathOrState == null) {
			// logger.error("Requested a null state. Aborting request.");
			return;
		}

		var requestedState,
			path,
			fromState,
			toState;

		// Store and possibly mask the requested state
		requestedState = navigatorjs.NavigationState.make(pathOrState);
		if (requestedState.hasWildcard()) {
			requestedState = requestedState.mask(_currentState || _defaultState);
		}

		// Check for exact match of the requested and the current state
		if (_currentState && _currentState.getPath() == requestedState.getPath()) {
			//logger.info("Already at the requested state: " + requested);
			return;
		}

		if (_redirects) {
			for (path in _redirects) {
				fromState = new navigatorjs.NavigationState(path);
				if (fromState.equals(requestedState)) {
					toState = navigatorjs.NavigationState.make(_redirects[path]);
					//logger.info("Redirecting " + from + " to " + to);
					_request(toState);
					return;
				}
			}
		}

		// this event makes it possible to add responders just in time to participate in the validation process.
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.STATE_REQUESTED, {state: requestedState});

		// Inline redirection is reset with every request call.
		// It can be changed by a responder implementing the IHasStateRedirection interface.
		_inlineRedirectionState = null;

		_performRequestCascade(requestedState);
	};

	var _performRequestCascade = function(requestedState, startAsyncValidation) {
		if (!_defaultState) { throw new Error("No default state set. Call start() before the first request!"); }
		// Request cascade starts here.
		//
//		console.groupEnd();
//		console.group('_performRequestCascade', requestedState.getPath(), startAsyncValidation);
		if (requestedState.getPath() == _defaultState.getPath() && !_defaultState.hasWildcard()) {
//			console.log('exact match');
			// Exact match on default state bypasses validation.
			_grantRequest(_defaultState);
		} else if (_asyncValidationOccurred && (_asyncValidated && !_asyncInvalidated)) {
//			console.log('Async operation completed');
			// Async operation completed
			_grantRequest(requestedState);
		} else if (_validate(requestedState, true, startAsyncValidation)) {
//			console.log('Any other state needs to be validated.');
			// Any other state needs to be validated.
			_grantRequest(requestedState);
		} else if (_validatingAsynchResponders && _validatingAsynchResponders.isBusy()) {
//			console.log('Waiting for async validation.');
			// Waiting for async validation.
			// FIXME: What do we do in the mean time, dispatch an event or sth?
			//logger.notice("waiting for async validation to complete");
		} else if (startAsyncValidation && _asyncValidationOccurred) {
//			console.log('any async prepration happened instantaneuously');
			// any async prepration happened instantaneuously
		} else if (_inlineRedirectionState) {
//			console.log('_inlineRedirectionState');
			_request(_inlineRedirectionState);
		} else if (_currentState) {
//			console.log('_inlineRedirectionState');
			// If validation fails, the notifyStateChange() is called with the current state as a parameter,
			// mainly for subclasses to respond to the blocked navigation (e.g. SWFAddress).
			_notifyStateChange(_currentState);
		} else if (requestedState.hasWildcard()) {
//			console.log('wildcard error');
			// If we get here, after validateWithWildcards has failed, this means there are still
			// wildcards in the requested state that didn't match the previous state. This,
			// unfortunately means your application has a logic error. Go fix it!
			throw new Error("Check wildcard masking: " + requestedState.getPath());
		} else if (_defaultState) {
//			console.log('everything failed, use default state');
			// If all else fails, we'll put up the default state.
			_grantRequest(_defaultState);
		} else {
//			console.log('everything failed without default state');
			// If you don't provide a default state, at least make sure your first request makes sense!
			throw new Error("First request is invalid: " + requestedState.getPath());
		}
	};

	var _grantRequest = function(state) {
		_asyncInvalidated = false;
		_asyncValidated = false;
		_previousState = _currentState;
		_currentState = state;

		_notifyStateChange(_currentState);

		_flow.startTransition();
	};

	var _notifyStateChange = function(state) {
		//logger.notice(state);

		// Do call the super.notifyStateChange() when overriding.
		if (state != _previousState) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.STATE_CHANGED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID, state: _currentState});
		}
	};

	// FLOW NAMESPACE START
	_flow.startTransition = function() {
		_isTransitioning = true;
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STARTED);

		_disappearingAsynchResponders = new navigatorjs.AsynchResponders();
		_disappearingAsynchResponders.addResponders(_flow.transitionOut());

		if (!_disappearingAsynchResponders.isBusy()) {
			_flow.performUpdates();
		}
	};

	_flow.transitionOut = function() {
		var respondersToShow = _getRespondersToShow(),
			responderID,
			responder,
			waitForResponders = [],
			i;

		// This initialize call is to catch responders that were put on stage to show,
		// yet still need to wait for async out transitions before they actually transition in.
		_initializeIfNeccessary(respondersToShow);

		for (responderID in _statusByResponderID) {
			responder = _respondersByID[responderID];
			if (respondersToShow.indexOf(responder) == -1) {
				// if the responder is not already hidden or disappearing, trigger the transitionOut:
				if (navigatorjs.transition.TransitionStatus.HIDDEN < _statusByResponderID[responderID] && _statusByResponderID[responderID] < navigatorjs.transition.TransitionStatus.DISAPPEARING &&
					//We could also not be hidden or disappearing but performing a state swap.
					navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateTransition")) {

					_statusByResponderID[responderID] = navigatorjs.transition.TransitionStatus.DISAPPEARING;
					waitForResponders.push(responder);

					//use namespace transition;
					//console.log('_flow -> transitionOut', responder);
					responder.transitionOut(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.HIDDEN, navigatorjs.NavigationBehaviors.HIDE, this, _transition).call);
				} else {
					// already hidden or hiding
				}
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = waitForResponders.length; --i >= 0;) {
			if (_statusByResponderID[waitForResponders[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.HIDDEN) {
				waitForResponders.splice(i, 1);
			}
		}

		if (waitForResponders.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return waitForResponders;
	};

	_flow.performUpdates = function() {
		_disappearingAsynchResponders.reset();

		var path, state, list, i, responder;

		for (path in _responders.updateByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				list = _responders.updateByPath[path];

				_initializeIfNeccessary(list);

				// check for existing validators.
				for (i = 0; i < list.length; i++) {
					responder = list[i];
					responder.updateState(_currentState.subtract(state), _currentState);
				}
			}
		}

		_flow.startTransitionIn();
	};

	_flow.startTransitionIn = function() {
		_appearingAsynchResponders = new navigatorjs.AsynchResponders();
		_appearingAsynchResponders.addResponders(_flow.transitionIn());

		if (!_appearingAsynchResponders.isBusy()) {
			_flow.startSwapOut();
		}
	};

	_flow.transitionIn = function() {
		var respondersToShow = _getRespondersToShow(),
			respondersToWaitFor = [],
			responder,
			status,
			i;

		_initializeIfNeccessary(respondersToShow);

		//for each (var responder : IHasStateTransition in respondersToShow) {
		for (i = 0; i < respondersToShow.length; i++) {
			responder = respondersToShow[i];
			status = _statusByResponderID[responder.__navigatorjs.id];

			if (status < navigatorjs.transition.TransitionStatus.APPEARING || navigatorjs.transition.TransitionStatus.SHOWN < status) {
				// then continue with the transitionIn() call.
				_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.APPEARING;
				respondersToWaitFor.push(responder);

				//use namespace transition;
				responder.transitionIn(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.SHOWN, navigatorjs.NavigationBehaviors.SHOW, this, _transition).call);
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = respondersToWaitFor.length; --i >= 0;) {
			if (_statusByResponderID[respondersToWaitFor[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.SHOWN) {
				respondersToWaitFor.splice(i, 1);
			}
		}

		if (respondersToWaitFor.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return respondersToWaitFor;
	};

	_flow.startSwapOut = function() {
		_swappingAsynchResponders = new navigatorjs.AsynchResponders();
		_swappingAsynchResponders.addResponders(_flow.swapOut());

		if (!_swappingAsynchResponders.isBusy()) {
			_flow.swapIn();
		}
	};

	_flow.swapOut = function() {
		_appearingAsynchResponders.reset();

		var waitForResponders = [],
			path, state,
			swapByPathList,
			responder,
			i,
			truncatedState;

		for (path in _responders.swapByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				swapByPathList = _responders.swapByPath[path];

				_initializeIfNeccessary(swapByPathList);

				// check for existing swaps.
				for (i = 0; i < swapByPathList.length; i++) {
					responder = swapByPathList[i];
					if (!_responders.swappedBefore[responder]) {
						continue;
					}

					truncatedState = _currentState.subtract(state);
					if (responder.willSwapToState(truncatedState, _currentState)) {
						_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.SWAPPING;
						waitForResponders.push(responder);

						//use namespace transition;
						responder.swapOut(new navigatorjs.transition.TransitionCompleteDelegate(responder, navigatorjs.transition.TransitionStatus.SHOWN, navigatorjs.NavigationBehaviors.SWAP, this, _transition).call);
					}
				}
			}
		}

		// loop backwards so we can splice elements off the array while in the loop.
		for (i = waitForResponders.length; --i >= 0;) {
			if (_statusByResponderID[waitForResponders[i].__navigatorjs.id] == navigatorjs.transition.TransitionStatus.SHOWN) {
				waitForResponders.splice(i, 1);
			}
		}

		if (waitForResponders.length > 0) {
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		return waitForResponders;
	};

	_flow.swapIn = function() {
		_swappingAsynchResponders.reset();

		var path,
			state,
			swapByPathList,
			responder,
			truncatedState,
			i;

		for (path in _responders.swapByPath) {
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (_currentState.contains(state)) {
				// the lookup path is contained by the new state.
				swapByPathList = _responders.swapByPath[path];

				_initializeIfNeccessary(swapByPathList);

				// check for existing swaps.
				//for each (var responder : IHasStateSwap in swapByPathList) {
				for (i = 0; i < swapByPathList.length; i++) {
					responder = swapByPathList[i];
					truncatedState = _currentState.subtract(state);
					if (responder.willSwapToState(truncatedState, _currentState)) {
						_responders.swappedBefore[responder] = true;
						responder.swapIn(truncatedState, _currentState);
					}
				}
			}
		}

		_flow.finishTransition();
	};

	_flow.finishTransition = function() {
		_isTransitioning = false;
		_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_FINISHED);
	};
	// FLOW NAMESPACE END

	// TRANSITION NAMESPACE START
	_transition.notifyComplete = function(responder, status, behavior) {
		if (_statusByResponderID[responder.__navigatorjs.id]) {
			_statusByResponderID[responder.__navigatorjs.id] = status;
			_$eventDispatcher.trigger(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, {statusByResponderID: _statusByResponderID, respondersByID: _respondersByID});
		}

		var asynchResponders,
			callbackMethod;

		switch (behavior) {
			case navigatorjs.NavigationBehaviors.HIDE:
				asynchResponders = _disappearingAsynchResponders;
				callbackMethod = _flow.performUpdates;
				break;
			case navigatorjs.NavigationBehaviors.SHOW:
				asynchResponders = _appearingAsynchResponders;
				callbackMethod = _flow.startSwapOut;
				break;
			case navigatorjs.NavigationBehaviors.SWAP:
				asynchResponders = _swappingAsynchResponders;
				callbackMethod = _flow.swapIn;
				break;
			default:
				throw new Error("Don't know how to handle notification of behavior " + behavior);
		}

		// If the notifyComplete is called instantly, the array of asynchronous responders is not yet assigned, and therefore not busy.
		if (asynchResponders.isBusy()) {
			asynchResponders.takeOutResponder(responder);

			// isBusy counts the number of responders, so it might have changed after takeOutResponder().
			if (!asynchResponders.isBusy()) {
				callbackMethod();
			} else {
				//logger.notice("waiting for " + asynch.length + " responders to " + behavior);
			}
		}
	};
	// TRANSITION NAMESPACE END

	// HIDDEN NAMESPACE START
	_hidden.hasResponder = function(responder) {
		if (_statusByResponderID[responder.__navigatorjs.id]) {return true;}

		var respondersByPath,
			existingResponders,
			i, j;

		for (i = 0; i < _responders.all.length; i++) {
			respondersByPath = _responders.all[i];
			for (j = 0; j < respondersByPath.length; j++) {
				existingResponders = respondersByPath[j];
				if (existingResponders.indexOf(responder) >= 0) {return true;}
			}
		}

		return false;
	};

	_hidden.getStatusByResponderID = function() {
		return _statusByResponderID;
	};

	_hidden.getRespondersByID = function() {
		return _respondersByID;
	};

	_hidden.getStatus = function(responder) {
		return _statusByResponderID[responder.__navigatorjs.id];
	};

	_hidden.getKnownPaths = function() {
		var list = {},
			path,
			knownPaths = [];

		list[_defaultState.getPath()] = true;

		for (path in _responders.showByPath) {
			list[new navigatorjs.NavigationState(path).getPath()] = true;
		}

		for (path in list) {
			knownPaths.push(path);
		}

		knownPaths.sort();
		return knownPaths;
	};
	// HIDDEN NAMESPACE END

	// VALIDATION NAMESPACE START
	_validation.notifyValidationPrepared = function(validatorResponder, truncatedState, fullState) {
		// If the takeOutResponder() method returns false, it was not in the responder list to begin with.
		// This happens if a second navigation state is requested before the async validation preparation of the first completes.
		if (_validatingAsynchResponders.takeOutResponder(validatorResponder)) {
			if (validatorResponder.validate(truncatedState, fullState)) {
				_asyncValidated = true;
			} else {
				//logger.warn("Asynchronously invalidated by " + validatorResponder);
				_asyncInvalidated = true;

				if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(validatorResponder, "IHasStateRedirection")) {
					_inlineRedirectionState = validatorResponder.redirect(truncatedState, fullState);
				}
			}

			if (_asyncInvalidated || !_validatingAsynchResponders.isBusy()) {
				_validatingAsynchResponders.reset();
				_preparedValidatingAsynchRespondersStack = [];
				_performRequestCascade(fullState, false);
			} else {
				_validateFirstValidatingAsynchResponderFromStack();
//				console.log("Waiting for " + _validatingAsynchResponders.getLength() + " validators to prepare");
			}
		} else {
			// ignore async preparations of former requests.
		}
	};
	// VALIDATION NAMESPACE END

	var _validateFirstValidatingAsynchResponderFromStack = function() {
		if(_preparedValidatingAsynchRespondersStack.length == 0) {
			return false;
		}

		var preparedResponder = _preparedValidatingAsynchRespondersStack.shift();
		preparedResponder.responder.prepareValidation(preparedResponder.remainderState, preparedResponder.unvalidatedState, preparedResponder.callOnPrepared);

		return true;
	};


	var _validate = function(stateToValidate, allowRedirection, allowAsyncValidation) {
		var allowRedirection = allowRedirection == undefined ? true : allowRedirection,
			allowAsyncValidation = allowAsyncValidation == undefined ? true : allowAsyncValidation,
			unvalidatedState = stateToValidate,
			callOnPrepared = null,
			implicit,
			invalidated = false,
			validated = false,
			path,
			state,
			remainderState,
			validateByPathList,
			i,
			responder,
			validatorResponder;

		// check to see if there are still wildcards left
		if (unvalidatedState.hasWildcard()) {
//			console.log("validate - validateState: Requested states may not contain wildcards", "return false");
			// throw new Error("validateState: Requested states may not contain wildcards " + NavigationState.WILDCARD);
			return false;
		}

		if (unvalidatedState.equals(_defaultState)) {
//			console.log("validate - unvalidatedState.equals(_defaultState)", unvalidatedState.getPath(), _defaultState.getPath() , "return false");
			return true;
		}

		if (allowAsyncValidation) {
			// This conditional is only true if we enter the validation the first (synchronous) time.
			_asyncValidationOccurred = false;
			_asyncInvalidated = false;
			_asyncValidated = false;

			// reset asynchronous validation for every new state.
			_validatingAsynchResponders = new navigatorjs.AsynchResponders();
			_preparedValidatingAsynchRespondersStack = [];
		}

		implicit = _validateImplicitly(unvalidatedState);
//		console.groupCollapsed('Responders');

		//TODO should we order the states? As mapping a validating child state before a invalidating parent state will validate the state
		for (path in _responders.validateByPath) {
//			console.log(path);
			// create a state object for comparison:
			state = new navigatorjs.NavigationState(path);

			if (unvalidatedState.contains(state)) {
				remainderState = unvalidatedState.subtract(state);

				// the lookup path is contained by the new state.
				validateByPathList = _responders.validateByPath[path];

				_initializeIfNeccessary(validateByPathList);

				if (allowAsyncValidation && _hasRegisteredResponder(stateToValidate)) {
					// check for async validators first. If this does not
					for (i = 0; i < validateByPathList.length; i++) {
						responder = validateByPathList[i];

						// check for optional validation
						if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationOptionalAsync") && !responder.willValidate(remainderState, unvalidatedState)) {
							continue;
						}

						if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationAsync")) {
							_asyncValidationOccurred = true;

							callOnPrepared = new navigatorjs.transition.ValidationPreparedDelegate(responder, remainderState, unvalidatedState, this, _validation).call;
							_validatingAsynchResponders.addResponder(responder);
							_preparedValidatingAsynchRespondersStack.push({responder: responder, remainderState: remainderState, unvalidatedState: unvalidatedState, callOnPrepared: callOnPrepared});

//							console.log("Preparing validation (total of " + _validatingAsynchResponders.getLength() + ")");
						}
					}
				}

				// check regular validators
				//for each (responder in list) {
				for (i = 0; i < validateByPathList.length; i++) {
					responder = validateByPathList[i];
					// skip async validators, we handled them a few lines back.
					if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationAsync")) {
						continue;
					}

					// check for optional validation
					if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateValidationOptional") && !responder.willValidate(remainderState, unvalidatedState)) {
						continue;
					}
					
					if (responder.validate(remainderState, unvalidatedState) && _hasRegisteredResponder(unvalidatedState)) {
						validated = true;
					} else {
						//logger.warn("Invalidated by validator: " + responder);
						invalidated = true;

						if (allowRedirection && navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateRedirection")) {
							_inlineRedirectionState = responder.redirect(remainderState, unvalidatedState);
						}

//						console.log("validate - a responder was mapped to the given state, but it did not validate");
//						console.groupEnd();
						return false;
					}
				}
			}
		}

		if (_asyncValidationOccurred && _validateFirstValidatingAsynchResponderFromStack()) {
			// If there are active async validators, stop the validation chain and wait for the prepration to finish.
			// if (_validating.isBusy()) return false;
			// if (_asyncValidationOccurred && (_asyncValidated || _asyncInvalidated) {
			// async validation was instantaneous, which means that the validation was approved or denied elsewhere
			// in the stack. this method should return false any which way.
//			console.log("validate - _asyncValidationOccurred","return false");
//			console.groupEnd();
			return false;
		}

//		console.groupEnd();

		if (_validatingAsynchResponders.isBusy()) {
//			console.log("validate - _validatingAsynchResponders.isBusy", "return false");
			// the request cascade will double check the asynch validators and act accordingly.
			return false;
		}

		// invalidation overrules any validation
		if (invalidated || _asyncInvalidated) {
//			console.log("validate - invalidated || _asyncInvalidated", invalidated,  _asyncInvalidated, "return false");
			return false;
		}

		if (validated || _asyncValidated) {
//			console.log("validate - validated || _asyncValidated", validated, _asyncValidated, "return true");
			return true;
		}

		if (!implicit) {
//			console.log("validate - Validation failed. No validators or transitions matched the requested ", unvalidatedState);
			//logger.warn("Validation failed. No validators or transitions matched the requested " + unvalidatedState);
		}

//		console.log("validate - return with the implicit return value", implicit);

		return implicit;
	};

	var _validateImplicitly = function(state) {
		var path;
		for (path in _responders.showByPath) {
			if (new navigatorjs.NavigationState(path).equals(state)) {
				// info("Validation passed based on transition responder.");
				return true;
			}
		}

		return false;
	};

	var _getRespondersToShow = function() {
		var respondersToShow = _getResponderList(_responders.showByPath, _currentState),
			respondersToHide = _getResponderList(_responders.hideByPath, _currentState),
			i,
			hideResponder,
			hideIndex;

		// remove elements from the toShow list, if they are in the toHide list.
//			for each (var hide : IHasStateTransition in toHide) {
		for (i = 0; i < respondersToHide.length; i++) {
			hideResponder = respondersToHide[i];
			hideIndex = respondersToShow.indexOf(hideResponder);
			if (hideIndex >= 0) {
				respondersToShow.splice(hideIndex, 1);
			}
		}

		return respondersToShow;
	};

	var _initializeIfNeccessary = function(responderList) {
		var i, responder;
//			for each (var responder : INavigationResponder in responderList) {
		for (i = 0; i < responderList.length; i++) {
			responder = responderList[i];
			if (_statusByResponderID[responder.__navigatorjs.id] == navigatorjs.transition.TransitionStatus.UNINITIALIZED && navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateInitialization")) {
				// first initialize the responder.
				responder.initializeByNavigator();
				_statusByResponderID[responder.__navigatorjs.id] = navigatorjs.transition.TransitionStatus.INITIALIZED;
			}
		}
	};

	var _getResponderList = function(listObj, state) {
		var responders = [],
			path;

		for (path in listObj) {
			if (state.contains(new navigatorjs.NavigationState(path))) {
				responders = responders.concat(listObj[path]);
			}
		}

		return responders;
	};

	var Navigator = function() {
		navigatorjs.utils.AutoBind(this, this);

		_$eventDispatcher = $({});
		_currentState = null;
		_responders = new navigatorjs.ResponderLists();
		_respondersByID = {};
		_statusByResponderID = {};
		_redirects = null;
		_responderIDCount = 0;
	};


	//PUBLIC API
	Navigator.prototype = {
		add: function(responder, pathsOrStates, behaviorString) {
			_modify(true, responder, pathsOrStates, behaviorString);
		},

		remove: function(responder, pathsOrStates, behaviorString) {
			_modify(false, responder, pathsOrStates, behaviorString);
		},

		registerRedirect: function(fromStateOrPath, toStateOrPath) {
			_redirects = _redirects || {};
			_redirects[navigatorjs.NavigationState.make(fromStateOrPath).getPath()] = navigatorjs.NavigationState.make(toStateOrPath);
		},

		start: function(defaultStateOrPath, startStateOrPath) {
			_defaultState = navigatorjs.NavigationState.make(defaultStateOrPath || "");

			this.request(startStateOrPath || _defaultState);
		},

		request: function(pathOrState) {
			_request(pathOrState);
		},

		getCurrentState: function() {
			if (!_currentState) {
				if (_defaultState) {
					return _defaultState.clone();
				}

				return null;
			}

			return _currentState.clone();
		},

		isTransitioning: function() {
			return _isTransitioning;
		},

		on: function(event, handler) {
			_$eventDispatcher.on(event, handler);
			return this;
		},

		off: function(event, handler) {
			_$eventDispatcher.off(event, handler);
			return this;
		},

		logResponders: function() {
//			console.log(_responders.toString());
		}
	};

	navigatorjs.Navigator = Navigator;
}());;this.navigatorjs = this.navigatorjs || {};

this.navigatorjs.NavigatorEvent = {};
this.navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED = "TRANSITION_STATUS_UPDATED";
this.navigatorjs.NavigatorEvent.STATE_REQUESTED = "STATE_REQUESTED";
this.navigatorjs.NavigatorEvent.STATE_CHANGED = "STATE_CHANGED";
this.navigatorjs.NavigatorEvent.TRANSITION_STARTED = "TRANSITION_STARTED";
this.navigatorjs.NavigatorEvent.TRANSITION_FINISHED = "TRANSITION_FINISHED";;this.navigatorjs = this.navigatorjs || {};

(function() {
	var ResponderLists = function() {
		this.validateByPath = {};
		this.updateByPath = {};
		this.swapByPath = {};
		this.showByPath = {};
		this.hideByPath = {};
		this.swappedBefore = {};

		this.all = [this.validateByPath,
		            this.updateByPath,
		            this.swapByPath,
		            this.showByPath,
		            this.hideByPath,
		            this.swappedBefore];
	};

	//PUBLIC API
	ResponderLists.prototype = {
		validateByPath: null, //[]
		updateByPath: null, //[]
		swapByPath: null, //[]
		showByPath: null, //[]
		hideByPath: null, //[]
		swappedBefore: null, //[]
		all: null, //[]

		toString: function() {
			var s = "ResponderLists [",
				variable,
				list, contents, key;

			for (variable in this) {
				list = this[variable];

				if (this.all.indexOf(list) > -1) {
					contents = [];
					for (key in list) {
						contents.push("[" + key + " = " + list[key] + "]");
					}
					s += "\n\t[" + variable + ": " + contents.join(", ") + "], ";
				}
			}

			s += "]";
			return s;
		}
	};

	navigatorjs.ResponderLists = ResponderLists;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.features = this.navigatorjs.features || {};

(function() {

	var _navigator = null,
		_template = '<div class="debugConsole">Path: <input type="text" class="path" /><div class="pathRenderer"></div><div class="responders"><div class="names"></div><div class="status"></div></div></div>',
		_visible = true,
		_inputRegex = new RegExp("[-_/A-Za-z0-9]"),
		_$el = null,
		_$pathInput = null,
		_$pathRenderer = null,
		_$responders = null,
		_$responderNames = null,
		_$responderStatus = null,
		_respondersByID = null,
		_statusByResponderID = null;

	//Input keydown validation and requesting the entered path
	var _onKeyPress = function(e) {
		switch (e.which) {
			case 13: //Return
				e.preventDefault(); //Prevent char from writing in textfield
				_navigator.request(_$pathInput.val());
				return;
				break;
			case 8: //Backspace
			case 0: //Others such as arrows
				return; //This can just be executed
				break;
		}

		var char = String.fromCharCode(e.which);
		if (!_inputRegex.test(char)) {
			e.preventDefault(); //Prevent char from writing in textfield
		}

		_autoSizeInput();
	};

	//Toggle showing debug console
	var _onWindowKeyPress = function(e) {
		switch (String.fromCharCode(e.which)) {
			case "~":
			case "$":
			case "`":
				_visible = !_visible;
				_$el.css({display: _visible ? '' : 'none'});
				break;
		}
	};

	var _onResponderClick = function(e) {
		var responderID = $(e.target).data("responder-id");

		console.log('Responder', _respondersByID[responderID]);
	};

	var _autoSizeInput = function() {
		_$pathRenderer.text(_$pathInput.val());
		_$pathInput.css({width: _$pathRenderer.width()});
	};

	var _handleStatusUpdated = function(e, data) {
		_respondersByID = data.respondersByID;
		_statusByResponderID = data.statusByResponderID;
		_updateDisplay();
	};

	var _updateDisplay = function() {
		var currentState = _navigator.getCurrentState(),
			responderID, responder, status, color, responderNamesHTMLString = "", responderStatusHTMLString = "";
		if (!currentState) {
			return;
		}

		_$pathInput.val(currentState.getPath());
		_autoSizeInput();

		for (responderID in _respondersByID) {
			responder = _respondersByID[responderID];
			status = _statusByResponderID[responderID];

			if (navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateTransition") || navigatorjs.NavigationResponderBehaviors.implementsBehaviorInterface(responder, "IHasStateInitialization")) {
				responderNamesHTMLString += '<span data-responder-id="' + responderID + '">' + _getResponderString(responder) + '</span><br />';
				color = _getColorByStatus(status);
				responderStatusHTMLString += '<span style=" color:' + color + '; font-weight:bold;" data-responder-id="' + responderID + '">' + navigatorjs.transition.TransitionStatus.toString(status) + '</span><br />';
			}
		}

		_$responderNames.html(responderNamesHTMLString);
		_$responderStatus.html(responderStatusHTMLString);
	};

	var _getResponderString = function(responder) {
		var responderString = responder.toString();

		if(responderString == "[object Object]" && responder.$el) {
			var tagName = responder.$el.prop("tagName").toLowerCase(),
				classes = responder.$el.attr("class").split(" ").join(".");

			responderString = tagName+"."+classes;
		}

		return responderString;
	};

	var _getColorByStatus = function(status) {
		var color = "";
		switch (status) {
			case navigatorjs.transition.TransitionStatus.UNINITIALIZED:
				color = "#AAAAAA";
				break;
			case navigatorjs.transition.TransitionStatus.INITIALIZED:
				color = "#FFFFFF";
				break;
			case navigatorjs.transition.TransitionStatus.HIDDEN:
				color = "#FF0000";
				break;
			case navigatorjs.transition.TransitionStatus.APPEARING:
			case navigatorjs.transition.TransitionStatus.DISAPPEARING:
				color = "#FFFF00";
				break;
			case navigatorjs.transition.TransitionStatus.SHOWN:
				color = "#00FF00";
				break;
		}

		return color;
	};

	var DebugConsole = function(navigator) {
		_navigator = navigator;

		_$el = $(_template);
		_$pathInput = _$el.find(".path");
		_$pathRenderer = _$el.find(".pathRenderer");
		_$responders = _$el.find(".responders");
		_$responderNames = _$responders.find(".names");
		_$responderStatus = _$responders.find(".status");

		//STYLING
		_$el.css({
			backgroundColor: '#000000',
			color: '#AAAAAA',
			fontFamily: 'Arial',
			fontSize: 12,
			padding: 5
		});

		_$pathInput.css({
			color: '#00FF00',
			backgroundColor: 'transparent',
			fontFamily: 'Arial',
			fontSize: 12,
			minWidth: 200,
			border: 0
		});

		_$pathRenderer.attr('style',_$pathInput.attr('style'));
		_$pathRenderer.css({
			position: 'absolute',
			height:0,
			overflowY:'hidden'
		});

		_$responderNames.css({
			display: 'inline-block',
			color: '#FF9900',
			marginRight: 15
		});

		_$responderStatus.css({
			display: 'inline-block'
		});

		_$pathInput.on('keypress', _onKeyPress);
		$(window).on('keypress', _onWindowKeyPress);

		_$responderNames.on('click', _onResponderClick);
		_$responderStatus.on('click', _onResponderClick);

		_navigator.on(navigatorjs.NavigatorEvent.STATE_CHANGED, _handleStatusUpdated);
		_navigator.on(navigatorjs.NavigatorEvent.TRANSITION_STATUS_UPDATED, _handleStatusUpdated);
	};

	//PUBLIC API
	DebugConsole.prototype = {
		get$El: function() {return _$el;}
	};

	navigatorjs.features.DebugConsole = DebugConsole;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var StateCommandMap = function(navigator, injector) {
		this._navigator = navigator;
		this._injector = injector;
		this._commandsByState = {};
		this._verifiedCommandClasses = {};

		//this._navigator.add(this, "");

		this.initialize();
	};

	StateCommandMap.prototype = {
		navigatorBehaviors: ["IHasStateValidationOptional", "IHasStateUpdate"],

		_navigator: null,
		_injector: null,
		_commandsByState: null, //{}
		_verifiedCommandClasses: null, //{}

		initialize: function() {
		},

		mapCommand: function(stateOrPath, CommandClass, aExactMatch, aOneShot) {
			var exactMatch = aExactMatch == undefined ? false : aExactMatch,
				oneShot = aOneShot == undefined ? false : aOneShot,
				state = navigatorjs.NavigationState.make(stateOrPath),
				commands = this._commandsByState[state.getPath()] || [];

			this._commandsByState[state.getPath()] = commands;
			this._navigator.add(this, state);

			if (this._hasCommand(commands, CommandClass)) {
				throw new Error("Already mapped " + CommandClass + " to state " + state.getPath());
				return;
			}

			this._verifyCommandClass(CommandClass);

			commands.push({CommandClass: CommandClass, state: state, exactMatch: exactMatch, oneShot: oneShot});
		},

		unmapCommand: function(stateOrPath, CommandClass) {
			var state = navigatorjs.NavigationState.make(stateOrPath),
				commands = this._commandsByState[state.getPath()] || [],
				i, wrapper;
			this._commandsByState[state.getPath()] = commands;
			this._navigator.remove(this, state);
			for (i = commands.length; --i >= 0;) {
				wrapper = commands[i];
				if (wrapper.CommandClass == CommandClass) {
					commands.splice(i, 1);
					return;
				}
			}
		},

		willValidate: function(truncatedState, fullState) {
			// will only validate if the state matches a command.
			return this.validate(truncatedState, fullState);
		},

		validate: function(truncatedState, fullState) {
			var path, mappedState, commands, isExact, i, wrapper;

			for (path in this._commandsByState) {
				mappedState = navigatorjs.NavigationState.make(path);

				if (fullState.contains(mappedState)) {
					commands = this._commandsByState[path];
					isExact = fullState.equals(mappedState);

					// reverse loop to accomodate for oneshot removal
					i = commands.length;
					for (i; --i >= 0;) {
						wrapper = commands[i];
						if (!isExact && wrapper.exactMatch) {
							continue;
						}
						return true;
					}
				}
			}

			return false;
		},

		updateState: function(truncatedState, fullState) {
			var path, mappedState, commands, isExact, i, wrapper, command;

			for (path in this._commandsByState) {
				mappedState = navigatorjs.NavigationState.make(path);
				if (fullState.contains(mappedState)) {
					commands = this._commandsByState[path];
					isExact = fullState.equals(mappedState);

					// reverse loop to accomodate for oneshot removal
					i = commands.length;
					for (i; --i >= 0;) {
						wrapper = commands[i];
						if (!isExact && wrapper.exactMatch) {
							continue;
						}

						this._injector.map('fullState').toValue(fullState);
						this._injector.map('truncatedState').toValue(fullState.subtract(wrapper.state));

						command = new wrapper.CommandClass({injector:this._injector});
						command.execute();

						this._injector.unmap('fullState');
						this._injector.unmap('truncatedState');

						if (wrapper.oneShot) {
							this.unmapCommand(wrapper.state, wrapper.CommandClass);
						}
					}
				}
			}
		},

		_hasCommand: function(wrappedCommandsList, testForCommandClass) {
			var i, commandWrapper, length = wrappedCommandsList.length;
			for (i = 0; i < length; i++) {
				commandWrapper = wrappedCommandsList[i];
				if (commandWrapper.CommandClass == testForCommandClass) {
					return true;
				}
			}
			return false;
		},

		_verifyCommandClass: function(CommandClass) {
			if (this._verifiedCommandClasses[CommandClass]) {
				return;
			}
			if (CommandClass.prototype["execute"]===undefined) {
				throw new Error("Command doesn't implement an execute method - " + CommandClass);
			}
			this._verifiedCommandClasses[CommandClass] = true;
		}
	};

	navigatorjs.integration.StateCommandMap = StateCommandMap;

}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var _usingPushState,
		_rootUrl,
		_navigator,
		_started;

	var StateUrlSyncer = function(navigator) {
		navigatorjs.utils.AutoBind(this, this);

		_usingPushState = false;
		_rootUrl = '/';
		_navigator = navigator;
		_started = false;
	};


	StateUrlSyncer.prototype = {
		supportsPushState: !!(window && window.history && window.history.pushState),

		usePushState: function(rootUrl) {
			if(_started) {
				throw new Error("Cannot switch to using push states after start was called");
				return;
			}

			_usingPushState = this.supportsPushState;
			_rootUrl = rootUrl || _rootUrl;
		},

		isUsingPushState: function() {
			return _usingPushState;
		},

		start: function() {
			if(_started) {
				throw new Error("Already started");
				return;
			}

			_started = true;
			this._addListeners();
		},

		_addListeners: function() {
			if (_usingPushState) {
				$(window).on('popstate', this._onUrlChange);
			} else {
				$(window).on('hashchange', this._onUrlChange);
			}

			var STATE_CHANGED = navigatorjs.NavigatorEvent.STATE_CHANGED;

			_navigator.on(STATE_CHANGED, this._onStateChanged);
		},

		_removeListeners: function() {
			$(window).off('popstate', this._onUrlChange);
			$(window).off('hashchange', this._onUrlChange);
		},

		setUrl: function(url) {
			var newState,
				urlState = this.getUrlState();
			if (_usingPushState) {
				newState = new navigatorjs.NavigationState(_rootUrl + url);
				if(newState.equals(urlState)) {
					window.history.replaceState(null, '', newState.getPath());
				} else {
					window.history.pushState(null, '', newState.getPath());
				}
			} else {
				newState = new navigatorjs.NavigationState(url);
				if(!newState.equals(urlState)) {
					window.location.hash = newState.getPath();
				}
			}
		},

		getRawUrl: function() {
			if (_usingPushState) {
				return this.parsePushStateUrl(window.location.pathname);
			} else {
				return this.parseHashUrl(window.location.hash);
			}
		},

		getUrlState: function() {
			return new navigatorjs.NavigationState(this.getRawUrl());
		},

		_onStateChanged: function() {
			this.setUrl(_navigator.getCurrentState().getPath());
		},

		_onUrlChange: function() {
			_navigator.request(this.getUrlState());
		},

		resetUrl: function() {
			this.setUrl('');
		},

		parseHashUrl: function(hashUrl) {
			return hashUrl.replace(/^#|$/g, '');
		},

		parsePushStateUrl: function(pushStateUrl) {
			return pushStateUrl.replace(_rootUrl, '');
		},

		dispose: function() {
			this._removeListeners();
		}


	};

	navigatorjs.integration.StateUrlSyncer = StateUrlSyncer;

})();;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {
	var _navigator = null;
	var _orderedRecipes = null;
	var _$root = null;


	var StateViewMap = function(navigator, $root) {
		_navigator = navigator;
		_orderedRecipes = [];
		_$root = $root || $('body');

		_navigator.on(navigatorjs.NavigatorEvent.STATE_REQUESTED, _handleStateRequested);
	};

	function _addRecipe(statesOrPaths) {
		var recipe = new navigatorjs.integration.ViewRecipe();

		var i, length = statesOrPaths.length;
		for (i = 0; i < length; i++) {
			recipe.addState(navigatorjs.NavigationState.make(statesOrPaths[i]));
		}

		_orderedRecipes.push(recipe);

		return recipe;
	}

	function _handleStateRequested(e, eventData) {
		var requestedState = eventData.state,
			index, recipe, recipeStates, recipesLength = _orderedRecipes.length,
			j, state, statesLength,
			viewInstance;

		for (index = 0; index < recipesLength; index++) {
			recipe = _orderedRecipes[index];
			recipeStates = recipe.getStates();
			statesLength = recipeStates.length;

			for (j = 0; j < statesLength; j++) {
				state = recipeStates[j];

				if (requestedState.contains(state)) {
					viewInstance = recipe.getViewInstance();

					if (viewInstance.navigatorBehaviors instanceof Array) {
						_addViewElementToDOM(recipe);
						_navigator.add(viewInstance, state);
					}
				}
			}
		}
	}

	function _addViewElementToDOM(recipe) {
		if (recipe.isInstantiated() && $.contains(document.documentElement, recipe.getViewInstance().$el)) {
			return;
		}

		var parentRecipe = recipe.getParentRecipe(),
			$container = _$root,
			$inside,
			insideSelector = recipe.getInsideSelector();

		if (parentRecipe) {
			if (!parentRecipe.isInstantiated()) {
				_addViewElementToDOM(parentRecipe);
			}

			$container = parentRecipe.getViewInstance().$el;
		}

		if (insideSelector != null) {
			$inside = $container.find(insideSelector);
			$container = $inside.length > 0 ? $inside.first() : $container;
		}

		var i = _orderedRecipes.indexOf(recipe) + 1,
			length = _orderedRecipes.length,
			testRecipe;
		for (i; i < length; i++) {
			testRecipe = _orderedRecipes[i];

			if (testRecipe.isInstantiated() && testRecipe.getViewInstance().$el.parent()[0] == $container[0]) {
				testRecipe.getViewInstance().$el.before(recipe.getViewInstance().$el);
				return;
			}
		}

		// otherwise add on top
		$container.append(recipe.getViewInstance().$el);
	}

	//PUBLIC API
	StateViewMap.prototype = {
		mapState: function(statesOrPaths) {
			var allArgumentsAsOneFlatArray = [];
			allArgumentsAsOneFlatArray = allArgumentsAsOneFlatArray.concat.apply(allArgumentsAsOneFlatArray, arguments);
			return _addRecipe(allArgumentsAsOneFlatArray);
		},

		get$Root: function() {
			return _$root;
		}
	};

	navigatorjs.integration.StateViewMap = StateViewMap;

}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.integration = this.navigatorjs.integration || {};

(function() {

	var ViewRecipe = function() {
		this._states = [];
		this._viewClass = null;
		this._viewArguments = [];
		this._viewInstance = null;
		this._insideSelector = null;
		this._parentRecipe = null;
	};

	//PUBLIC API
	ViewRecipe.prototype = {

		addState: function(navigationState) {
			var i, existingState, length = this._states.length;

			for (i = 0; i < length; i++) {
				existingState = this._states[i];

				if (existingState.getPath() == navigationState.getPath()) {
					return;
				}
			}

			this._states.push(navigationState);

			return this;
		},

		getStates: function() {
			return this._states;
		},

		toView: function(viewClass) {
			this._viewClass = viewClass;

			return this;
		},

		getViewClass: function() {
			return this._viewClass;
		},

		getViewInstance: function() {
			if (!this.isInstantiated()) {

				var params = this._viewArguments;
				switch (params.length) {
					default:
					case 0:
						this._viewInstance = new this._viewClass();
						break;
					case 1:
						this._viewInstance = new this._viewClass(params[0]);
						break;
					case 2:
						this._viewInstance = new this._viewClass(params[0], params[1]);
						break;
					case 3:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2]);
						break;
					case 4:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2], params[3]);
						break;
					case 5:
						this._viewInstance = new this._viewClass(params[0], params[1], params[2], params[3], params[4]);
						break;
				}

			}
			return this._viewInstance;
		},

		isInstantiated: function() {
			return this._viewInstance != null;
		},

		withArguments: function() {
			if (arguments.length > 5) {
				throw new Error("Uncle Bob says you want to use too many arguments");
			}
			this._viewArguments = arguments;

			return this;
		},

		inside: function(selector) {
			this._insideSelector = selector;

			return this;
		},

		getInsideSelector: function() {
			return this._insideSelector;
		},

		withParent: function(parentRecipe) {
			this._parentRecipe = parentRecipe;
			return this;
		},

		getParentRecipe: function() {
			return this._parentRecipe;
		}
	};

	navigatorjs.integration.ViewRecipe = ViewRecipe;

}());;if (!Array.prototype.indexOf) {
	Array.prototype.indexOf = function (elt /*, from*/) {
		var len = this.length;
		var from = Number(arguments[1]) || 0;
		from = (from < 0) ? Math.ceil(from) : Math.floor(from);
		if (from < 0) from += len;
		for (; from < len; from++) {
			if (from in this && this[from] === elt) {
				return from;
			}
		}
		return -1;
	};
};this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

(function() {
	var TransitionCompleteDelegate = function(responder, status, behavior, navigator, transitionNamespace) {
		this._responder = responder;
		this._status = status;
		this._behavior = behavior;
		this._navigator = navigator;
		this._transitionNamespace = transitionNamespace;
		this._called = false;
		navigatorjs.utils.AutoBind(this, this);
	};

	//PUBLIC API
	TransitionCompleteDelegate.prototype = {
		call: function() {
			//console.log('TransitionCompleteDelegate -> call', this);
			if (this._called) { throw new Error("Illegal second call to transition complete. This instance is already prepared for garbage collection!"); }

			this._called = true;
			this._transitionNamespace.notifyComplete(this._responder, this._status, this._behavior);
			this._responder = null;
			this._navigator = null;
			this._transitionNamespace = null;
		}
	};

	navigatorjs.transition.TransitionCompleteDelegate = TransitionCompleteDelegate;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

this.navigatorjs.transition.TransitionStatus = {};
this.navigatorjs.transition.TransitionStatus.UNINITIALIZED = -2;
this.navigatorjs.transition.TransitionStatus.INITIALIZED = -1;
this.navigatorjs.transition.TransitionStatus.HIDDEN = 1;
this.navigatorjs.transition.TransitionStatus.APPEARING = 2;
this.navigatorjs.transition.TransitionStatus.SHOWN = 3;
this.navigatorjs.transition.TransitionStatus.SWAPPING = 4;
this.navigatorjs.transition.TransitionStatus.DISAPPEARING = 5;

this.navigatorjs.transition.TransitionStatus.toString = function(status) {
	switch (status) {
		case navigatorjs.transition.TransitionStatus.UNINITIALIZED:
			return "UNINITIALIZED";
		case navigatorjs.transition.TransitionStatus.INITIALIZED:
			return "INITIALIZED";
		case navigatorjs.transition.TransitionStatus.HIDDEN:
			return "HIDDEN";
		case navigatorjs.transition.TransitionStatus.APPEARING:
			return "APPEARING";
		case navigatorjs.transition.TransitionStatus.SHOWN:
			return "SHOWN";
		case navigatorjs.transition.TransitionStatus.SWAPPING:
			return "SWAPPING";
		case navigatorjs.transition.TransitionStatus.DISAPPEARING:
			return "DISAPPEARING";
	}

	return "UNKNOWN";
};;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.transition = this.navigatorjs.transition || {};

(function() {
	var ValidationPreparedDelegate = function(validatorResponder, truncatedState, fullState, navigator, validationNamespace) {
		this._validatorResponder = validatorResponder;
		this._truncatedState = truncatedState;
		this._fullState = fullState;
		this._navigator = navigator;
		this._validationNamespace = validationNamespace;
		navigatorjs.utils.AutoBind(this, this);
	};

	//PUBLIC API
	ValidationPreparedDelegate.prototype = {
		call: function() {
			this._validationNamespace.notifyValidationPrepared(this._validatorResponder, this._truncatedState, this._fullState);
			this._validatorResponder = null;
			this._truncatedState = null;
			this._fullState = null;
			this._navigator = null;
			this._validationNamespace = null;
		}
	};

	navigatorjs.transition.ValidationPreparedDelegate = ValidationPreparedDelegate;
}());;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.utils = this.navigatorjs.utils || {};

this.navigatorjs.utils.AutoBind = function(object, context) {
	var key, method;
	for (key in object) {
		method = object[key];
		if (typeof method === 'function') {
			object[key] = $.proxy(object[key], context);
		}
	}
};;this.navigatorjs = this.navigatorjs || {};
this.navigatorjs.utils = this.navigatorjs.utils || {};

this.navigatorjs.utils.Bind = function(functionOrArray, context) {
	var bind = function (method, context) {
		if (typeof method === 'function') {
			$.proxy(method, context);
		}
	}

	if (typeof functionOrArray === 'array') {
		var i, length = functionOrArray.length;
		for (i = 0; i < length; i++) {
			bind(functionOrArray[i], context);
		}

	} else {
		bind(functionOrArray, context);
	}

};