compass-jquery-plugin 0.3.2.3 → 0.3.2.4

data/templates/jquery/history.html4.min.js

@@ -0,0 +1,21 @@
+/*
+ New BSD License <http://creativecommons.org/licenses/BSD/>
+ Public Domain
+ @author Benjamin Arthur Lupton <contact@balupton.com>
+ @author James Padolsey <https://gist.github.com/527683>
+ Public Domain
+ @author Benjamin Arthur Lupton <contact@balupton.com>
+*/
+(function(h){h.History=h.History||{};h._History=h._History||{};var i=h.document,b=h._History,a=h.History;if(typeof a.initHtml4!=="undefined")throw Error("History.js HTML4 Support has already been loaded...");a.initHtml4=function(){if(typeof a.initHtml5==="undefined"||typeof a.Adapter==="undefined")return false;b.getInternetExplorerMajorVersion=function(){return b.getInternetExplorerMajorVersion.cached=typeof b.getInternetExplorerMajorVersion.cached!=="undefined"?b.getInternetExplorerMajorVersion.cached:
+function(){for(var c=3,d=i.createElement("div"),f=d.getElementsByTagName("i");d.innerHTML="<!--[if gt IE "+ ++c+"]><i></i><![endif]--\>",f[0];);return c>4?c:void 0}()};b.isInternetExplorer=function(){return b.isInternetExplorer.cached=typeof b.isInternetExplorer.cached!=="undefined"?b.isInternetExplorer.cached:b.getInternetExplorerMajorVersion()!==0};a.emulated.hashChange=Boolean(!("onhashchange"in h||"onhashchange"in i)||b.isInternetExplorer()&&b.getInternetExplorerMajorVersion()<8);b.savedHashes=
+[];b.isLastHash=function(c){var d=b.getHashByIndex();return c===d};b.saveHash=function(c){if(b.isLastHash(c))return false;b.savedHashes.push(c);return true};b.getHashByIndex=function(c){var d=null;return d=typeof c==="undefined"?b.savedHashes[b.savedHashes.length-1]:c<0?b.savedHashes[b.savedHashes.length+c]:b.savedHashes[c]};b.stateHashExists=function(c){return typeof b.statesByHash[c]!=="undefined"};b.discardedHashes={};b.discardedStates={};b.discardState=function(c,d,f){a.debug("History.discardState",
+this,arguments);var j=a.contractState(c);b.discardedStates[j]={discardedState:c,backState:f,forwardState:d};return true};b.discardHash=function(c,d,f){a.debug("History.discardState",this,arguments);b.discardedHashes[c]={discardedHash:c,backState:f,forwardState:d};return true};b.discardedState=function(c){c=a.contractState(c);return b.discardedStates[c]||false};b.discardedHash=function(c){return b.discardedHashes[c]||false};b.recycleState=function(c){a.debug("History.recycleState",this,arguments);
+var d=a.contractState(c);b.discardedState(c)&&delete b.discardedStates[d];return true};a.emulated.hashChange&&a.Adapter.onDomLoad(function(){b.checkerFunction=null;if(b.isInternetExplorer()){var c=i.createElement("iframe");c.setAttribute("id","historyjs-iframe");c.style.display="none";i.body.appendChild(c);c.contentWindow.document.open();c.contentWindow.document.close();var d=null,f=null,j=false;b.checkerFunction=function(){if(j){a.debug("hashchange.checker: checker is running");return false}j=true;
+var e=a.getHash(),g=b.unescapeHash(c.contentWindow.document.location.hash);if(e!==d){d=e;if(g!==e){a.debug("hashchange.checker: iframe hash change","documentHash (new):",e,"iframeHash (old):",g);f=e;c.contentWindow.document.open();c.contentWindow.document.close();c.contentWindow.document.location.hash=b.escapeHash(e)}a.Adapter.trigger(h,"hashchange")}else if(g!==f){a.debug("hashchange.checker: iframe hash out of sync","iframeHash (new):",g,"documentHash (old):",e);f=g;a.setHash(g,false)}j=false;return true}}else{d=
+null;b.checkerFunction=function(){var e=a.getHash();if(e!==d){d=e;a.Adapter.trigger(h,"hashchange")}return true}}setInterval(b.checkerFunction,a.options.hashChangeCheckerDelay);return true});if(a.emulated.pushState){b.onHashChange=function(c){a.debug("_History.onHashChange",this,arguments);currentHash=unescape(a.extractHashFromUrl(c&&c.newURL||i.location.href));currentStateHashExits=currentStateHash=currentState=null;if(b.isLastHash(currentHash)){a.debug("_History.onHashChange: no change");a.busy(false);
+return false}b.saveHash(currentHash);currentState=a.expandHash(currentHash);if(!currentState){a.debug("_History.onHashChange: traditional anchor");a.Adapter.trigger(h,"anchorchange");a.busy(false);return false}if(b.isLastState(currentState)){a.debug("_History.onHashChange: no change");a.busy(false);return false}currentStateHash=a.contractState(currentState);a.debug("_History.onHashChange: ","currentStateHash",currentStateHash,"Hash -1",b.getHashByIndex(-1),"Hash -2",b.getHashByIndex(-2),"Hash -3",
+b.getHashByIndex(-3),"Hash -4",b.getHashByIndex(-4),"Hash -5",b.getHashByIndex(-5),"Hash -6",b.getHashByIndex(-6),"Hash -7",b.getHashByIndex(-7));var d=b.discardedState(currentState);if(d){a.debug("forwardState:",a.contractState(d.forwardState),"backState:",a.contractState(d.backState));if(b.getHashByIndex(-2)===a.contractState(d.forwardState)){a.debug("_History.onHashChange: go backwards");a.back(false)}else{a.debug("_History.onHashChange: go forwards");a.forward(false)}a.busy(false);return false}a.debug("_History.onHashChange: success hashchange");
+a.pushState(currentState.data,currentState.title,currentState.url,false);return true};a.Adapter.bind(h,"hashchange",b.onHashChange);a.pushState=function(c,d,f,j){a.debug("History.pushState",this,arguments);if(a.extractHashFromUrl(f))throw Error("History.js does not support states with fragement-identifiers (hashes/anchors).");if(j!==false&&a.busy()){a.debug("History.pushState: we must wait",arguments);a.pushQueue({scope:a,callback:a.pushState,args:arguments,queue:j});return false}a.busy(true);var e=
+a.createStateObject(c,d,f),g=a.contractState(e);a.getState();var k=a.getStateHash(),l=unescape(a.getHash());b.storeState(e);b.recycleState(e);if(i.title!==e.title){i.title=e.title;try{i.getElementsByTagName("title")[0].innerHTML=e.title}catch(m){}}a.debug("History.pushState: details","newStateHash:",g,"oldStateHash:",k,"html4Hash:",l);if(g===k){a.debug("History.pushState: no change",g);return false}if(g!==l){a.debug("History.pushState: update hash",g);a.setHash(g,false);return false}b.saveState(e);
+a.debug("History.pushState: trigger popstate");a.Adapter.trigger(h,"statechange");a.busy(false);return true};a.replaceState=function(c,d,f,j){a.debug("History.replaceState",this,arguments);if(a.extractHashFromUrl(f))throw Error("History.js does not support states with fragement-identifiers (hashes/anchors).");if(j!==false&&a.busy()){a.debug("History.replaceState: we must wait",arguments);a.pushQueue({scope:a,callback:a.replaceState,args:arguments,queue:j});return false}a.busy(true);var e=a.createStateObject(c,
+d,f),g=a.getState(),k=b.getStateByIndex(-2);b.discardState(g,e,k);a.pushState(e.data,e.title,e.url,false);return true};if(!i.location.hash||i.location.hash==="#")a.Adapter.onDomLoad(function(){a.debug("Internet Explorer Initial State Change Fix");var c=a.createStateObject({},"",i.location.href);a.pushState(c.data,c.title,c.url)});else if(!a.emulated.hashChange){a.debug("Firefox Initial State Change Fix");a.Adapter.onDomLoad(function(){b.onHashChange()})}}};a.initHtml4()})(window);

