compass-jquery-plugin 0.3.2.8 → 0.3.3.0

data/templates/jquery/config/initializers/jquery.rb

@@ -26,12 +26,14 @@ ActionView::Helpers::AssetTagHelper.register_javascript_expansion :contextMenu =
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :cookie => ['jquery.cookie.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :doTimeout => ['jquery.dotimeout.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :dst => ['jquery.dst.min']
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :easing => ['jquery.easing.min']
 ActionView::Helpers::AssetTagHelper.register_stylesheet_expansion :farbtastic => ['compiled/jquery/ui/farbtastic.css']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :farbtastic => ['jquery.farbtastic.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :form => ['jquery.form.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :history => ['history.adapter.jquery.min', 'history.min', 'history.html4.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :hotkeys => ['jquery.hotkeys.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :layout => ['jquery.layout.min']
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :mediahelpers => ['jquery.mediahelpers.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :mousewheel => ['jquery.mousewheel.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :offline => ['json.min', 'jquery.offline.min']
 ActionView::Helpers::AssetTagHelper.register_javascript_expansion :pngFix => ['jquery.pngFix.min']

data/templates/jquery/history.adapter.jquery.js

@@ -7,46 +7,52 @@
 
 // Closure
 (function(window, undefined) {
-    // Localise Globals
-    var
-            History = window.History = window.History || {},
-            jQuery = window.jQuery;
+  // Localise Globals
+  var
+          History = window.History = window.History || {},
+          jQuery = window.jQuery;
 
-    // Check Existence
-    if (typeof History.Adapter !== 'undefined') {
-        throw new Error('History.js Adapter has already been loaded...');
-    }
-
-    // Add the Adapter
-    History.Adapter = {
-        // History.Adapter.bind(el,event,callback)
-        // @param {Element|Selector} el
-        // @param {String} event - custom and standard events
-        // @param {Function} callback
-        // @return
-        bind: function(el, event, callback) {
-            jQuery(el).bind(event, callback);
-        },
+  // Check Existence
+  if (typeof History.Adapter !== 'undefined') {
+    throw new Error('History.js Adapter has already been loaded...');
+  }
 
-        // History.Adapter.trigger(el,event)
-        // @param {Element|Selector} el
-        // @param {String} event - custom and standard events
-        // @return
-        trigger: function(el, event) {
-            jQuery(el).trigger(event);
-        },
+  // Add the Adapter
+  History.Adapter = {
+    /**
+     * History.Adapter.bind(el,event,callback)
+     * @param {Element|Selector} el
+     * @param {String} event - custom and standard events
+     * @param {Function} callback
+     * @return
+     */
+    bind: function(el, event, callback) {
+      jQuery(el).bind(event, callback);
+    },
 
-        // History.Adapter.trigger(el,event,data)
-        // @param {Function} callback
-        // @return
-        onDomLoad: function(callback) {
-            jQuery(callback);
-        }
-    };
+    /**
+     * History.Adapter.trigger(el,event)
+     * @param {Element|Selector} el
+     * @param {String} event - custom and standard events
+     * @return
+     */
+    trigger: function(el, event) {
+      jQuery(el).trigger(event);
+    },
 
-    // Try and Initialise History
-    if (typeof History.init !== 'undefined') {
-        History.init();
+    /**
+     * History.Adapter.trigger(el,event,data)
+     * @param {Function} callback
+     * @return
+     */
+    onDomLoad: function(callback) {
+      jQuery(callback);
     }
+  };
+
+  // Try and Initialise History
+  if (typeof History.init !== 'undefined') {
+    History.init();
+  }
 
 })(window);

data/templates/jquery/history.html4.js

@@ -7,600 +7,600 @@
  */
 
 (function(window, undefined) {
-    "use strict";
+  "use strict";
 
-    // --------------------------------------------------------------------------
-    // Initialise
+  // --------------------------------------------------------------------------
+  // Initialise
+
+  // Localise Globals
+  var
+          document = window.document, // Make sure we are using the correct document
+          setTimeout = window.setTimeout || setTimeout,
+          clearTimeout = window.clearTimeout || clearTimeout,
+          setInterval = window.setInterval || setInterval,
+          History = window.History = window.History || {}; // Public History Object
+
+  // Check Existence
+  if (typeof History.initHtml4 !== 'undefined') {
+    throw new Error('History.js HTML4 Support has already been loaded...');
+  }
 
-    // Localise Globals
-    var
-            document = window.document, // Make sure we are using the correct document
-            setTimeout = window.setTimeout || setTimeout,
-            clearTimeout = window.clearTimeout || clearTimeout,
-            setInterval = window.setInterval || setInterval,
-            History = window.History = window.History || {}; // Public History Object
-
-    // Check Existence
-    if (typeof History.initHtml4 !== 'undefined') {
-        throw new Error('History.js HTML4 Support has already been loaded...');
+  // --------------------------------------------------------------------------
+  // Initialise HTML4 Support
+
+  // Initialise HTML4 Support
+  History.initHtml4 = function() {
+    // Initialise
+    if (typeof History.initHtml4.initialized !== 'undefined') {
+      // Already Loaded
+      return false;
+    }
+    else {
+      History.initHtml4.initialized = true;
     }
 
-    // --------------------------------------------------------------------------
-    // Initialise HTML4 Support
+    // ----------------------------------------------------------------------
+    // Properties
+
+    /**
+     * History.enabled
+     * Is History enabled?
+     */
+    History.enabled = true;
+
+
+    // ----------------------------------------------------------------------
+    // Hash Storage
+
+    /**
+     * History.savedHashes
+     * Store the hashes in an array
+     */
+    History.savedHashes = [];
+
+    /**
+     * History.isLastHash(newHash)
+     * Checks if the hash is the last hash
+     * @param {string} newHash
+     * @return {boolean} true
+     */
+    History.isLastHash = function(newHash) {
+      // Prepare
+      var oldHash = History.getHashByIndex();
+
+      // Check
+      var isLast = newHash === oldHash;
+
+      // Return isLast
+      return isLast;
+    };
+
+    /**
+     * History.saveHash(newHash)
+     * Push a Hash
+     * @param {string} newHash
+     * @return {boolean} true
+     */
+    History.saveHash = function(newHash) {
+      // Check Hash
+      if (History.isLastHash(newHash)) {
+        return false;
+      }
+
+      // Push the Hash
+      History.savedHashes.push(newHash);
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.getHashByIndex()
+     * Gets a hash by the index
+     * @param {integer} index
+     * @return {string}
+     */
+    History.getHashByIndex = function(index) {
+      // Prepare
+      var hash = null;
+
+      // Handle
+      if (typeof index === 'undefined') {
+        // Get the last inserted
+        hash = History.savedHashes[History.savedHashes.length - 1];
+      }
+      else if (index < 0) {
+        // Get from the end
+        hash = History.savedHashes[History.savedHashes.length + index];
+      }
+      else {
+        // Get from the beginning
+        hash = History.savedHashes[index];
+      }
+
+      // Return hash
+      return hash;
+    };
+
+    // ----------------------------------------------------------------------
+    // Discarded States
+
+    /**
+     * History.discardedHashes
+     * A hashed array of discarded hashes
+     */
+    History.discardedHashes = {};
+
+    /**
+     * History.discardedStates
+     * A hashed array of discarded states
+     */
+    History.discardedStates = {};
+
+    /**
+     * History.discardState(State)
+     * Discards the state by ignoring it through History
+     * @param {object} State
+     * @return {true}
+     */
+    History.discardState = function(discardedState, forwardState, backState) {
+      //History.debug('History.discardState', arguments);
+      // Prepare
+      var discardedStateHash = History.getHashByState(discardedState);
+
+      // Create Discard Object
+      var discardObject = {
+        'discardedState': discardedState,
+        'backState': backState,
+        'forwardState': forwardState
+      };
+
+      // Add to DiscardedStates
+      History.discardedStates[discardedStateHash] = discardObject;
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.discardHash(hash)
+     * Discards the hash by ignoring it through History
+     * @param {string} hash
+     * @return {true}
+     */
+    History.discardHash = function(discardedHash, forwardState, backState) {
+      //History.debug('History.discardState', arguments);
+      // Create Discard Object
+      var discardObject = {
+        'discardedHash': discardedHash,
+        'backState': backState,
+        'forwardState': forwardState
+      };
+
+      // Add to discardedHash
+      History.discardedHashes[discardedHash] = discardObject;
+
+      // Return true
+      return true;
+    };
+
+    /**
+     * History.discardState(State)
+     * Checks to see if the state is discarded
+     * @param {object} State
+     * @return {bool}
+     */
+    History.discardedState = function(State) {
+      // Prepare
+      var StateHash = History.getHashByState(State);
+
+      // Check
+      var discarded = History.discardedStates[StateHash] || false;
+
+      // Return true
+      return discarded;
+    };
+
+    /**
+     * History.discardedHash(hash)
+     * Checks to see if the state is discarded
+     * @param {string} State
+     * @return {bool}
+     */
+    History.discardedHash = function(hash) {
+      // Check
+      var discarded = History.discardedHashes[hash] || false;
+
+      // Return true
+      return discarded;
+    };
+
+    /**
+     * History.recycleState(State)
+     * Allows a discarded state to be used again
+     * @param {object} data
+     * @param {string} title
+     * @param {string} url
+     * @return {true}
+     */
+    History.recycleState = function(State) {
+      //History.debug('History.recycleState', arguments);
+      // Prepare
+      var StateHash = History.getHashByState(State);
+
+      // Remove from DiscardedStates
+      if (History.discardedState(State)) {
+        delete History.discardedStates[StateHash];
+      }
+
+      // Return true
+      return true;
+    };
+
+    // ----------------------------------------------------------------------
+    // HTML4 HashChange Support
+
+    if (History.emulated.hashChange) {
+      /*
+       * We must emulate the HTML4 HashChange Support by manually checking for hash changes
+       */
+
+      /**
+       * History.hashChangeInit()
+       * Init the HashChange Emulation
+       */
+      History.hashChangeInit = function() {
+        // Define our Checker Function
+        History.checkerFunction = null;
+
+        // Define some variables that will help in our checker function
+        var
+                lastDocumentHash = '';
+
+        // Handle depending on the browser
+        if (History.isInternetExplorer()) {
+          // IE6 and IE7
+          // We need to use an iframe to emulate the back and forward buttons
+
+          // Create iFrame
+          var
+                  iframeId = 'historyjs-iframe',
+                  iframe = document.createElement('iframe');
+
+          // Adjust iFarme
+          iframe.setAttribute('id', iframeId);
+          iframe.style.display = 'none';
+
+          // Append iFrame
+          document.body.appendChild(iframe);
+
+          // Create initial history entry
+          iframe.contentWindow.document.open();
+          iframe.contentWindow.document.close();
+
+          // Define some variables that will help in our checker function
+          var
+                  lastIframeHash = '',
+                  checkerRunning = false;
+
+          // Define the checker function
+          History.checkerFunction = function() {
+            // Check Running
+            if (checkerRunning) {
+              return false;
+            }
 
-    // Initialise HTML4 Support
-    History.initHtml4 = function() {
-        // Initialise
-        if (typeof History.initHtml4.initialized !== 'undefined') {
-            // Already Loaded
-            return false;
-        }
-        else {
-            History.initHtml4.initialized = true;
-        }
+            // Update Running
+            checkerRunning = true;
 
-        // ----------------------------------------------------------------------
-        // Properties
+            // Fetch
+            var
+                    documentHash = History.getHash() || '',
+                    iframeHash = History.unescapeHash(iframe.contentWindow.document.location.hash) || '';
 
-        /**
-         * History.enabled
-         * Is History enabled?
-         */
-        History.enabled = true;
+            // The Document Hash has changed (application caused)
+            if (documentHash !== lastDocumentHash) {
+              // Equalise
+              lastDocumentHash = documentHash;
 
+              // Create a history entry in the iframe
+              if (iframeHash !== documentHash) {
+                //History.debug('hashchange.checker: iframe hash change', 'documentHash (new):', documentHash, 'iframeHash (old):', iframeHash);
 
-        // ----------------------------------------------------------------------
-        // Hash Storage
+                // Equalise
+                lastIframeHash = iframeHash = documentHash;
 
-        /**
-         * History.savedHashes
-         * Store the hashes in an array
-         */
-        History.savedHashes = [];
+                // Create History Entry
+                iframe.contentWindow.document.open();
+                iframe.contentWindow.document.close();
 
-        /**
-         * History.isLastHash(newHash)
-         * Checks if the hash is the last hash
-         * @param {string} newHash
-         * @return {boolean} true
-         */
-        History.isLastHash = function(newHash) {
-            // Prepare
-            var oldHash = History.getHashByIndex();
-
-            // Check
-            var isLast = newHash === oldHash;
-
-            // Return isLast
-            return isLast;
-        };
-
-        /**
-         * History.saveHash(newHash)
-         * Push a Hash
-         * @param {string} newHash
-         * @return {boolean} true
-         */
-        History.saveHash = function(newHash) {
-            // Check Hash
-            if (History.isLastHash(newHash)) {
-                return false;
+                // Update the iframe's hash
+                iframe.contentWindow.document.location.hash = History.escapeHash(documentHash);
+              }
+
+              // Trigger Hashchange Event
+              History.Adapter.trigger(window, 'hashchange');
             }
 
-            // Push the Hash
-            History.savedHashes.push(newHash);
+            // The iFrame Hash has changed (back button caused)
+            else if (iframeHash !== lastIframeHash) {
+              //History.debug('hashchange.checker: iframe hash out of sync', 'iframeHash (new):', iframeHash, 'documentHash (old):', documentHash);
 
-            // Return true
-            return true;
-        };
-
-        /**
-         * History.getHashByIndex()
-         * Gets a hash by the index
-         * @param {integer} index
-         * @return {string}
-         */
-        History.getHashByIndex = function(index) {
-            // Prepare
-            var hash = null;
+              // Equalise
+              lastIframeHash = iframeHash;
 
-            // Handle
-            if (typeof index === 'undefined') {
-                // Get the last inserted
-                hash = History.savedHashes[History.savedHashes.length - 1];
-            }
-            else if (index < 0) {
-                // Get from the end
-                hash = History.savedHashes[History.savedHashes.length + index];
-            }
-            else {
-                // Get from the beginning
-                hash = History.savedHashes[index];
+              // Update the Hash
+              History.setHash(iframeHash, false);
             }
 
-            // Return hash
-            return hash;
-        };
-
-        // ----------------------------------------------------------------------
-        // Discarded States
-
-        /**
-         * History.discardedHashes
-         * A hashed array of discarded hashes
-         */
-        History.discardedHashes = {};
-
-        /**
-         * History.discardedStates
-         * A hashed array of discarded states
-         */
-        History.discardedStates = {};
-
-        /**
-         * History.discardState(State)
-         * Discards the state by ignoring it through History
-         * @param {object} State
-         * @return {true}
-         */
-        History.discardState = function(discardedState, forwardState, backState) {
-            //History.debug('History.discardState', arguments);
+            // Reset Running
+            checkerRunning = false;
+
+            // Return true
+            return true;
+          };
+        }
+        else {
+          // We are not IE
+          // Firefox 1 or 2, Opera
+
+          // Define the checker function
+          History.checkerFunction = function() {
             // Prepare
-            var discardedStateHash = History.getHashByState(discardedState);
+            var documentHash = History.getHash();
 
-            // Create Discard Object
-            var discardObject = {
-                'discardedState': discardedState,
-                'backState': backState,
-                'forwardState': forwardState
-            };
+            // The Document Hash has changed (application caused)
+            if (documentHash !== lastDocumentHash) {
+              // Equalise
+              lastDocumentHash = documentHash;
 
-            // Add to DiscardedStates
-            History.discardedStates[discardedStateHash] = discardObject;
+              // Trigger Hashchange Event
+              History.Adapter.trigger(window, 'hashchange');
+            }
 
             // Return true
             return true;
-        };
-
-        /**
-         * History.discardHash(hash)
-         * Discards the hash by ignoring it through History
-         * @param {string} hash
-         * @return {true}
-         */
-        History.discardHash = function(discardedHash, forwardState, backState) {
-            //History.debug('History.discardState', arguments);
-            // Create Discard Object
-            var discardObject = {
-                'discardedHash': discardedHash,
-                'backState': backState,
-                'forwardState': forwardState
-            };
-
-            // Add to discardedHash
-            History.discardedHashes[discardedHash] = discardObject;
+          };
+        }
 
-            // Return true
-            return true;
-        };
-
-        /**
-         * History.discardState(State)
-         * Checks to see if the state is discarded
-         * @param {object} State
-         * @return {bool}
-         */
-        History.discardedState = function(State) {
-            // Prepare
-            var StateHash = History.getHashByState(State);
+        // Apply the checker function
+        History.intervalList.push(setInterval(History.checkerFunction, History.options.hashChangeInterval));
 
-            // Check
-            var discarded = History.discardedStates[StateHash] || false;
+        // Done
+        return true;
+      }; // History.hashChangeInit
 
-            // Return true
-            return discarded;
-        };
-
-        /**
-         * History.discardedHash(hash)
-         * Checks to see if the state is discarded
-         * @param {string} State
-         * @return {bool}
-         */
-        History.discardedHash = function(hash) {
-            // Check
-            var discarded = History.discardedHashes[hash] || false;
+      // Bind hashChangeInit
+      History.Adapter.onDomLoad(History.hashChangeInit);
 
-            // Return true
-            return discarded;
-        };
-
-        /**
-         * History.recycleState(State)
-         * Allows a discarded state to be used again
-         * @param {object} data
-         * @param {string} title
-         * @param {string} url
-         * @return {true}
-         */
-        History.recycleState = function(State) {
-            //History.debug('History.recycleState', arguments);
-            // Prepare
-            var StateHash = History.getHashByState(State);
+    } // History.emulated.hashChange
 
-            // Remove from DiscardedStates
-            if (History.discardedState(State)) {
-                delete History.discardedStates[StateHash];
-            }
 
-            // Return true
-            return true;
-        };
-
-        // ----------------------------------------------------------------------
-        // HTML4 HashChange Support
-
-        if (History.emulated.hashChange) {
-            /*
-             * We must emulate the HTML4 HashChange Support by manually checking for hash changes
-             */
-
-            /**
-             * History.hashChangeInit()
-             * Init the HashChange Emulation
-             */
-            History.hashChangeInit = function() {
-                // Define our Checker Function
-                History.checkerFunction = null;
-
-                // Define some variables that will help in our checker function
-                var
-                        lastDocumentHash = '';
-
-                // Handle depending on the browser
-                if (History.isInternetExplorer()) {
-                    // IE6 and IE7
-                    // We need to use an iframe to emulate the back and forward buttons
-
-                    // Create iFrame
-                    var
-                            iframeId = 'historyjs-iframe',
-                            iframe = document.createElement('iframe');
-
-                    // Adjust iFarme
-                    iframe.setAttribute('id', iframeId);
-                    iframe.style.display = 'none';
-
-                    // Append iFrame
-                    document.body.appendChild(iframe);
-
-                    // Create initial history entry
-                    iframe.contentWindow.document.open();
-                    iframe.contentWindow.document.close();
-
-                    // Define some variables that will help in our checker function
-                    var
-                            lastIframeHash = '',
-                            checkerRunning = false;
-
-                    // Define the checker function
-                    History.checkerFunction = function() {
-                        // Check Running
-                        if (checkerRunning) {
-                            return false;
-                        }
-
-                        // Update Running
-                        checkerRunning = true;
-
-                        // Fetch
-                        var
-                                documentHash = History.getHash() || '',
-                                iframeHash = History.unescapeHash(iframe.contentWindow.document.location.hash) || '';
-
-                        // The Document Hash has changed (application caused)
-                        if (documentHash !== lastDocumentHash) {
-                            // Equalise
-                            lastDocumentHash = documentHash;
-
-                            // Create a history entry in the iframe
-                            if (iframeHash !== documentHash) {
-                                //History.debug('hashchange.checker: iframe hash change', 'documentHash (new):', documentHash, 'iframeHash (old):', iframeHash);
-
-                                // Equalise
-                                lastIframeHash = iframeHash = documentHash;
-
-                                // Create History Entry
-                                iframe.contentWindow.document.open();
-                                iframe.contentWindow.document.close();
-
-                                // Update the iframe's hash
-                                iframe.contentWindow.document.location.hash = History.escapeHash(documentHash);
-                            }
-
-                            // Trigger Hashchange Event
-                            History.Adapter.trigger(window, 'hashchange');
-                        }
-
-                        // The iFrame Hash has changed (back button caused)
-                        else if (iframeHash !== lastIframeHash) {
-                            //History.debug('hashchange.checker: iframe hash out of sync', 'iframeHash (new):', iframeHash, 'documentHash (old):', documentHash);
-
-                            // Equalise
-                            lastIframeHash = iframeHash;
-
-                            // Update the Hash
-                            History.setHash(iframeHash, false);
-                        }
-
-                        // Reset Running
-                        checkerRunning = false;
-
-                        // Return true
-                        return true;
-                    };
-                }
-                else {
-                    // We are not IE
-                    // Firefox 1 or 2, Opera
-
-                    // Define the checker function
-                    History.checkerFunction = function() {
-                        // Prepare
-                        var documentHash = History.getHash();
-
-                        // The Document Hash has changed (application caused)
-                        if (documentHash !== lastDocumentHash) {
-                            // Equalise
-                            lastDocumentHash = documentHash;
-
-                            // Trigger Hashchange Event
-                            History.Adapter.trigger(window, 'hashchange');
-                        }
-
-                        // Return true
-                        return true;
-                    };
-                }
-
-                // Apply the checker function
-                setInterval(History.checkerFunction, History.options.hashChangeInterval);
-
-                // Done
-                return true;
-            }; // History.hashChangeInit
-
-            // Bind hashChangeInit
-            History.Adapter.onDomLoad(History.hashChangeInit);
-
-        } // History.emulated.hashChange
-
-
-        // ----------------------------------------------------------------------
-        // HTML5 State Support
-
-        if (History.emulated.pushState) {
-            /*
-             * We must emulate the HTML5 State Management by using HTML4 HashChange
-             */
-
-            /**
-             * History.onHashChange(event)
-             * Trigger HTML5's window.onpopstate via HTML4 HashChange Support
-             */
-            History.onHashChange = function(event) {
-                //History.debug('History.onHashChange', arguments);
-
-                // Prepare
-                var
-                        currentUrl = ((event && event.newURL) || document.location.href),
-                        currentHash = History.getHashByUrl(currentUrl),
-                        currentState = null,
-                        currentStateHash = null,
-                        currentStateHashExits = null;
-
-                // Check if we are the same state
-                if (History.isLastHash(currentHash)) {
-                    // There has been no change (just the page's hash has finally propagated)
-                    //History.debug('History.onHashChange: no change');
-                    History.busy(false);
-                    return false;
-                }
-
-                // Reset the double check
-                History.doubleCheckComplete();
-
-                // Store our location for use in detecting back/forward direction
-                History.saveHash(currentHash);
-
-                // Expand Hash
-                if (currentHash && History.isTraditionalAnchor(currentHash)) {
-                    //History.debug('History.onHashChange: traditional anchor', currentHash);
-                    // Traditional Anchor Hash
-                    History.Adapter.trigger(window, 'anchorchange');
-                    History.busy(false);
-                    return false;
-                }
-
-                // Create State
-                currentState = History.extractState(History.getFullUrl(currentHash || document.location.href, false), true);
-
-                // Check if we are the same state
-                if (History.isLastSavedState(currentState)) {
-                    //History.debug('History.onHashChange: no change');
-                    // There has been no change (just the page's hash has finally propagated)
-                    History.busy(false);
-                    return false;
-                }
-
-                // Create the state Hash
-                currentStateHash = History.getHashByState(currentState);
-
-                // Check if we are DiscardedState
-                var discardObject = History.discardedState(currentState);
-                if (discardObject) {
-                    // Ignore this state as it has been discarded and go back to the state before it
-                    if (History.getHashByIndex(-2) === History.getHashByState(discardObject.forwardState)) {
-                        // We are going backwards
-                        //History.debug('History.onHashChange: go backwards');
-                        History.back(false);
-                    } else {
-                        // We are going forwards
-                        //History.debug('History.onHashChange: go forwards');
-                        History.forward(false);
-                    }
-                    return false;
-                }
-
-                // Push the new HTML5 State
-                //History.debug('History.onHashChange: success hashchange');
-                History.pushState(currentState.data, currentState.title, currentState.url, false);
-
-                // End onHashChange closure
-                return true;
-            };
-            History.Adapter.bind(window, 'hashchange', History.onHashChange);
-
-            /**
-             * 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) {
-                //History.debug('History.pushState: called', arguments);
-
-                // Check the State
-                if (History.getHashByUrl(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
-                History.busy(true);
-
-                // Fetch the State Object
-                var
-                        newState = History.createStateObject(data, title, url),
-                        newStateHash = History.getHashByState(newState),
-                        oldState = History.getState(false),
-                        oldStateHash = History.getHashByState(oldState),
-                        html4Hash = History.getHash();
-
-                // Store the newState
-                History.storeState(newState);
-                History.expectedStateId = newState.id;
-
-                // Recycle the State
-                History.recycleState(newState);
-
-                // Force update of the title
-                History.setTitle(newState);
-
-                // Check if we are the same State
-                if (newStateHash === oldStateHash) {
-                    //History.debug('History.pushState: no change', newStateHash);
-                    History.busy(false);
-                    return false;
-                }
-
-                // Update HTML4 Hash
-                if (newStateHash !== html4Hash && newStateHash !== History.getShortUrl(document.location.href)) {
-                    //History.debug('History.pushState: update hash', newStateHash, html4Hash);
-                    History.setHash(newStateHash, false);
-                    return false;
-                }
-
-                // Update HTML5 State
-                History.saveState(newState);
-
-                // Fire HTML5 Event
-                //History.debug('History.pushState: trigger popstate');
-                History.Adapter.trigger(window, 'statechange');
-                History.busy(false);
-
-                // 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) {
-                //History.debug('History.replaceState: called', arguments);
-
-                // Check the State
-                if (History.getHashByUrl(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
-                History.busy(true);
-
-                // Fetch the State Objects
-                var
-                        newState = History.createStateObject(data, title, url),
-                        oldState = History.getState(false),
-                        previousState = History.getStateByIndex(-2);
-
-                // Discard Old State
-                History.discardState(oldState, newState, previousState);
-
-                // Alias to PushState
-                History.pushState(newState.data, newState.title, newState.url, false);
-
-                // End replaceState closure
-                return true;
-            };
-
-            /**
-             * Ensure initial state is handled correctly
-             */
-            if (History.getHash() && !History.emulated.hashChange) {
-                History.Adapter.onDomLoad(function() {
-                    History.Adapter.trigger(window, 'hashchange');
-                });
-            }
+    // ----------------------------------------------------------------------
+    // HTML5 State Support
+
+    if (History.emulated.pushState) {
+      /*
+       * We must emulate the HTML5 State Management by using HTML4 HashChange
+       */
+
+      /**
+       * History.onHashChange(event)
+       * Trigger HTML5's window.onpopstate via HTML4 HashChange Support
+       */
+      History.onHashChange = function(event) {
+        //History.debug('History.onHashChange', arguments);
+
+        // Prepare
+        var
+                currentUrl = ((event && event.newURL) || document.location.href),
+                currentHash = History.getHashByUrl(currentUrl),
+                currentState = null,
+                currentStateHash = null,
+                currentStateHashExits = null;
+
+        // Check if we are the same state
+        if (History.isLastHash(currentHash)) {
+          // There has been no change (just the page's hash has finally propagated)
+          //History.debug('History.onHashChange: no change');
+          History.busy(false);
+          return false;
+        }
+
+        // Reset the double check
+        History.doubleCheckComplete();
+
+        // Store our location for use in detecting back/forward direction
+        History.saveHash(currentHash);
+
+        // Expand Hash
+        if (currentHash && History.isTraditionalAnchor(currentHash)) {
+          //History.debug('History.onHashChange: traditional anchor', currentHash);
+          // Traditional Anchor Hash
+          History.Adapter.trigger(window, 'anchorchange');
+          History.busy(false);
+          return false;
+        }
+
+        // Create State
+        currentState = History.extractState(History.getFullUrl(currentHash || document.location.href, false), true);
+
+        // Check if we are the same state
+        if (History.isLastSavedState(currentState)) {
+          //History.debug('History.onHashChange: no change');
+          // There has been no change (just the page's hash has finally propagated)
+          History.busy(false);
+          return false;
+        }
+
+        // Create the state Hash
+        currentStateHash = History.getHashByState(currentState);
+
+        // Check if we are DiscardedState
+        var discardObject = History.discardedState(currentState);
+        if (discardObject) {
+          // Ignore this state as it has been discarded and go back to the state before it
+          if (History.getHashByIndex(-2) === History.getHashByState(discardObject.forwardState)) {
+            // We are going backwards
+            //History.debug('History.onHashChange: go backwards');
+            History.back(false);
+          } else {
+            // We are going forwards
+            //History.debug('History.onHashChange: go forwards');
+            History.forward(false);
+          }
+          return false;
+        }
+
+        // Push the new HTML5 State
+        //History.debug('History.onHashChange: success hashchange');
+        History.pushState(currentState.data, currentState.title, currentState.url, false);
+
+        // End onHashChange closure
+        return true;
+      };
+      History.Adapter.bind(window, 'hashchange', History.onHashChange);
+
+      /**
+       * 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) {
+        //History.debug('History.pushState: called', arguments);
+
+        // Check the State
+        if (History.getHashByUrl(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
+        History.busy(true);
+
+        // Fetch the State Object
+        var
+                newState = History.createStateObject(data, title, url),
+                newStateHash = History.getHashByState(newState),
+                oldState = History.getState(false),
+                oldStateHash = History.getHashByState(oldState),
+                html4Hash = History.getHash();
+
+        // Store the newState
+        History.storeState(newState);
+        History.expectedStateId = newState.id;
+
+        // Recycle the State
+        History.recycleState(newState);
+
+        // Force update of the title
+        History.setTitle(newState);
+
+        // Check if we are the same State
+        if (newStateHash === oldStateHash) {
+          //History.debug('History.pushState: no change', newStateHash);
+          History.busy(false);
+          return false;
+        }
+
+        // Update HTML4 Hash
+        if (newStateHash !== html4Hash && newStateHash !== History.getShortUrl(document.location.href)) {
+          //History.debug('History.pushState: update hash', newStateHash, html4Hash);
+          History.setHash(newStateHash, false);
+          return false;
+        }
+
+        // Update HTML5 State
+        History.saveState(newState);
+
+        // Fire HTML5 Event
+        //History.debug('History.pushState: trigger popstate');
+        History.Adapter.trigger(window, 'statechange');
+        History.busy(false);
+
+        // 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) {
+        //History.debug('History.replaceState: called', arguments);
+
+        // Check the State
+        if (History.getHashByUrl(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
+        History.busy(true);
+
+        // Fetch the State Objects
+        var
+                newState = History.createStateObject(data, title, url),
+                oldState = History.getState(false),
+                previousState = History.getStateByIndex(-2);
+
+        // Discard Old State
+        History.discardState(oldState, newState, previousState);
+
+        // Alias to PushState
+        History.pushState(newState.data, newState.title, newState.url, false);
+
+        // End replaceState closure
+        return true;
+      };
+
+      /**
+       * Ensure initial state is handled correctly
+       */
+      if (History.getHash() && !History.emulated.hashChange) {
+        History.Adapter.onDomLoad(function() {
+          History.Adapter.trigger(window, 'hashchange');
+        });
+      }
 
-        } // History.emulated.pushState
+    } // History.emulated.pushState
 
-    }; // History.initHtml4
+  }; // History.initHtml4
 
-    // Try and Initialise History
-    History.init();
+  // Try and Initialise History
+  History.init();
 
 })(window);