text: /*!
   * jQuery BBQ: Back Button & Query Library - v1.1.1 - 1/22/2010
   * http://benalman.com/projects/jquery-bbq-plugin/
   * 
   * Copyright (c) 2010 "Cowboy" Ben Alman
   * Dual licensed under the MIT and GPL licenses.
   * http://benalman.com/about/license/
   */
  
  // Script: jQuery BBQ: Back Button & Query Library
  //
  // *Version: 1.1.1, Last updated: 1/22/2010*
  // 
  // Project Home - http://benalman.com/projects/jquery-bbq-plugin/
  // GitHub       - http://github.com/cowboy/jquery-bbq/
  // Source       - http://github.com/cowboy/jquery-bbq/raw/master/jquery.ba-bbq.js
  // (Minified)   - http://github.com/cowboy/jquery-bbq/raw/master/jquery.ba-bbq.min.js (3.7kb)
  // 
  // About: License
  // 
  // Copyright (c) 2010 "Cowboy" Ben Alman,
  // Dual licensed under the MIT and GPL licenses.
  // http://benalman.com/about/license/
  // 
  // About: Examples
  // 
  // These working examples, complete with fully commented code, illustrate a few
  // ways in which this plugin can be used.
  // 
  // Basic AJAX     - http://benalman.com/code/projects/jquery-bbq/examples/fragment-basic/
  // Advanced AJAX  - http://benalman.com/code/projects/jquery-bbq/examples/fragment-advanced/
  // jQuery UI Tabs - http://benalman.com/code/projects/jquery-bbq/examples/fragment-jquery-ui-tabs/
  // Deparam        - http://benalman.com/code/projects/jquery-bbq/examples/deparam/
  // 
  // About: Support and Testing
  // 
  // Information about what version or versions of jQuery this plugin has been
  // tested with, what browsers it has been tested in, and where the unit tests
  // reside (so you can test it yourself).
  // 
  // jQuery Versions - 1.3.2, 1.4
  // Browsers Tested - Internet Explorer 6-8, Firefox 2-3.7, Safari 3-4, Chrome, Opera 9.6-10.1.
  // Unit Tests      - http://benalman.com/code/projects/jquery-bbq/unit/
  // 
  // About: Release History
  // 
  // 1.1.1 - (1/22/2010) Integrated <jQuery hashchange event> v1.1, which fixes an
  //         obscure IE8 EmulateIE7 meta tag compatibility mode bug.
  // 1.1   - (1/9/2010) Broke out the jQuery BBQ event.special window.onhashchange
  //         functionality into a separate plugin for users who want just the
  //         basic event & back button support, without all the extra awesomeness
  //         that BBQ provides. This plugin will be included as part of jQuery BBQ,
  //         but also be available separately. See <jQuery hashchange event>
  //         plugin for more information. Also added the $.bbq.removeState method
  //         and added additional $.deparam examples.
  // 1.0.3 - (12/2/2009) Fixed an issue in IE 6 where location.search and
  //         location.hash would report incorrectly if the hash contained the ?
  //         character. Also $.param.querystring and $.param.fragment will no
  //         longer parse params out of a URL that doesn't contain ? or #,
  //         respectively.
  // 1.0.2 - (10/10/2009) Fixed an issue in IE 6/7 where the hidden IFRAME caused
  //         a "This page contains both secure and nonsecure items." warning when
  //         used on an https:// page.
  // 1.0.1 - (10/7/2009) Fixed an issue in IE 8. Since both "IE7" and "IE8
  //         Compatibility View" modes erroneously report that the browser
  //         supports the native window.onhashchange event, a slightly more
  //         robust test needed to be added.
  // 1.0   - (10/2/2009) Initial release
  
  (function($,window){
    '$:nomunge'; // Used by YUI compressor.
    
    // Some convenient shortcuts.
    var undefined,
      loc = window.location,
      aps = Array.prototype.slice,
      decode = decodeURIComponent,
      
      // Method / object references.
      jq_param = $.param,
      jq_param_fragment,
      jq_deparam,
      jq_deparam_fragment,
      jq_bbq = $.bbq = $.bbq || {},
      jq_bbq_pushState,
      jq_bbq_getState,
      jq_elemUrlAttr,
      jq_event_special = $.event.special,
      
      // Reused strings.
      str_hashchange = 'hashchange',
      str_querystring = 'querystring',
      str_fragment = 'fragment',
      str_elemUrlAttr = 'elemUrlAttr',
      str_href = 'href',
      str_src = 'src',
      
      // Reused RegExp.
      re_trim_querystring = /^.*\?|#.*$/g,
      re_trim_fragment = /^.*\#/,
      
      // Used by jQuery.elemUrlAttr.
      elemUrlAttr_cache = {};
    
    // A few commonly used bits, broken out to help reduce minified file size.
    
    function is_string( arg ) {
      return typeof arg === 'string';
    };
    
    // Why write the same function twice? Let's curry! Mmmm, curry..
    
    function curry( func ) {
      var args = aps.call( arguments, 1 );
      
      return function() {
        return func.apply( this, args.concat( aps.call( arguments ) ) );
      };
    };
    
    // Get location.hash (or what you'd expect location.hash to be) sans any
    // leading #. Thanks for making this necessary, Firefox!
    function get_fragment( url ) {
      return url.replace( /^[^#]*#?(.*)$/, '$1' );
    };
    
    // Get location.search (or what you'd expect location.search to be) sans any
    // leading #. Thanks for making this necessary, IE6!
    function get_querystring( url ) {
      return url.replace( /(?:^[^?#]*\?([^#]*).*$)?.*/, '$1' );
    };
    
    // Section: Param (to string)
    // 
    // Method: jQuery.param.querystring
    // 
    // Retrieve the query string from a URL or if no arguments are passed, the
    // current window.location.
    // 
    // Usage:
    // 
    // > jQuery.param.querystring( [ url ] );
    // 
    // Arguments:
    // 
    //  url - (String) A URL containing query string params to be parsed. If url
    //    is not passed, the current window.location is used.
    // 
    // Returns:
    // 
    //  (String) The parsed query string, with any leading "?" removed.
    //
    
    // Method: jQuery.param.querystring (build url)
    // 
    // Merge a URL, with or without pre-existing query string params, plus any
    // object, params string or URL containing query string params into a new URL.
    // 
    // Usage:
    // 
    // > jQuery.param.querystring( url, params [, merge_mode ] );
    // 
    // Arguments:
    // 
    //  url - (String) A valid URL for params to be merged into. This URL may
    //    contain a query string and/or fragment (hash).
    //  params - (String) A params string or URL containing query string params to
    //    be merged into url.
    //  params - (Object) A params object to be merged into url.
    //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
    //    specified, and is as-follows:
    // 
    //    * 0: params in the params argument will override any query string
    //         params in url.
    //    * 1: any query string params in url will override params in the params
    //         argument.
    //    * 2: params argument will completely replace any query string in url.
    // 
    // Returns:
    // 
    //  (String) Either a params string with urlencoded data or a URL with a
    //    urlencoded query string in the format 'a=b&c=d&e=f'.
    
    // Method: jQuery.param.fragment
    // 
    // Retrieve the fragment (hash) from a URL or if no arguments are passed, the
    // current window.location.
    // 
    // Usage:
    // 
    // > jQuery.param.fragment( [ url ] );
    // 
    // Arguments:
    // 
    //  url - (String) A URL containing fragment (hash) params to be parsed. If
    //    url is not passed, the current window.location is used.
    // 
    // Returns:
    // 
    //  (String) The parsed fragment (hash) string, with any leading "#" removed.
    
    // Method: jQuery.param.fragment (build url)
    // 
    // Merge a URL, with or without pre-existing fragment (hash) params, plus any
    // object, params string or URL containing fragment (hash) params into a new
    // URL.
    // 
    // Usage:
    // 
    // > jQuery.param.fragment( url, params [, merge_mode ] );
    // 
    // Arguments:
    // 
    //  url - (String) A valid URL for params to be merged into. This URL may
    //    contain a query string and/or fragment (hash).
    //  params - (String) A params string or URL containing fragment (hash) params
    //    to be merged into url.
    //  params - (Object) A params object to be merged into url.
    //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
    //    specified, and is as-follows:
    // 
    //    * 0: params in the params argument will override any fragment (hash)
    //         params in url.
    //    * 1: any fragment (hash) params in url will override params in the
    //         params argument.
    //    * 2: params argument will completely replace any query string in url.
    // 
    // Returns:
    // 
    //  (String) Either a params string with urlencoded data or a URL with a
    //    urlencoded fragment (hash) in the format 'a=b&c=d&e=f'.
    
    function jq_param_sub( is_fragment, get_func, url, params, merge_mode ) {
      var result,
        qs,
        matches,
        url_params,
        hash;
      
      if ( params !== undefined ) {
        // Build URL by merging params into url string.
        
        // matches[1] = url part that precedes params, not including trailing ?/#
        // matches[2] = params, not including leading ?/#
        // matches[3] = if in 'querystring' mode, hash including leading #, otherwise ''
        matches = url.match( is_fragment ? /^([^#]*)\#?(.*)$/ : /^([^#?]*)\??([^#]*)(#?.*)/ );
        
        // Get the hash if in 'querystring' mode, and it exists.
        hash = matches[3] || '';
        
        if ( merge_mode === 2 && is_string( params ) ) {
          // If merge_mode is 2 and params is a string, merge the fragment / query
          // string into the URL wholesale, without converting it into an object.
          qs = params.replace( is_fragment ? re_trim_fragment : re_trim_querystring, '' );
          
        } else {
          // Convert relevant params in url to object.
          url_params = jq_deparam( matches[2] );
          
          params = is_string( params )
            
            // Convert passed params string into object.
            ? jq_deparam[ is_fragment ? str_fragment : str_querystring ]( params )
            
            // Passed params object.
            : params;
          
          qs = merge_mode === 2 ? params                              // passed params replace url params
            : merge_mode === 1  ? $.extend( {}, params, url_params )  // url params override passed params
            : $.extend( {}, url_params, params );                     // passed params override url params
          
          // Convert params object to a string.
          qs = jq_param( qs );
        }
        
        // Build URL from the base url, querystring and hash. In 'querystring'
        // mode, ? is only added if a query string exists. In 'fragment' mode, #
        // is always added.
        result = matches[1] + ( is_fragment ? '#' : qs || !matches[1] ? '?' : '' ) + qs + hash;
        
      } else {
        // If URL was passed in, parse params from URL string, otherwise parse
        // params from window.location.
        result = get_func( url !== undefined ? url : loc[ str_href ] );
      }
      
      return result;
    };
    
    jq_param[ str_querystring ]                  = curry( jq_param_sub, 0, get_querystring );
    jq_param[ str_fragment ] = jq_param_fragment = curry( jq_param_sub, 1, get_fragment );
    
    // Section: Deparam (from string)
    // 
    // Method: jQuery.deparam
    // 
    // Deserialize a params string into an object, optionally coercing numbers,
    // booleans, null and undefined values; this method is the counterpart to the
    // internal jQuery.param method.
    // 
    // Usage:
    // 
    // > jQuery.deparam( params [, coerce ] );
    // 
    // Arguments:
    // 
    //  params - (String) A params string to be parsed.
    //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
    //    undefined to their actual value. Defaults to false if omitted.
    // 
    // Returns:
    // 
    //  (Object) An object representing the deserialized params string.
    
    $.deparam = jq_deparam = function( params, coerce ) {
      var obj = {},
        coerce_types = { 'true': !0, 'false': !1, 'null': null };
      
      // Iterate over all name=value pairs.
      $.each( params.replace( /\+/g, ' ' ).split( '&' ), function(j,v){
        var param = v.split( '=' ),
          key = decode( param[0] ),
          val,
          cur = obj,
          i = 0,
          
          // If key is more complex than 'foo', like 'a[]' or 'a[b][c]', split it
          // into its component parts.
          keys = key.split( '][' ),
          keys_last = keys.length - 1;
        
        // If the first keys part contains [ and the last ends with ], then []
        // are correctly balanced.
        if ( /\[/.test( keys[0] ) && /\]$/.test( keys[ keys_last ] ) ) {
          // Remove the trailing ] from the last keys part.
          keys[ keys_last ] = keys[ keys_last ].replace( /\]$/, '' );
          
          // Split first keys part into two parts on the [ and add them back onto
          // the beginning of the keys array.
          keys = keys.shift().split('[').concat( keys );
          
          keys_last = keys.length - 1;
        } else {
          // Basic 'foo' style key.
          keys_last = 0;
        }
        
        // Are we dealing with a name=value pair, or just a name?
        if ( param.length === 2 ) {
          val = decode( param[1] );
          
          // Coerce values.
          if ( coerce ) {
            val = val && !isNaN(val)            ? +val              // number
              : val === 'undefined'             ? undefined         // undefined
              : coerce_types[val] !== undefined ? coerce_types[val] // true, false, null
              : val;                                                // string
          }
          
          if ( keys_last ) {
            // Complex key, build deep object structure based on a few rules:
            // * The 'cur' pointer starts at the object top-level.
            // * [] = array push (n is set to array length), [n] = array if n is 
            //   numeric, otherwise object.
            // * If at the last keys part, set the value.
            // * For each keys part, if the current level is undefined create an
            //   object or array based on the type of the next keys part.
            // * Move the 'cur' pointer to the next level.
            // * Rinse & repeat.
            for ( ; i <= keys_last; i++ ) {
              key = keys[i] === '' ? cur.length : keys[i];
              cur = cur[key] = i < keys_last
                ? cur[key] || ( keys[i+1] && isNaN( keys[i+1] ) ? {} : [] )
                : val;
            }
            
          } else {
            // Simple key, even simpler rules, since only scalars and shallow
            // arrays are allowed.
            
            if ( $.isArray( obj[key] ) ) {
              // val is already an array, so push on the next value.
              obj[key].push( val );
              
            } else if ( obj[key] !== undefined ) {
              // val isn't an array, but since a second value has been specified,
              // convert val into an array.
              obj[key] = [ obj[key], val ];
              
            } else {
              // val is a scalar.
              obj[key] = val;
            }
          }
          
        } else if ( key ) {
          // No value was defined, so set something meaningful.
          obj[key] = coerce
            ? undefined
            : '';
        }
      });
      
      return obj;
    };
    
    // Method: jQuery.deparam.querystring
    // 
    // Parse the query string from a URL or the current window.location,
    // deserializing it into an object, optionally coercing numbers, booleans,
    // null and undefined values.
    // 
    // Usage:
    // 
    // > jQuery.deparam.querystring( [ url ] [, coerce ] );
    // 
    // Arguments:
    // 
    //  url - (String) An optional params string or URL containing query string
    //    params to be parsed. If url is omitted, the current window.location
    //    is used.
    //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
    //    undefined to their actual value. Defaults to false if omitted.
    // 
    // Returns:
    // 
    //  (Object) An object representing the deserialized params string.
    
    // Method: jQuery.deparam.fragment
    // 
    // Parse the fragment (hash) from a URL or the current window.location,
    // deserializing it into an object, optionally coercing numbers, booleans,
    // null and undefined values.
    // 
    // Usage:
    // 
    // > jQuery.deparam.fragment( [ url ] [, coerce ] );
    // 
    // Arguments:
    // 
    //  url - (String) An optional params string or URL containing fragment (hash)
    //    params to be parsed. If url is omitted, the current window.location
    //    is used.
    //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
    //    undefined to their actual value. Defaults to false if omitted.
    // 
    // Returns:
    // 
    //  (Object) An object representing the deserialized params string.
    
    function jq_deparam_sub( is_fragment, url_or_params, coerce ) {
      if ( url_or_params === undefined || typeof url_or_params === 'boolean' ) {
        // url_or_params not specified.
        coerce = url_or_params;
        url_or_params = jq_param[ is_fragment ? str_fragment : str_querystring ]();
      } else {
        url_or_params = is_string( url_or_params )
          ? url_or_params.replace( is_fragment ? re_trim_fragment : re_trim_querystring, '' )
          : url_or_params;
      }
      
      return jq_deparam( url_or_params, coerce );
    };
    
    jq_deparam[ str_querystring ]                    = curry( jq_deparam_sub, 0 );
    jq_deparam[ str_fragment ] = jq_deparam_fragment = curry( jq_deparam_sub, 1 );
    
    // Section: Element manipulation
    // 
    // Method: jQuery.elemUrlAttr
    // 
    // Get the internal "Default URL attribute per tag" list, or augment the list
    // with additional tag-attribute pairs, in case the defaults are insufficient.
    // 
    // In the <jQuery.fn.querystring> and <jQuery.fn.fragment> methods, this list
    // is used to determine which attribute contains the URL to be modified, if
    // an "attr" param is not specified.
    // 
    // Default Tag-Attribute List:
    // 
    //  a      - href
    //  base   - href
    //  iframe - src
    //  img    - src
    //  input  - src
    //  form   - action
    //  link   - href
    //  script - src
    // 
    // Usage:
    // 
    // > jQuery.elemUrlAttr( [ tag_attr ] );
    // 
    // Arguments:
    // 
    //  tag_attr - (Object) An object containing a list of tag names and their
    //    associated default attribute names in the format { tag: 'attr', ... } to
    //    be merged into the internal tag-attribute list.
    // 
    // Returns:
    // 
    //  (Object) An object containing all stored tag-attribute values.
    
    // Only define function and set defaults if function doesn't already exist, as
    // the urlInternal plugin will provide this method as well.
    $[ str_elemUrlAttr ] || ($[ str_elemUrlAttr ] = function( obj ) {
      return $.extend( elemUrlAttr_cache, obj );
    })({
      a: str_href,
      base: str_href,
      iframe: str_src,
      img: str_src,
      input: str_src,
      form: 'action',
      link: str_href,
      script: str_src
    });
    
    jq_elemUrlAttr = $[ str_elemUrlAttr ];
    
    // Method: jQuery.fn.querystring
    // 
    // Update URL attribute in one or more elements, merging the current URL (with
    // or without pre-existing query string params) plus any params object or
    // string into a new URL, which is then set into that attribute. Like
    // <jQuery.param.querystring (build url)>, but for all elements in a jQuery
    // collection.
    // 
    // Usage:
    // 
    // > jQuery('selector').querystring( [ attr, ] params [, merge_mode ] );
    // 
    // Arguments:
    // 
    //  attr - (String) Optional name of an attribute that will contain a URL to
    //    merge params or url into. See <jQuery.elemUrlAttr> for a list of default
    //    attributes.
    //  params - (Object) A params object to be merged into the URL attribute.
    //  params - (String) A URL containing query string params, or params string
    //    to be merged into the URL attribute.
    //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
    //    specified, and is as-follows:
    //    
    //    * 0: params in the params argument will override any params in attr URL.
    //    * 1: any params in attr URL will override params in the params argument.
    //    * 2: params argument will completely replace any query string in attr
    //         URL.
    // 
    // Returns:
    // 
    //  (jQuery) The initial jQuery collection of elements, but with modified URL
    //  attribute values.
    
    // Method: jQuery.fn.fragment
    // 
    // Update URL attribute in one or more elements, merging the current URL (with
    // or without pre-existing fragment/hash params) plus any params object or
    // string into a new URL, which is then set into that attribute. Like
    // <jQuery.param.fragment (build url)>, but for all elements in a jQuery
    // collection.
    // 
    // Usage:
    // 
    // > jQuery('selector').fragment( [ attr, ] params [, merge_mode ] );
    // 
    // Arguments:
    // 
    //  attr - (String) Optional name of an attribute that will contain a URL to
    //    merge params into. See <jQuery.elemUrlAttr> for a list of default
    //    attributes.
    //  params - (Object) A params object to be merged into the URL attribute.
    //  params - (String) A URL containing fragment (hash) params, or params
    //    string to be merged into the URL attribute.
    //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
    //    specified, and is as-follows:
    //    
    //    * 0: params in the params argument will override any params in attr URL.
    //    * 1: any params in attr URL will override params in the params argument.
    //    * 2: params argument will completely replace any fragment (hash) in attr
    //         URL.
    // 
    // Returns:
    // 
    //  (jQuery) The initial jQuery collection of elements, but with modified URL
    //  attribute values.
    
    function jq_fn_sub( mode, force_attr, params, merge_mode ) {
      if ( !is_string( params ) && typeof params !== 'object' ) {
        // force_attr not specified.
        merge_mode = params;
        params = force_attr;
        force_attr = undefined;
      }
      
      return this.each(function(){
        var that = $(this),
          
          // Get attribute specified, or default specified via $.elemUrlAttr.
          attr = force_attr || jq_elemUrlAttr()[ ( this.nodeName || '' ).toLowerCase() ] || '',
          
          // Get URL value.
          url = attr && that.attr( attr ) || '';
        
        // Update attribute with new URL.
        that.attr( attr, jq_param[ mode ]( url, params, merge_mode ) );
      });
      
    };
    
    $.fn[ str_querystring ] = curry( jq_fn_sub, str_querystring );
    $.fn[ str_fragment ]    = curry( jq_fn_sub, str_fragment );
    
    // Section: History, hashchange event
    // 
    // Method: jQuery.bbq.pushState
    // 
    // Adds a 'state' into the browser history at the current position, setting
    // location.hash and triggering any bound <window.onhashchange> event
    // callbacks (provided the new state is different than the previous state).
    // 
    // If no arguments are passed, an empty state is created, which is just a
    // shortcut for jQuery.bbq.pushState( {}, 2 ).
    // 
    // Usage:
    // 
    // > jQuery.bbq.pushState( [ params [, merge_mode ] ] );
    // 
    // Arguments:
    // 
    //  params - (String) A serialized params string or a hash string beginning
    //    with # to merge into location.hash.
    //  params - (Object) A params object to merge into location.hash.
    //  merge_mode - (Number) Merge behavior defaults to 0 if merge_mode is not
    //    specified (unless a hash string beginning with # is specified, in which
    //    case merge behavior defaults to 2), and is as-follows:
    // 
    //    * 0: params in the params argument will override any params in the
    //         current state.
    //    * 1: any params in the current state will override params in the params
    //         argument.
    //    * 2: params argument will completely replace current state.
    // 
    // Returns:
    // 
    //  Nothing.
    // 
    // Additional Notes:
    // 
    //  * Setting an empty state may cause the browser to scroll.
    //  * Unlike the fragment and querystring methods, if a hash string beginning
    //    with # is specified as the params agrument, merge_mode defaults to 2.
    
    jq_bbq.pushState = jq_bbq_pushState = function( params, merge_mode ) {
      if ( is_string( params ) && /^#/.test( params ) && merge_mode === undefined ) {
        // Params string begins with # and merge_mode not specified, so completely
        // overwrite window.location.hash.
        merge_mode = 2;
      }
      
      var has_args = params !== undefined,
        // Merge params into window.location using $.param.fragment.
        url = jq_param_fragment( loc[ str_href ], has_args ? params : {}, has_args ? merge_mode : 2 );
      
      // Set new window.location.href. If hash is empty, use just # to prevent
      // browser from reloading the page. Note that Safari 3 & Chrome barf on
      // location.hash = '#'.
      loc[ str_href ] = url + ( /#/.test( url ) ? '' : '#' );
    };
    
    
    // Method: jQuery.bbq.getState
    // 
    // Retrieves the current 'state' from the browser history, parsing
    // location.hash for a specific key or returning an object containing the
    // entire state, optionally coercing numbers, booleans, null and undefined
    // values.
    // 
    // Usage:
    // 
    // > jQuery.bbq.getState( [ key ] [, coerce ] );
    // 
    // Arguments:
    // 
    //  key - (String) An optional state key for which to return a value.
    //  coerce - (Boolean) If true, coerces any numbers or true, false, null, and
    //    undefined to their actual value. Defaults to false.
    // 
    // Returns:
    // 
    //  (Anything) If key is passed, returns the value corresponding with that key
    //    in the location.hash 'state', or undefined. If not, an object
    //    representing the entire 'state' is returned.
    
    jq_bbq.getState = jq_bbq_getState = function( key, coerce ) {
      return key === undefined || typeof key === 'boolean'
        ? jq_deparam_fragment( key ) // 'key' really means 'coerce' here
        : jq_deparam_fragment( coerce )[ key ];
    };
    
    // Method: jQuery.bbq.removeState
    // 
    // Remove one or more keys from the current browser history 'state', creating
    // a new state, setting location.hash and triggering any bound
    // <window.onhashchange> event callbacks (provided the new state is different
    // than the previous state).
    // 
    // If no arguments are passed, an empty state is created, which is just a
    // shortcut for jQuery.bbq.pushState( {}, 2 ).
    // 
    // Usage:
    // 
    // > jQuery.bbq.removeState( [ key [, key ... ] ] );
    // 
    // Arguments:
    // 
    //  key - (String) One or more key values to remove from the current state,
    //    passed as individual arguments.
    //  key - (Array) A single array argument that contains a list of key values
    //    to remove from the current state.
    // 
    // Returns:
    // 
    //  Nothing.
    // 
    // Additional Notes:
    // 
    //  * Setting an empty state may cause the browser to scroll.
    
    jq_bbq.removeState = function( arr ) {
      var state = {};
      
      // If one or more arguments is passed..
      if ( arr !== undefined ) {
        
        // Get the current state.
        state = jq_bbq_getState();
        
        // For each passed key, delete the corresponding property from the current
        // state.
        $.each( $.isArray( arr ) ? arr : arguments, function(i,v){
          delete state[ v ];
        });
      }
      
      // Set the state, completely overriding any existing state.
      jq_bbq_pushState( state, 2 );
    };
    
    // Event: window.onhashchange
    // 
    // Usage in 1.4 and newer:
    // 
    // In 1.4 and newer, the event object that is passed into the callback is
    // augmented with an additional e.fragment property that contains the current
    // document location.hash state as a string, as well as an e.getState method.
    // 
    // e.fragment is equivalent to the output of <jQuery.param.fragment>, and
    // e.getState() is equivalent to <jQuery.bbq.getState>, except that they refer
    // to the event-specific state value stored in the event object, instead of
    // the current window.location, allowing the event object to be referenced
    // later, even if window.location has changed.
    // 
    // > $(window).bind( 'hashchange', function(e) {
    // >   var hash_str = e.fragment,
    // >     param_obj = e.getState(),
    // >     param_val = e.getState( 'param_name' ),
    // >     param_val_coerced = e.getState( 'param_name', true );
    // >   ...
    // > });
    // 
    // Usage in 1.3.2:
    // 
    // In 1.3.2, the event object is unable to be augmented as in 1.4+, so the
    // fragment state isn't bound to the event object and must instead be parsed
    // using the <jQuery.param.fragment> and <jQuery.bbq.getState> methods.
    // 
    // > $(window).bind( 'hashchange', function(e) {
    // >   var hash_str = $.param.fragment(),
    // >     param_obj = $.bbq.getState(),
    // >     param_val = $.bbq.getState( 'param_name' ),
    // >     param_val_coerced = $.bbq.getState( 'param_name', true );
    // >   ...
    // > });
    // 
    // Additional Notes:
    // 
    // * See <jQuery hashchange event> for more detailed information.
    
    jq_event_special[ str_hashchange ] = $.extend( jq_event_special[ str_hashchange ], {
      
      // Augmenting the event object with the .fragment property and .getState
      // method requires jQuery 1.4 or newer. Note: with 1.3.2, everything will
      // work, but the event won't be augmented)
      add: function( handler, data, namespaces ) {
        return function(e) {
          // e.fragment is set to the value of location.hash (with any leading #
          // removed) at the time the event is triggered.
          var hash = e[ str_fragment ] = jq_param_fragment();
          
          // e.getState() works just like $.bbq.getState(), but uses the
          // e.fragment property stored on the event object.
          e.getState = function( key, coerce ) {
            return key === undefined || typeof key === 'boolean'
              ? jq_deparam( hash, key ) // 'key' really means 'coerce' here
              : jq_deparam( hash, coerce )[ key ];
          };
          
          handler.apply( this, arguments );
        };
      }
      
    });
    
  })(jQuery,this);
  
  /*!
   * jQuery hashchange event - v1.1 - 1/21/2010
   * http://benalman.com/projects/jquery-hashchange-plugin/
   * 
   * Copyright (c) 2010 "Cowboy" Ben Alman
   * Dual licensed under the MIT and GPL licenses.
   * http://benalman.com/about/license/
   */
  
  // Script: jQuery hashchange event
  //
  // *Version: 1.1, Last updated: 1/21/2010*
  // 
  // Project Home - http://benalman.com/projects/jquery-hashchange-plugin/
  // GitHub       - http://github.com/cowboy/jquery-hashchange/
  // Source       - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.js
  // (Minified)   - http://github.com/cowboy/jquery-hashchange/raw/master/jquery.ba-hashchange.min.js (1.1kb)
  // 
  // About: License
  // 
  // Copyright (c) 2010 "Cowboy" Ben Alman,
  // Dual licensed under the MIT and GPL licenses.
  // http://benalman.com/about/license/
  // 
  // About: Examples
  // 
  // This working example, complete with fully commented code, illustrate one way
  // in which this plugin can be used.
  // 
  // hashchange event - http://benalman.com/code/projects/jquery-hashchange/examples/hashchange/
  // 
  // About: Support and Testing
  // 
  // Information about what version or versions of jQuery this plugin has been
  // tested with, what browsers it has been tested in, and where the unit tests
  // reside (so you can test it yourself).
  // 
  // jQuery Versions - 1.3.2, 1.4
  // Browsers Tested - Internet Explorer 6-8, Firefox 2-3.7, Safari 3-4, Chrome, Opera 9.6-10.
  // Unit Tests      - http://benalman.com/code/projects/jquery-hashchange/unit/
  // 
  // About: Known issues
  // 
  // While this jQuery hashchange event implementation is quite stable and robust,
  // there are a few unfortunate browser bugs surrounding expected hashchange
  // event-based behaviors, independent of any JavaScript window.onhashchange
  // abstraction. See the following examples for more information:
  // 
  // Chrome: Back Button - http://benalman.com/code/projects/jquery-hashchange/examples/bug-chrome-back-button/
  // Firefox: Remote XMLHttpRequest - http://benalman.com/code/projects/jquery-hashchange/examples/bug-firefox-remote-xhr/
  // WebKit: Back Button in an Iframe - http://benalman.com/code/projects/jquery-hashchange/examples/bug-webkit-hash-iframe/
  // 
  // About: Release History
  // 
  // 1.1   - (1/21/2010) Incorporated document.documentMode test to fix IE8 bug
  //         where browser version is incorrectly reported as 8.0, despite
  //         inclusion of the X-UA-Compatible IE=EmulateIE7 meta tag.
  // 1.0   - (1/9/2010) Initial Release. Broke out the jQuery BBQ event.special
  //         window.onhashchange functionality into a separate plugin for users
  //         who want just the basic event & back button support, without all the
  //         extra awesomeness that BBQ provides. This plugin will be included as
  //         part of jQuery BBQ, but also be available separately.
  
  (function($,window,undefined){
    '$:nomunge'; // Used by YUI compressor.
    
    // A convenient shortcut.
    var loc = window.location,
      
      // Method / object references.
      fake_onhashchange,
      jq_event_special = $.event.special,
      
      // Reused strings.
      str_hashchange = 'hashchange',
      
      // IE6/7 specifically need some special love when it comes to back-button
      // support, so let's do a little browser sniffing..
      browser = $.browser,
      mode = document.documentMode,
      is_old_ie = browser.msie && ( mode === undefined || mode < 8 ),
      
      // Does the browser support window.onhashchange? Test for IE version, since
      // IE8 incorrectly reports this when in "IE7" or "IE8 Compatibility View"!
      supports_onhashchange = 'on' + str_hashchange in window && !is_old_ie;
    
    // Get location.hash (or what you'd expect location.hash to be) sans any
    // leading #. Thanks for making this necessary, Firefox!
    function get_fragment( url ) {
      url = url || loc.href;
      return url.replace( /^[^#]*#?(.*)$/, '$1' );
    };
    
    // Property: jQuery.hashchangeDelay
    // 
    // The numeric interval (in milliseconds) at which the <window.onhashchange>
    // polling loop executes. Defaults to 100.
    
    $[ str_hashchange + 'Delay' ] = 100;
    
    // Event: window.onhashchange
    // 
    // Fired when window.location.hash changes. In browsers that support it, the
    // native window.onhashchange event is used (IE8, FF3.6), otherwise a polling
    // loop is initialized, running every <jQuery.hashchangeDelay> milliseconds
    // to see if the hash has changed. In IE 6 and 7, a hidden IFRAME is created
    // to allow the back button and hash-based history to work.
    // 
    // Usage:
    // 
    // > $(window).bind( 'hashchange', function(e) {
    // >   var hash = location.hash;
    // >   ...
    // > });
    // 
    // Additional Notes:
    // 
    // * The polling loop and iframe are not created until at least one callback
    //   is actually bound to 'hashchange'.
    // * If you need the bound callback(s) to execute immediately, in cases where
    //   the page 'state' exists on page load (via bookmark or page refresh, for
    //   example) use $(window).trigger( 'hashchange' );
    
    jq_event_special[ str_hashchange ] = $.extend( jq_event_special[ str_hashchange ], {
      
      // Called only when the first 'hashchange' event is bound to window.
      setup: function() {
        // If window.onhashchange is supported natively, there's nothing to do..
        if ( supports_onhashchange ) { return false; }
        
        // Otherwise, we need to create our own. And we don't want to call this
        // until the user binds to the event, just in case they never do, since it
        // will create a polling loop and possibly even a hidden IFRAME.
        fake_onhashchange.start();
      },
      
      // Called only when the last 'hashchange' event is unbound from window.
      teardown: function() {
        // If window.onhashchange is supported natively, there's nothing to do..
        if ( supports_onhashchange ) { return false; }
        
        // Otherwise, we need to stop ours (if possible).
        fake_onhashchange.stop();
      }
      
    });
    
    // fake_onhashchange does all the work of triggering the window.onhashchange
    // event for browsers that don't natively support it, including creating a
    // polling loop to watch for hash changes and in IE 6/7 creating a hidden
    // IFRAME to enable back and forward.
    fake_onhashchange = (function(){
      var self = {},
        timeout_id,
        iframe,
        set_history,
        get_history;
      
      // Initialize. In IE 6/7, creates a hidden IFRAME for history handling.
      function init(){
        // Most browsers don't need special methods here..
        set_history = get_history = function(val){ return val; };
        
        // But IE6/7 do!
        if ( is_old_ie ) {
          
          // Create hidden IFRAME at the end of the body.
          iframe = $('<iframe src="javascript:0"/>').hide().appendTo( 'body' )[0].contentWindow;
          
          // Get history by looking at the hidden IFRAME's location.hash.
          get_history = function() {
            return get_fragment( iframe.document.location.href );
          };
          
          // Set a new history item by opening and then closing the IFRAME
          // document, *then* setting its location.hash.
          set_history = function( hash, history_hash ) {
            if ( hash !== history_hash ) {
              var doc = iframe.document;
              doc.open().close();
              doc.location.hash = '#' + hash;
            }
          };
          
          // Set initial history.
          set_history( get_fragment() );
        }
      };
      
      // Start the polling loop.
      self.start = function() {
        // Polling loop is already running!
        if ( timeout_id ) { return; }
        
        // Remember the initial hash so it doesn't get triggered immediately.
        var last_hash = get_fragment();
        
        // Initialize if not yet initialized.
        set_history || init();
        
        // This polling loop checks every $.hashchangeDelay milliseconds to see if
        // location.hash has changed, and triggers the 'hashchange' event on
        // window when necessary.
        (function loopy(){
          var hash = get_fragment(),
            history_hash = get_history( last_hash );
          
          if ( hash !== last_hash ) {
            set_history( last_hash = hash, history_hash );
            
            $(window).trigger( str_hashchange );
            
          } else if ( history_hash !== last_hash ) {
            loc.href = loc.href.replace( /#.*/, '' ) + '#' + history_hash;
          }
          
          timeout_id = setTimeout( loopy, $[ str_hashchange + 'Delay' ] );
        })();
      };
      
      // Stop the polling loop, but only if an IE6/7 IFRAME wasn't created. In
      // that case, even if there are no longer any bound event handlers, the
      // polling loop is still necessary for back/next to work at all!
      self.stop = function() {
        if ( !iframe ) {
          timeout_id && clearTimeout( timeout_id );
          timeout_id = 0;
        }
      };
      
      return self;
    })();
    
  })(jQuery,this);
  