data/templates/jquery/history.js

@@ -0,0 +1,1297 @@
+/**
+ * History.js HTML5 Support
+ * @author Benjamin Arthur Lupton <contact@balupton.com>
+ * @copyright 2010-2011 Benjamin Arthur Lupton <contact@balupton.com>
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+
+(function(window,undefined){
+
+	// --------------------------------------------------------------------------
+	// Initialise
+
+	// History Object
+	window.History = window.History||{};
+	window._History = window._History||{};
+
+	// Localise Globals
+	var
+		console = window.console||undefined, // Prevent a JSLint complain
+		document = window.document, // Make sure we are using the correct document
+		_History = window._History, // Private History Object
+		History = window.History, // Public History Object
+		history = window.history; // Old History Object
+
+	// Check Existence of History.js
+	if ( typeof History.initHtml5 !== 'undefined' ) {
+		throw new Error('History.js HTML5 Support has already been loaded...');
+	}
+
+	// Initialise
+	History.initHtml5 = function(){
+
+		// ----------------------------------------------------------------------
+		// Check Status
+
+		if ( typeof History.Adapter === 'undefined' ) {
+			return false;
+		}
+
+		// ----------------------------------------------------------------------
+		// Debug Helpers
+
+		/**
+		 * History.options
+		 * Configurable options
+		 */
+		History.options = {
+			/**
+			 * History.options.hashChangeCheckerDelay
+			 * How long should the interval be before hashchange checks
+			 */
+			hashChangeCheckerDelay: 100,
+			/**
+			 * History.options.busyDelay
+			 * How long should we wait between busy events
+			 */
+			busyDelay: 250
+		};
+
+		// ----------------------------------------------------------------------
+		// Debug Helpers
+
+		/**
+		 * History.debug(message,...)
+		 * Logs the passed arguments if debug enabled
+		 */
+		History.debug = function(){
+			if ( (History.debug.enable||false) ) {
+				History.log.apply(History,arguments);
+			}
+		};
+		History.debug.enable = false;
+
+		/**
+		 * History.log(message,...)
+		 * Logs the passed arguments
+		 */
+		History.log = function(){
+			// Prepare
+			var
+				consoleExists = (typeof console !== 'undefined'),
+				textarea = document.getElementById('log'),
+				message = ("\n"+arguments[0]+"\n"),
+				i
+				;
+
+			// Write to Console
+			if ( consoleExists ) {
+				var
+					args = Array.prototype.slice.call(arguments),
+					message = args.shift();
+				if ( typeof console.debug !== 'undefined' ) {
+					console.debug.apply(console,[message,args]);
+				}
+				else {
+					console.log.apply(console,[message,args]);
+				}
+			}
+
+			// Write to log
+			for ( i=1,n=arguments.length; i<n; ++i ) {
+				var arg = arguments[i];
+				if ( typeof arg === 'object' && typeof JSON !== 'undefined' ) {
+					try {
+						arg = JSON.stringify(arg);
+					}
+					catch ( Exception ) {
+						// Recursive Object
+					}
+				}
+				message += "\n"+arg+"\n";
+			}
+
+			// Textarea
+			if ( textarea ) {
+				textarea.value += message+"\n-----\n";
+				textarea.scrollTop = textarea.scrollHeight - textarea.clientHeight;
+			}
+			// No Textarea, No Console
+			else if ( !consoleExists ) {
+				alert(message);
+			}
+
+			// Return true
+			return true;
+		};
+
+		// ----------------------------------------------------------------------
+		// Emulated Status
+
+		/**
+		 * _History.getInternetExplorerMajorVersion()
+		 * Get's the major version of Internet Explorer
+		 * @return {integer}
+		 * @license Public Domain
+		 * @author Benjamin Arthur Lupton <contact@balupton.com>
+		 * @author James Padolsey <https://gist.github.com/527683>
+		 */
+		_History.getInternetExplorerMajorVersion = function(){
+			var result = _History.getInternetExplorerMajorVersion.cached =
+					(typeof _History.getInternetExplorerMajorVersion.cached !== 'undefined')
+				?	_History.getInternetExplorerMajorVersion.cached
+				:	(function(){
+						var undef,
+								v = 3,
+								div = document.createElement('div'),
+								all = div.getElementsByTagName('i');
+						while (
+								div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
+								all[0]
+						);
+						return v > 4 ? v : undef;
+					})()
+				;
+			return result;
+		};
+
+		/**
+		 * _History.isInternetExplorer()
+		 * Are we using Internet Explorer?
+		 * @return {boolean}
+		 * @license Public Domain
+		 * @author Benjamin Arthur Lupton <contact@balupton.com>
+		 */
+		_History.isInternetExplorer = function(){
+			var result = _History.isInternetExplorer.cached =
+					(typeof _History.isInternetExplorer.cached !== 'undefined')
+				?	_History.isInternetExplorer.cached
+				:	(_History.getInternetExplorerMajorVersion() !== 0)
+				;
+			return result;
+		};
+
+		/**
+		 * History.emulated
+		 * Which features require emulating?
+		 */
+		History.emulated = {
+			pushState: !Boolean(window.history && window.history.pushState && window.history.replaceState)
+		};
+
+		/**
+		 * _History.isEmptyObject(obj)
+		 * Checks to see if the Object is Empty
+		 * @param {Object} obj
+		 * @return {boolean}
+		 */
+		_History.isEmptyObject = function(obj) {
+			for ( var key in obj ) {
+				if ( !this.hasOwnProperty(key) ) {
+					continue;
+				}
+				return false;
+			}
+			return true;
+		};
+
+		/**
+		 * _History.cloneObject(obj)
+		 * Clones a object
+		 * @param {Object} obj
+		 * @return {Object}
+		 */
+		_History.cloneObject = function(obj) {
+			var hash,newObj;
+			if ( obj ) {
+				hash = JSON.stringify(obj);
+				newObj = JSON.parse(hash);
+			}
+			else {
+				newObj = {};
+			}
+			return newObj;
+		};
+
+		// ----------------------------------------------------------------------
+		// State Object Helpers
+
+		/**
+		 * History.contractUrl(url)
+		 * Ensures that we have a relative URL and not a absolute URL
+		 * @param {string} url
+		 * @return {string} url
+		 */
+		History.contractUrl = function(url){
+			// Prepare
+			url = History.expandUrl(url);
+
+			// Prepare for Base Domain
+			var baseDomain = document.location.protocol+'//'+(document.location.hostname||document.location.host);
+			if ( document.location.port||false ) {
+				baseDomain += ':'+document.location.port;
+			}
+			baseDomain += '/';
+
+			// Adjust for Base Domain
+			url = url.replace(baseDomain,'/');
+
+			// Return url
+			return url;
+		};
+
+		/**
+		 * History.expandUrl(url)
+		 * Ensures that we have an absolute URL and not a relative URL
+		 * @param {string} url
+		 * @return {string} url
+		 */
+		History.expandUrl = function(url){
+			// Prepare
+			url = url||'';
+
+			// Test for Full URL
+			if ( /[a-z]+\:\/\//.test(url) ) {
+				// We have a Full URL
+			}
+
+			// Relative URL
+			else {
+				// Test for Base Page
+				if ( url.length === 0 || url.substring(0,1) === '?' ) {
+					// Fetch Base Page
+					var basePage = document.location.href.replace(/[#\?].*/,'');
+
+					// Adjust Page
+					url = basePage+url;
+				}
+
+				// No Base Page
+				else {
+
+					// Prepare for Base Element
+					var
+						baseElements = document.getElementsByTagName('base'),
+						baseElement = null,
+						baseHref = '';
+
+					// Test for Base Element
+					if ( baseElements.length === 1 ) {
+						// Prepare for Base Element
+						baseElement = baseElements[0];
+						baseHref = baseElement.href;
+						if ( baseHref[baseHref.length-1] !== '/' ) baseHref += '/';
+
+						// Adjust for Base Element
+						url = baseHref+url.replace(/^\//,'');
+					}
+
+					// No Base Element
+					else {
+						// Test for Base URL
+						if ( url.substring(0,1) === '.' ) {
+							// Prepare for Base URL
+							var baseUrl = document.location.href.replace(/[#\?].*/,'').replace(/[^\/]+$/,'');
+							if ( baseUrl[baseUrl.length-1] !== '/' ) baseUrl += '/';
+
+							// Adjust for Base URL
+							url = baseUrl + url;
+						}
+
+						// No Base URL
+						else {
+							// Prepare for Base Domain
+							var baseDomain = document.location.protocol+'//'+(document.location.hostname||document.location.host);
+							if ( document.location.port||false ) {
+								baseDomain += ':'+document.location.port;
+							}
+							baseDomain += '/';
+
+							// Adjust for Base Domain
+							url = baseDomain+url.replace(/^\//,'');
+						}
+					}
+				}
+			}
+
+			// Return url
+			return url;
+		};
+
+		/**
+		 * History.expandState(State)
+		 * Expands a State Object
+		 * @param {object} State
+		 * @return {object}
+		 */
+		History.expandState = function(oldState){
+			oldState = oldState||{};
+			var newState = {
+				'data': oldState.data||{},
+				'url': History.expandUrl(oldState.url||''),
+				'title': oldState.title||''
+			};
+			newState.data.title = newState.data.title||newState.title;
+			newState.data.url = newState.data.url||newState.url;
+			return newState;
+		};
+
+		/**
+		 * History.createStateObject(data,title,url)
+		 * Creates a object based on the data, title and url state params
+		 * @param {object} data
+		 * @param {string} title
+		 * @param {string} url
+		 * @return {object}
+		 */
+		History.createStateObject = function(data,title,url){
+			// Hashify
+			var State = {
+				'data': data,
+				'title': title,
+				'url': url
+			};
+
+			// Expand the State
+			State = History.expandState(State);
+
+			// Return object
+			return State;
+		};
+
+		/**
+		 * History.expandHash(hash)
+		 * Expands a Hash into a StateHash if applicable
+		 * @param {string} hash
+		 * @return {Object|null} State
+		 */
+		History.expandHash = function(hash){
+			// Prepare
+			var State = null;
+
+			// JSON
+			try {
+				State = JSON.parse(hash);
+			}
+			catch ( Exception ) {
+				var
+					parts = /(.*)\/uid=([0-9]+)$/.exec(hash),
+					url = parts ? (parts[1]||hash) : hash,
+					uid = parts ? String(parts[2]||'') : '';
+
+				if ( uid ) {
+					State = _History.getStateByUid(uid)||null;
+				}
+
+				if ( !State && /\//.test(hash) ) {
+					// Is a URL
+					var expandedUrl = History.expandUrl(hash);
+					State = History.createStateObject(null,null,expandedUrl);
+				}
+				else {
+					// Non State Hash
+					// do nothing
+				}
+			}
+
+			// Expand
+			State = State ? History.expandState(State) : null;
+
+			// Return State
+			return State;
+		};
+
+		/**
+		 * History.contractState(State)
+		 * Creates a Hash for the State Object
+		 * @param {object} passedState
+		 * @return {string} hash
+		 */
+		History.contractState = function(passedState){
+			// Check
+			if ( !passedState ) {
+				return null;
+			}
+
+			// Prepare
+			var
+				hash = null,
+				State = _History.cloneObject(passedState);
+
+			// Ensure State
+			if ( State ) {
+				// Clean
+				State.data = State.data||{};
+				delete State.data.title;
+				delete State.data.url;
+
+				// Handle
+				if ( _History.isEmptyObject(State) && !State.title ) {
+					hash = History.contractUrl(State.url);
+				}
+				else {
+					// Serialised Hash
+					hash = JSON.stringify(State);
+
+					// Has it been associated with a UID?
+					var uid;
+					if ( typeof _History.hashesToUids[hash] !== 'undefined' ) {
+						uid = _History.hashesToUids[hash];
+					}
+					else {
+						while ( true ) {
+							uid = String(Math.floor(Math.random()*1000));
+							if ( typeof _History.uidsToStates[uid] === 'undefined' ) {
+								break;
+							}
+						}
+					}
+
+					// Associate UID with Hash
+					_History.hashesToUids[hash] = uid;
+					_History.uidsToStates[uid] = State;
+
+					// Simplified Hash
+					hash = History.contractUrl(State.url)+'/uid='+uid;
+				}
+			}
+
+			// Return hash
+			return hash;
+		};
+
+		/**
+		 * _History.uidsToStates
+		 * UIDs to States
+		 */
+		_History.uidsToStates = {};
+
+		/**
+		 * _History.hashesToUids
+		 * Serialised States to UIDs
+		 */
+		_History.hashesToUids = {};
+
+		/**
+		 * _History.getStateByUid(uid)
+		 * Get a state by it's UID
+		 * @param {string} uid
+		 */
+		_History.getStateByUid = function(uid){
+			uid = String(uid);
+			var State = _History.uidsToStates[uid]||undefined;
+			return State;
+		};
+
+
+		// ----------------------------------------------------------------------
+		// State Storage
+
+		/**
+		 * _History.statesByUrl
+		 * Store the states indexed by their URLs
+		 */
+		_History.statesByUrl = {};
+
+		/**
+		 * _History.duplicateStateUrls
+		 * Which urls have duplicate states (indexed by url)
+		 */
+		_History.duplicateStateUrls = {};
+
+		/**
+		 * _History.statesByHash
+		 * Store the states indexed by their Hashes
+		 */
+		_History.statesByHash = {};
+
+		/**
+		 * _History.savedStates
+		 * Store the states in an array
+		 */
+		_History.savedStates = [];
+
+		/**
+		 * History.getState()
+		 * Get an object containing the data, title and url of the current state
+		 * @return {Object} State
+		 */
+		History.getState = function(){
+			return _History.getStateByIndex();
+		};
+
+		/**
+		 * History.getStateHash()
+		 * Get the hash of the current state
+		 * @return {string} hash
+		 */
+		History.getStateHash = function(){
+			return History.contractState(History.getState());
+		};
+
+		/**
+		 * _History.getStateByUrl
+		 * Get a state by it's url
+		 * @param {string} stateUrl
+		 */
+		_History.getStateByUrl = function(stateUrl){
+			var State = _History.statesByUrl[stateUrl]||undefined;
+			return State;
+		};
+
+		/**
+		 * _History.getStateByHash
+		 * Get a state by it's hash
+		 * @param {string} stateHash
+		 */
+		_History.getStateByHash = function(stateHash){
+			var State = _History.statesByHash[stateHash]||undefined;
+			return State;
+		};
+
+		/**
+		 * _History.storeState
+		 * Store a State
+		 * @param {object} State
+		 * @return {boolean} true
+		 */
+		_History.storeState = function(newState){
+			// Prepare
+			var
+				newStateHash = History.contractState(newState),
+				oldState = _History.getStateByUrl(newState.url);
+
+			// Check for Conflict
+			if ( typeof oldState !== 'undefined' ) {
+				// Compare Hashes
+				var oldStateHash = History.contractState(oldState);
+				if ( oldStateHash !== newStateHash ) {
+					// We have a conflict
+					_History.duplicateStateUrls[newState.url] = true;
+				}
+			}
+
+			// Store the State
+			_History.statesByUrl[newState.url] = _History.statesByHash[newStateHash] = newState;
+
+			// Return true
+			return true;
+		};
+
+		/**
+		 * _History.isLastState(newState)
+		 * Tests to see if the state is the last state
+		 * @param {Object} newState
+		 * @return {boolean} isLast
+		 */
+		_History.isLastState = function(newState){
+			// Prepare
+			var
+				newStateHash = History.contractState(newState),
+				oldStateHash = History.getStateHash();
+
+			// Check
+			var isLast = _History.savedStates.length && newStateHash === oldStateHash;
+
+			// Return isLast
+			return isLast;
+		};
+
+		/**
+		 * _History.saveState
+		 * Push a State
+		 * @param {Object} newState
+		 * @return {boolean} changed
+		 */
+		_History.saveState = function(newState){
+			// Check Hash
+			if ( _History.isLastState(newState) ) {
+				return false;
+			}
+
+			// Push the State
+			_History.savedStates.push(newState);
+
+			// Return true
+			return true;
+		};
+
+		/**
+		 * _History.getStateByIndex()
+		 * Gets a state by the index
+		 * @param {integer} index
+		 * @return {Object}
+		 */
+		_History.getStateByIndex = function(index){
+			// Prepare
+			var State = null;
+
+			// Handle
+			if ( typeof index === 'undefined' ) {
+				// Get the last inserted
+				State = _History.savedStates[_History.savedStates.length-1];
+			}
+			else if ( index < 0 ) {
+				// Get from the end
+				State = _History.savedStates[_History.savedStates.length+index];
+			}
+			else {
+				// Get from the beginning
+				State = _History.savedStates[index];
+			}
+
+			// Return State
+			return State;
+		};
+
+		/**
+		 * _History.stateUrlExists
+		 * Checks if the State Url Exists
+		 * @param {string} stateUrl
+		 * @return {boolean} exists
+		 */
+		_History.stateUrlExists = function(stateUrl){
+			// Prepare
+			var exists = typeof _History.statesByUrl[stateUrl] !== 'undefined';
+
+			// Return exists
+			return exists;
+		};
+
+		/**
+		 * _History.urlDuplicateExists
+		 * Check if the url has multiple states associated to it
+		 * @param {string} stateUrl
+		 * @return {boolean} exists
+		 */
+		_History.urlDuplicateExists = function(stateUrl){
+			var exists = typeof _History.duplicateStateUrls[stateUrl] !== 'undefined';
+			return exists;
+		};
+
+
+		// ----------------------------------------------------------------------
+		// Hash Helpers
+
+		/**
+		 * History.getHash()
+		 * Gets the current document hash
+		 * @return {string}
+		 */
+		History.getHash = function(){
+			var hash = _History.unescapeHash(document.location.hash);
+			return hash;
+		};
+
+		/**
+		 * _History.unescapeHash()
+		 * Normalise and Unescape a Hash
+		 * @return {string}
+		 */
+		_History.unescapeHash = function(hash){
+			var result = _History.normalizeHash(hash);
+
+			// Unescape hash
+			if ( /[\%]/.test(result) ) {
+				result = unescape(result);
+			}
+
+			// Return result
+			return result;
+		};
+
+		/**
+		 * _History.normalizeHash()
+		 * Normalise a hash across browsers
+		 * @return {string}
+		 */
+		_History.normalizeHash = function(hash){
+			var result = hash.replace(/[^#]*#/,'').replace(/#.*/, '');
+
+			// Return result
+			return result;
+		};
+
+		/**
+		 * History.setHash(hash)
+		 * Sets the document hash
+		 * @param {string} hash
+		 * @return {string}
+		 */
+		History.setHash = function(hash,queue){
+			// Handle Queueing
+			if ( queue !== false && History.busy() ) {
+				// Wait + Push to Queue
+				History.debug('History.setHash: we must wait', arguments);
+				History.pushQueue({
+					scope: History,
+					callback: History.setHash,
+					args: arguments,
+					queue: queue
+				});
+				return false;
+			}
+
+			// Prepare
+			var adjustedHash = _History.escapeHash(hash);
+
+			// Log hash
+			History.debug('History.setHash',this,arguments,'hash:',hash,'adjustedHash:',adjustedHash,'oldHash:',document.location.hash);
+
+			// Make Busy + Continue
+			History.busy(true);
+
+			// Apply hash
+			document.location.hash = adjustedHash;
+
+			// Return hash
+			return hash;
+		};
+
+		/**
+		 * _History.escape()
+		 * Normalise and Escape a Hash
+		 * @return {string}
+		 */
+		_History.escapeHash = function(hash){
+			var result = _History.normalizeHash(hash);
+
+			// Escape hash
+			if ( /[^a-zA-Z0-9\/\-\_\%\.]/.test(result) ) {
+				result = escape(result);
+			}
+
+			// Return result
+			return result;
+		};
+
+		/**
+		 * History.extractHashFromUrl(url)
+		 * Extracts the Hash from a URL
+		 * @param {string} url
+		 * @return {string} url
+		 */
+		History.extractHashFromUrl = function(url){
+			// Extract the hash
+			var hash = String(url)
+				.replace(/([^#]*)#?([^#]*)#?(.*)/, '$2')
+				;
+
+			// Unescape hash
+			hash = _History.unescapeHash(hash);
+
+			// Return hash
+			return hash;
+		};
+
+		/**
+		 * History.isTraditionalAnchor(url)
+		 * Checks to see if the url is a traditional anchor
+		 * @param {string} url
+		 * @return {boolean}
+		 */
+		History.isTraditionalAnchor = function(url){
+			var
+				hash = History.extractHashFromUrl(url),
+				el = document.getElementById(hash),
+				isTraditionalAnchor = typeof el !== 'undefined';
+
+			// Return isTraditionalAnchor
+			return isTraditionalAnchor;
+		};
+
+		// ----------------------------------------------------------------------
+		// Queueing
+
+		/**
+		 * History.queues
+		 * The list of queues to use
+		 * First In, First Out
+		 */
+		History.queues = [];
+
+		/**
+		 * History.busy(value)
+		 * @param {boolean} value [optional]
+		 * @return {boolean} busy
+		 */
+		History.busy = function(value){
+			History.debug('History.busy: called: changing ['+(History.busy.flag||false)+'] to ['+(value||false)+']', History.queues);
+
+			// Apply
+			if ( typeof value !== 'undefined' ) {
+				History.busy.flag = value;
+			}
+			// Default
+			else if ( typeof History.busy.flag === 'undefined' ) {
+				History.busy.flag = false;
+			}
+
+			// Queue
+			if ( !History.busy.flag ) {
+				// Execute the next item in the queue
+				clearTimeout(History.busy.timeout);
+				var fireNext = function(){
+					if ( History.busy.flag ) return;
+					for ( var i=History.queues.length-1; i >= 0; --i ) {
+						var queue = History.queues[i];
+						if ( queue.length === 0 ) continue;
+						var item = queue.shift();
+						History.debug('History.busy: firing', item);
+						History.fireQueueItem(item);
+						History.busy.timeout = setTimeout(fireNext,History.options.busyDelay);
+					}
+				};
+				History.busy.timeout = setTimeout(fireNext,History.options.busyDelay);
+			}
+
+			// Return
+			return History.busy.flag;
+		};
+
+		/**
+		 * History.fireQueueItem(item)
+		 * Fire a Queue Item
+		 * @param {Object} item
+		 * @return {Mixed} result
+		 */
+		History.fireQueueItem = function(item){
+			return item.callback.apply(item.scope||History,item.args||[]);
+		};
+
+		/**
+		 * History.pushQueue(callback,args)
+		 * Add an item to the queue
+		 * @param {Object} item [scope,callback,args,queue]
+		 */
+		History.pushQueue = function(item){
+			History.debug('History.pushQueue: called', arguments);
+
+			// Prepare the queue
+			History.queues[item.queue||0] = History.queues[item.queue||0]||[];
+
+			// Add to the queue
+			History.queues[item.queue||0].push(item);
+
+			// End pushQueue closure
+			return true;
+		};
+
+		/**
+		 * History.queue (item,queue), (func,queue), (func), (item)
+		 * Either firs the item now if not busy, or adds it to the queue
+		 */
+		History.queue = function(item,queue){
+			// Prepare
+			if ( typeof item === 'function' ) {
+				item = {
+					callback: item
+				};
+			}
+			if ( typeof queue !== 'undefined' ) {
+				item.queue = queue;
+			}
+
+			// Handle
+			if ( History.busy() ) {
+				History.pushQueue(item);
+			} else {
+				History.fireQueueItem(item);
+			}
+
+			// End queue closure
+			return true;
+		};
+
+
+		// ----------------------------------------------------------------------
+		// State Aliases
+
+		/**
+		 * History.back(queue)
+		 * Send the browser history back one item
+		 * @param {Integer} queue [optional]
+		 */
+		History.back = function(queue){
+			History.debug('History.back: called', arguments);
+
+			// Handle Queueing
+			if ( queue !== false && History.busy() ) {
+				// Wait + Push to Queue
+				History.debug('History.back: we must wait', arguments);
+				History.pushQueue({
+					scope: History,
+					callback: History.back,
+					args: arguments,
+					queue: queue
+				});
+				return false;
+			}
+
+			// Make Busy + Continue
+			History.busy(true);
+
+			// Fix a bug in IE6,IE7
+			if ( History.emulated.hashChange && _History.isInternetExplorer() ) {
+				// Prepare
+				var currentHash = History.getHash();
+
+				// Apply Check
+				setTimeout(function(){
+					var newHash = History.getHash();
+					if ( newHash === currentHash ) {
+						// No change occurred, try again
+						History.debug('History.back: trying again');
+						return History.back(false);
+					}
+					return true;
+				},History.options.hashChangeCheckerDelay*5);
+			}
+
+			// Go back
+			history.go(-1);
+
+			// End back closure
+			return true;
+		};
+
+		/**
+		 * History.forward(queue)
+		 * Send the browser history forward one item
+		 * @param {Integer} queue [optional]
+		 */
+		History.forward = function(queue){
+			History.debug('History.forward: called', arguments);
+
+			// Handle Queueing
+			if ( queue !== false && History.busy() ) {
+				// Wait + Push to Queue
+				History.debug('History.forward: we must wait', arguments);
+				History.pushQueue({
+					scope: History,
+					callback: History.forward,
+					args: arguments,
+					queue: queue
+				});
+				return false;
+			}
+
+			// Make Busy + Continue
+			History.busy(true);
+
+			// Fix a bug in IE6,IE7
+			if ( History.emulated.hashChange && _History.isInternetExplorer() ) {
+				// Prepare
+				var currentHash = History.getHash();
+
+				// Apply Check
+				setTimeout(function(){
+					var newHash = History.getHash();
+					if ( newHash === currentHash ) {
+						// No change occurred, try again
+						History.debug('History.forward: trying again');
+						return History.forward(false);
+					}
+					return true;
+				},History.options.hashChangeCheckerDelay*5);
+			}
+
+			// Go forward
+			history.go(1);
+
+			// End forward closure
+			return true;
+		};
+
+		/**
+		 * History.go(index,queue)
+		 * Send the browser history back or forward index times
+		 * @param {Integer} queue [optional]
+		 */
+		History.go = function(index,queue){
+			History.debug('History.go: called', arguments);
+
+			// Handle
+			if ( index > 0 ) {
+				// Forward
+				for ( var i=1; i<=index; ++i ) {
+					History.forward(queue);
+				}
+			}
+			else if ( index < 0 ) {
+				// Backward
+				for ( var i=-1; i>=index; --i ) {
+					History.back(queue);
+				}
+			}
+			else {
+				throw new Error('History.go: History.go requires a positive or negative integer passed.');
+			}
+
+			// End go closure
+			return true;
+		};
+
+
+		// ----------------------------------------------------------------------
+		// HTML5 State Support
+
+		if ( !History.emulated.pushState ) {
+			/*
+			 * Use native HTML5 History API Implementation
+			 */
+
+			/**
+			 * _History.onPopState(event,extra)
+			 * Refresh the Current State
+			 */
+			_History.onPopState = function(event){
+				History.debug('_History.onPopState',this,arguments);
+
+				// Check for a Hash, and handle apporiatly
+				var currentHash	= unescape(History.getHash());
+				if ( currentHash ) {
+					// Expand Hash
+					var currentState = History.expandHash(currentHash);
+					if ( currentState ) {
+						// We were able to parse it, it must be a State!
+						// Let's forward to replaceState
+						History.debug('_History.onPopState: state anchor', currentHash, currentState);
+						History.replaceState(currentState.data, currentState.tite, currentState.url, false);
+					}
+					else {
+						// Traditional Anchor
+						History.debug('_History.onPopState: traditional anchor', currentHash);
+						History.Adapter.trigger(window,'anchorchange');
+						History.busy(false);
+					}
+
+					// We don't care for hashes
+					return false;
+				}
+
+				// Prepare
+				var
+					currentStateHashExits				= null,
+					stateData										= {},
+					stateTitle									= null,
+					stateUrl										= null,
+					newState										= null;
+
+				// Prepare
+				event = event||{};
+				if ( typeof event.state === 'undefined' ) {
+					// jQuery
+					if ( typeof event.originalEvent !== 'undefined' && typeof event.originalEvent.state !== 'undefined' ) {
+						event.state = event.originalEvent.state;
+					}
+					// MooTools
+					else if ( typeof event.event !== 'undefined' && typeof event.event.state !== 'undefined' ) {
+						event.state = event.event.state;
+					}
+				}
+
+				// Fetch Data
+				if ( event.state === null ) {
+					// Vanilla: State has no data (new state, not pushed)
+					stateData = event.state;
+				}
+				else if ( typeof event.state !== 'undefined' ) {
+					// Vanilla: Back/forward button was used
+
+					// Using Chrome Fix
+					var
+						newStateUrl = History.expandUrl(document.location.href),
+						oldState = _History.getStateByUrl(newStateUrl),
+						duplicateExists = _History.urlDuplicateExists(newStateUrl);
+
+					// Does oldState Exist?
+					if ( typeof oldState !== 'undefined' && !duplicateExists ) {
+						stateData = oldState.data;
+					}
+					else {
+						stateData = event.state;
+					}
+
+					// Use the way that should work
+					// stateData = event.state;
+				}
+				else {
+					// Vanilla: A new state was pushed, and popstate was called manually
+
+					// Get State object from the last state
+					var
+						newStateUrl = History.expandUrl(document.location.href),
+						oldState = _History.getStateByUrl(newStateUrl);
+
+					// Check if the URLs match
+					if ( oldState && newStateUrl == oldState.url ) {
+						stateData = oldState.data;
+					}
+					else {
+						throw new Error('Unknown state');
+					}
+				}
+
+				// Resolve newState
+				stateData		= (typeof stateData !== 'object' || stateData === null) ? {} : stateData;
+				stateTitle	=	stateData.title||'',
+				stateUrl		=	stateData.url||document.location.href,
+				newState		=	History.createStateObject(stateData,stateTitle,stateUrl);
+
+				// Check if we are the same state
+				if ( _History.isLastState(newState) ) {
+					// There has been no change (just the page's hash has finally propagated)
+					History.debug('_History.onPopState: no change', newState, _History.savedStates);
+					History.busy(false);
+					return false;
+				}
+
+				// Log
+				History.debug(
+					'_History.onPopState',
+					'newState:', newState,
+					'oldState:', _History.getStateByUrl(History.expandUrl(document.location.href)),
+					'duplicateExists:', _History.urlDuplicateExists(History.expandUrl(document.location.href))
+				);
+
+				// Store the State
+				_History.storeState(newState);
+				_History.saveState(newState);
+
+				// Force update of the title
+				if ( newState.title ) {
+					document.title = newState.title
+				}
+
+				// Fire Our Event
+				History.Adapter.trigger(window,'statechange');
+				History.busy(false);
+
+				// Return true
+				return true;
+			};
+			History.Adapter.bind(window,'popstate',_History.onPopState);
+
+			/**
+			 * History.pushState(data,title,url)
+			 * Add a new State to the history object, become it, and trigger onpopstate
+			 * We have to trigger for HTML4 compatibility
+			 * @param {object} data
+			 * @param {string} title
+			 * @param {string} url
+			 * @return {true}
+			 */
+			History.pushState = function(data,title,url,queue){
+				// Check the State
+				if ( History.extractHashFromUrl(url) ) {
+					throw new Error('History.js does not support states with fragement-identifiers (hashes/anchors).');
+				}
+
+				// Handle Queueing
+				if ( queue !== false && History.busy() ) {
+					// Wait + Push to Queue
+					History.debug('History.pushState: we must wait', arguments);
+					History.pushQueue({
+						scope: History,
+						callback: History.pushState,
+						args: arguments,
+						queue: queue
+					});
+					return false;
+				}
+
+				// Make Busy + Continue
+				History.busy(true);
+
+				// Create the newState
+				var newState = History.createStateObject(data,title,url);
+
+				// Store the newState
+				_History.storeState(newState);
+
+				// Push the newState
+				history.pushState(newState.data,newState.title,newState.url);
+
+				// Fire HTML5 Event
+				History.Adapter.trigger(window,'popstate');
+
+				// End pushState closure
+				return true;
+			}
+
+			/**
+			 * History.replaceState(data,title,url)
+			 * Replace the State and trigger onpopstate
+			 * We have to trigger for HTML4 compatibility
+			 * @param {object} data
+			 * @param {string} title
+			 * @param {string} url
+			 * @return {true}
+			 */
+			History.replaceState = function(data,title,url,queue){
+				// Check the State
+				if ( History.extractHashFromUrl(url) ) {
+					throw new Error('History.js does not support states with fragement-identifiers (hashes/anchors).');
+				}
+
+				// Handle Queueing
+				if ( queue !== false && History.busy() ) {
+					// Wait + Push to Queue
+					History.debug('History.replaceState: we must wait', arguments);
+					History.pushQueue({
+						scope: History,
+						callback: History.replaceState,
+						args: arguments,
+						queue: queue
+					});
+					return false;
+				}
+
+				// Make Busy + Continue
+				History.busy(true);
+
+				// Create the newState
+				var newState = History.createStateObject(data,title,url);
+
+				// Store the newState
+				_History.storeState(newState);
+
+				// Push the newState
+				history.replaceState(newState.data,newState.title,newState.url);
+
+				// Fire HTML5 Event
+				History.Adapter.trigger(window,'popstate');
+
+				// End replaceState closure
+				return true;
+			}
+
+
+			/**
+			 * Ensure Cross Browser Compatibility
+			 */
+			if ( navigator.vendor === 'Apple Computer, Inc.' ) {
+				/**
+				 * Fix Safari Initial State Issue
+				 */
+				History.Adapter.onDomLoad(function(){
+					History.debug('Safari Initial State Change Fix');
+					var currentState = History.createStateObject({},'',document.location.href);
+					History.pushState(currentState.data,currentState.title,currentState.url);
+				});
+
+				/**
+				 * Fix Safari HashChange Issue
+				 */
+				History.Adapter.bind(window,'hashchange',function(){
+					History.Adapter.trigger(window,'popstate');
+				});
+			}
+		}
+	}; // init
+
+	// Try Load HTML5 Support
+	History.initHtml5();
+
+})(window);