sass-site/source/assets/js/vendor/jquery-ui-1.11.0.custom.js

/*! jQuery UI - v1.11.0 - 2014-07-27
* http://jqueryui.com
* Includes: core.js, widget.js, tabs.js
* Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */

(function( factory ) {
  if ( typeof define === "function" && define.amd ) {

    // AMD. Register as an anonymous module.
    define([ "jquery" ], factory );
  } else {

    // Browser globals
    factory( jQuery );
  }
}(function( $ ) {
/*!
 * jQuery UI Core 1.11.0
 * http://jqueryui.com
 *
 * Copyright 2014 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/category/ui-core/
 */


// $.ui might exist from components with no dependencies, e.g., $.ui.position
$.ui = $.ui || {};

$.extend( $.ui, {
  version: "1.11.0",

  keyCode: {
    BACKSPACE: 8,
    COMMA: 188,
    DELETE: 46,
    DOWN: 40,
    END: 35,
    ENTER: 13,
    ESCAPE: 27,
    HOME: 36,
    LEFT: 37,
    PAGE_DOWN: 34,
    PAGE_UP: 33,
    PERIOD: 190,
    RIGHT: 39,
    SPACE: 32,
    TAB: 9,
    UP: 38
  }
});

// plugins
$.fn.extend({
  scrollParent: function() {
    var position = this.css( "position" ),
      excludeStaticParent = position === "absolute",
      scrollParent = this.parents().filter( function() {
        var parent = $( this );
        if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
          return false;
        }
        return (/(auto|scroll)/).test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
      }).eq( 0 );

    return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
  },

  uniqueId: (function() {
    var uuid = 0;

    return function() {
      return this.each(function() {
        if ( !this.id ) {
          this.id = "ui-id-" + ( ++uuid );
        }
      });
    };
  })(),

  removeUniqueId: function() {
    return this.each(function() {
      if ( /^ui-id-\d+$/.test( this.id ) ) {
        $( this ).removeAttr( "id" );
      }
    });
  }
});

// selectors
function focusable( element, isTabIndexNotNaN ) {
  var map, mapName, img,
    nodeName = element.nodeName.toLowerCase();
  if ( "area" === nodeName ) {
    map = element.parentNode;
    mapName = map.name;
    if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
      return false;
    }
    img = $( "img[usemap=#" + mapName + "]" )[0];
    return !!img && visible( img );
  }
  return ( /input|select|textarea|button|object/.test( nodeName ) ?
    !element.disabled :
    "a" === nodeName ?
      element.href || isTabIndexNotNaN :
      isTabIndexNotNaN) &&
    // the element and all of its ancestors must be visible
    visible( element );
}

function visible( element ) {
  return $.expr.filters.visible( element ) &&
    !$( element ).parents().addBack().filter(function() {
      return $.css( this, "visibility" ) === "hidden";
    }).length;
}

$.extend( $.expr[ ":" ], {
  data: $.expr.createPseudo ?
    $.expr.createPseudo(function( dataName ) {
      return function( elem ) {
        return !!$.data( elem, dataName );
      };
    }) :
    // support: jQuery <1.8
    function( elem, i, match ) {
      return !!$.data( elem, match[ 3 ] );
    },

  focusable: function( element ) {
    return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
  },

  tabbable: function( element ) {
    var tabIndex = $.attr( element, "tabindex" ),
      isTabIndexNaN = isNaN( tabIndex );
    return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
  }
});

// support: jQuery <1.8
if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
  $.each( [ "Width", "Height" ], function( i, name ) {
    var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
      type = name.toLowerCase(),
      orig = {
        innerWidth: $.fn.innerWidth,
        innerHeight: $.fn.innerHeight,
        outerWidth: $.fn.outerWidth,
        outerHeight: $.fn.outerHeight
      };

    function reduce( elem, size, border, margin ) {
      $.each( side, function() {
        size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
        if ( border ) {
          size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
        }
        if ( margin ) {
          size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
        }
      });
      return size;
    }

    $.fn[ "inner" + name ] = function( size ) {
      if ( size === undefined ) {
        return orig[ "inner" + name ].call( this );
      }

      return this.each(function() {
        $( this ).css( type, reduce( this, size ) + "px" );
      });
    };

    $.fn[ "outer" + name] = function( size, margin ) {
      if ( typeof size !== "number" ) {
        return orig[ "outer" + name ].call( this, size );
      }

      return this.each(function() {
        $( this).css( type, reduce( this, size, true, margin ) + "px" );
      });
    };
  });
}

// support: jQuery <1.8
if ( !$.fn.addBack ) {
  $.fn.addBack = function( selector ) {
    return this.add( selector == null ?
      this.prevObject : this.prevObject.filter( selector )
    );
  };
}

// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
  $.fn.removeData = (function( removeData ) {
    return function( key ) {
      if ( arguments.length ) {
        return removeData.call( this, $.camelCase( key ) );
      } else {
        return removeData.call( this );
      }
    };
  })( $.fn.removeData );
}

// deprecated
$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );

$.fn.extend({
  focus: (function( orig ) {
    return function( delay, fn ) {
      return typeof delay === "number" ?
        this.each(function() {
          var elem = this;
          setTimeout(function() {
            $( elem ).focus();
            if ( fn ) {
              fn.call( elem );
            }
          }, delay );
        }) :
        orig.apply( this, arguments );
    };
  })( $.fn.focus ),

  disableSelection: (function() {
    var eventType = "onselectstart" in document.createElement( "div" ) ?
      "selectstart" :
      "mousedown";

    return function() {
      return this.bind( eventType + ".ui-disableSelection", function( event ) {
        event.preventDefault();
      });
    };
  })(),

  enableSelection: function() {
    return this.unbind( ".ui-disableSelection" );
  },

  zIndex: function( zIndex ) {
    if ( zIndex !== undefined ) {
      return this.css( "zIndex", zIndex );
    }

    if ( this.length ) {
      var elem = $( this[ 0 ] ), position, value;
      while ( elem.length && elem[ 0 ] !== document ) {
        // Ignore z-index if position is set to a value where z-index is ignored by the browser
        // This makes behavior of this function consistent across browsers
        // WebKit always returns auto if the element is positioned
        position = elem.css( "position" );
        if ( position === "absolute" || position === "relative" || position === "fixed" ) {
          // IE returns 0 when zIndex is not specified
          // other browsers return a string
          // we ignore the case of nested elements with an explicit value of 0
          // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
          value = parseInt( elem.css( "zIndex" ), 10 );
          if ( !isNaN( value ) && value !== 0 ) {
            return value;
          }
        }
        elem = elem.parent();
      }
    }

    return 0;
  }
});

// $.ui.plugin is deprecated. Use $.widget() extensions instead.
$.ui.plugin = {
  add: function( module, option, set ) {
    var i,
      proto = $.ui[ module ].prototype;
    for ( i in set ) {
      proto.plugins[ i ] = proto.plugins[ i ] || [];
      proto.plugins[ i ].push( [ option, set[ i ] ] );
    }
  },
  call: function( instance, name, args, allowDisconnected ) {
    var i,
      set = instance.plugins[ name ];

    if ( !set ) {
      return;
    }

    if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
      return;
    }

    for ( i = 0; i < set.length; i++ ) {
      if ( instance.options[ set[ i ][ 0 ] ] ) {
        set[ i ][ 1 ].apply( instance.element, args );
      }
    }
  }
};


/*!
 * jQuery UI Widget 1.11.0
 * http://jqueryui.com
 *
 * Copyright 2014 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/jQuery.widget/
 */


var widget_uuid = 0,
  widget_slice = Array.prototype.slice;

$.cleanData = (function( orig ) {
  return function( elems ) {
    for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
      try {
        $( elem ).triggerHandler( "remove" );
      // http://bugs.jquery.com/ticket/8235
      } catch( e ) {}
    }
    orig( elems );
  };
})( $.cleanData );

$.widget = function( name, base, prototype ) {
  var fullName, existingConstructor, constructor, basePrototype,
    // proxiedPrototype allows the provided prototype to remain unmodified
    // so that it can be used as a mixin for multiple widgets (#8876)
    proxiedPrototype = {},
    namespace = name.split( "." )[ 0 ];

  name = name.split( "." )[ 1 ];
  fullName = namespace + "-" + name;

  if ( !prototype ) {
    prototype = base;
    base = $.Widget;
  }

  // create selector for plugin
  $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
    return !!$.data( elem, fullName );
  };

  $[ namespace ] = $[ namespace ] || {};
  existingConstructor = $[ namespace ][ name ];
  constructor = $[ namespace ][ name ] = function( options, element ) {
    // allow instantiation without "new" keyword
    if ( !this._createWidget ) {
      return new constructor( options, element );
    }

    // allow instantiation without initializing for simple inheritance
    // must use "new" keyword (the code above always passes args)
    if ( arguments.length ) {
      this._createWidget( options, element );
    }
  };
  // extend with the existing constructor to carry over any static properties
  $.extend( constructor, existingConstructor, {
    version: prototype.version,
    // copy the object used to create the prototype in case we need to
    // redefine the widget later
    _proto: $.extend( {}, prototype ),
    // track widgets that inherit from this widget in case this widget is
    // redefined after a widget inherits from it
    _childConstructors: []
  });

  basePrototype = new base();
  // we need to make the options hash a property directly on the new instance
  // otherwise we'll modify the options hash on the prototype that we're
  // inheriting from
  basePrototype.options = $.widget.extend( {}, basePrototype.options );
  $.each( prototype, function( prop, value ) {
    if ( !$.isFunction( value ) ) {
      proxiedPrototype[ prop ] = value;
      return;
    }
    proxiedPrototype[ prop ] = (function() {
      var _super = function() {
          return base.prototype[ prop ].apply( this, arguments );
        },
        _superApply = function( args ) {
          return base.prototype[ prop ].apply( this, args );
        };
      return function() {
        var __super = this._super,
          __superApply = this._superApply,
          returnValue;

        this._super = _super;
        this._superApply = _superApply;

        returnValue = value.apply( this, arguments );

        this._super = __super;
        this._superApply = __superApply;

        return returnValue;
      };
    })();
  });
  constructor.prototype = $.widget.extend( basePrototype, {
    // TODO: remove support for widgetEventPrefix
    // always use the name + a colon as the prefix, e.g., draggable:start
    // don't prefix for widgets that aren't DOM-based
    widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
  }, proxiedPrototype, {
    constructor: constructor,
    namespace: namespace,
    widgetName: name,
    widgetFullName: fullName
  });

  // If this widget is being redefined then we need to find all widgets that
  // are inheriting from it and redefine all of them so that they inherit from
  // the new version of this widget. We're essentially trying to replace one
  // level in the prototype chain.
  if ( existingConstructor ) {
    $.each( existingConstructor._childConstructors, function( i, child ) {
      var childPrototype = child.prototype;

      // redefine the child widget using the same prototype that was
      // originally used, but inherit from the new version of the base
      $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
    });
    // remove the list of existing child constructors from the old constructor
    // so the old child constructors can be garbage collected
    delete existingConstructor._childConstructors;
  } else {
    base._childConstructors.push( constructor );
  }

  $.widget.bridge( name, constructor );

  return constructor;
};

$.widget.extend = function( target ) {
  var input = widget_slice.call( arguments, 1 ),
    inputIndex = 0,
    inputLength = input.length,
    key,
    value;
  for ( ; inputIndex < inputLength; inputIndex++ ) {
    for ( key in input[ inputIndex ] ) {
      value = input[ inputIndex ][ key ];
      if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
        // Clone objects
        if ( $.isPlainObject( value ) ) {
          target[ key ] = $.isPlainObject( target[ key ] ) ?
            $.widget.extend( {}, target[ key ], value ) :
            // Don't extend strings, arrays, etc. with objects
            $.widget.extend( {}, value );
        // Copy everything else by reference
        } else {
          target[ key ] = value;
        }
      }
    }
  }
  return target;
};

$.widget.bridge = function( name, object ) {
  var fullName = object.prototype.widgetFullName || name;
  $.fn[ name ] = function( options ) {
    var isMethodCall = typeof options === "string",
      args = widget_slice.call( arguments, 1 ),
      returnValue = this;

    // allow multiple hashes to be passed on init
    options = !isMethodCall && args.length ?
      $.widget.extend.apply( null, [ options ].concat(args) ) :
      options;

    if ( isMethodCall ) {
      this.each(function() {
        var methodValue,
          instance = $.data( this, fullName );
        if ( options === "instance" ) {
          returnValue = instance;
          return false;
        }
        if ( !instance ) {
          return $.error( "cannot call methods on " + name + " prior to initialization; " +
            "attempted to call method '" + options + "'" );
        }
        if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
          return $.error( "no such method '" + options + "' for " + name + " widget instance" );
        }
        methodValue = instance[ options ].apply( instance, args );
        if ( methodValue !== instance && methodValue !== undefined ) {
          returnValue = methodValue && methodValue.jquery ?
            returnValue.pushStack( methodValue.get() ) :
            methodValue;
          return false;
        }
      });
    } else {
      this.each(function() {
        var instance = $.data( this, fullName );
        if ( instance ) {
          instance.option( options || {} );
          if ( instance._init ) {
            instance._init();
          }
        } else {
          $.data( this, fullName, new object( options, this ) );
        }
      });
    }

    return returnValue;
  };
};

$.Widget = function( /* options, element */ ) {};
$.Widget._childConstructors = [];

$.Widget.prototype = {
  widgetName: "widget",
  widgetEventPrefix: "",
  defaultElement: "<div>",
  options: {
    disabled: false,

    // callbacks
    create: null
  },
  _createWidget: function( options, element ) {
    element = $( element || this.defaultElement || this )[ 0 ];
    this.element = $( element );
    this.uuid = widget_uuid++;
    this.eventNamespace = "." + this.widgetName + this.uuid;
    this.options = $.widget.extend( {},
      this.options,
      this._getCreateOptions(),
      options );

    this.bindings = $();
    this.hoverable = $();
    this.focusable = $();

    if ( element !== this ) {
      $.data( element, this.widgetFullName, this );
      this._on( true, this.element, {
        remove: function( event ) {
          if ( event.target === element ) {
            this.destroy();
          }
        }
      });
      this.document = $( element.style ?
        // element within the document
        element.ownerDocument :
        // element is window or document
        element.document || element );
      this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
    }

    this._create();
    this._trigger( "create", null, this._getCreateEventData() );
    this._init();
  },
  _getCreateOptions: $.noop,
  _getCreateEventData: $.noop,
  _create: $.noop,
  _init: $.noop,

  destroy: function() {
    this._destroy();
    // we can probably remove the unbind calls in 2.0
    // all event bindings should go through this._on()
    this.element
      .unbind( this.eventNamespace )
      .removeData( this.widgetFullName )
      // support: jquery <1.6.3
      // http://bugs.jquery.com/ticket/9413
      .removeData( $.camelCase( this.widgetFullName ) );
    this.widget()
      .unbind( this.eventNamespace )
      .removeAttr( "aria-disabled" )
      .removeClass(
        this.widgetFullName + "-disabled " +
        "ui-state-disabled" );

    // clean up events and states
    this.bindings.unbind( this.eventNamespace );
    this.hoverable.removeClass( "ui-state-hover" );
    this.focusable.removeClass( "ui-state-focus" );
  },
  _destroy: $.noop,

  widget: function() {
    return this.element;
  },

  option: function( key, value ) {
    var options = key,
      parts,
      curOption,
      i;

    if ( arguments.length === 0 ) {
      // don't return a reference to the internal hash
      return $.widget.extend( {}, this.options );
    }

    if ( typeof key === "string" ) {
      // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
      options = {};
      parts = key.split( "." );
      key = parts.shift();
      if ( parts.length ) {
        curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
        for ( i = 0; i < parts.length - 1; i++ ) {
          curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
          curOption = curOption[ parts[ i ] ];
        }
        key = parts.pop();
        if ( arguments.length === 1 ) {
          return curOption[ key ] === undefined ? null : curOption[ key ];
        }
        curOption[ key ] = value;
      } else {
        if ( arguments.length === 1 ) {
          return this.options[ key ] === undefined ? null : this.options[ key ];
        }
        options[ key ] = value;
      }
    }

    this._setOptions( options );

    return this;
  },
  _setOptions: function( options ) {
    var key;

    for ( key in options ) {
      this._setOption( key, options[ key ] );
    }

    return this;
  },
  _setOption: function( key, value ) {
    this.options[ key ] = value;

    if ( key === "disabled" ) {
      this.widget()
        .toggleClass( this.widgetFullName + "-disabled", !!value );

      // If the widget is becoming disabled, then nothing is interactive
      if ( value ) {
        this.hoverable.removeClass( "ui-state-hover" );
        this.focusable.removeClass( "ui-state-focus" );
      }
    }

    return this;
  },

  enable: function() {
    return this._setOptions({ disabled: false });
  },
  disable: function() {
    return this._setOptions({ disabled: true });
  },

  _on: function( suppressDisabledCheck, element, handlers ) {
    var delegateElement,
      instance = this;

    // no suppressDisabledCheck flag, shuffle arguments
    if ( typeof suppressDisabledCheck !== "boolean" ) {
      handlers = element;
      element = suppressDisabledCheck;
      suppressDisabledCheck = false;
    }

    // no element argument, shuffle and use this.element
    if ( !handlers ) {
      handlers = element;
      element = this.element;
      delegateElement = this.widget();
    } else {
      element = delegateElement = $( element );
      this.bindings = this.bindings.add( element );
    }

    $.each( handlers, function( event, handler ) {
      function handlerProxy() {
        // allow widgets to customize the disabled handling
        // - disabled as an array instead of boolean
        // - disabled class as method for disabling individual parts
        if ( !suppressDisabledCheck &&
            ( instance.options.disabled === true ||
              $( this ).hasClass( "ui-state-disabled" ) ) ) {
          return;
        }
        return ( typeof handler === "string" ? instance[ handler ] : handler )
          .apply( instance, arguments );
      }

      // copy the guid so direct unbinding works
      if ( typeof handler !== "string" ) {
        handlerProxy.guid = handler.guid =
          handler.guid || handlerProxy.guid || $.guid++;
      }

      var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
        eventName = match[1] + instance.eventNamespace,
        selector = match[2];
      if ( selector ) {
        delegateElement.delegate( selector, eventName, handlerProxy );
      } else {
        element.bind( eventName, handlerProxy );
      }
    });
  },

  _off: function( element, eventName ) {
    eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
    element.unbind( eventName ).undelegate( eventName );
  },

  _delay: function( handler, delay ) {
    function handlerProxy() {
      return ( typeof handler === "string" ? instance[ handler ] : handler )
        .apply( instance, arguments );
    }
    var instance = this;
    return setTimeout( handlerProxy, delay || 0 );
  },

  _hoverable: function( element ) {
    this.hoverable = this.hoverable.add( element );
    this._on( element, {
      mouseenter: function( event ) {
        $( event.currentTarget ).addClass( "ui-state-hover" );
      },
      mouseleave: function( event ) {
        $( event.currentTarget ).removeClass( "ui-state-hover" );
      }
    });
  },

  _focusable: function( element ) {
    this.focusable = this.focusable.add( element );
    this._on( element, {
      focusin: function( event ) {
        $( event.currentTarget ).addClass( "ui-state-focus" );
      },
      focusout: function( event ) {
        $( event.currentTarget ).removeClass( "ui-state-focus" );
      }
    });
  },

  _trigger: function( type, event, data ) {
    var prop, orig,
      callback = this.options[ type ];

    data = data || {};
    event = $.Event( event );
    event.type = ( type === this.widgetEventPrefix ?
      type :
      this.widgetEventPrefix + type ).toLowerCase();
    // the original event may come from any element
    // so we need to reset the target on the new event
    event.target = this.element[ 0 ];

    // copy original event properties over to the new event
    orig = event.originalEvent;
    if ( orig ) {
      for ( prop in orig ) {
        if ( !( prop in event ) ) {
          event[ prop ] = orig[ prop ];
        }
      }
    }

    this.element.trigger( event, data );
    return !( $.isFunction( callback ) &&
      callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
      event.isDefaultPrevented() );
  }
};

$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
  $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
    if ( typeof options === "string" ) {
      options = { effect: options };
    }
    var hasOptions,
      effectName = !options ?
        method :
        options === true || typeof options === "number" ?
          defaultEffect :
          options.effect || defaultEffect;
    options = options || {};
    if ( typeof options === "number" ) {
      options = { duration: options };
    }
    hasOptions = !$.isEmptyObject( options );
    options.complete = callback;
    if ( options.delay ) {
      element.delay( options.delay );
    }
    if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
      element[ method ]( options );
    } else if ( effectName !== method && element[ effectName ] ) {
      element[ effectName ]( options.duration, options.easing, callback );
    } else {
      element.queue(function( next ) {
        $( this )[ method ]();
        if ( callback ) {
          callback.call( element[ 0 ] );
        }
        next();
      });
    }
  };
});

var widget = $.widget;


/*!
 * jQuery UI Tabs 1.11.0
 * http://jqueryui.com
 *
 * Copyright 2014 jQuery Foundation and other contributors
 * Released under the MIT license.
 * http://jquery.org/license
 *
 * http://api.jqueryui.com/tabs/
 */


var tabs = $.widget( "ui.tabs", {
  version: "1.11.0",
  delay: 300,
  options: {
    active: null,
    collapsible: false,
    event: "click",
    heightStyle: "content",
    hide: null,
    show: null,

    // callbacks
    activate: null,
    beforeActivate: null,
    beforeLoad: null,
    load: null
  },

  _isLocal: (function() {
    var rhash = /#.*$/;

    return function( anchor ) {
      var anchorUrl, locationUrl;

      // support: IE7
      // IE7 doesn't normalize the href property when set via script (#9317)
      anchor = anchor.cloneNode( false );

      anchorUrl = anchor.href.replace( rhash, "" );
      locationUrl = location.href.replace( rhash, "" );

      // decoding may throw an error if the URL isn't UTF-8 (#9518)
      try {
        anchorUrl = decodeURIComponent( anchorUrl );
      } catch ( error ) {}
      try {
        locationUrl = decodeURIComponent( locationUrl );
      } catch ( error ) {}

      return anchor.hash.length > 1 && anchorUrl === locationUrl;
    };
  })(),

  _create: function() {
    var that = this,
      options = this.options;

    this.running = false;

    this.element
      .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
      .toggleClass( "ui-tabs-collapsible", options.collapsible )
      // Prevent users from focusing disabled tabs via click
      .delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
        if ( $( this ).is( ".ui-state-disabled" ) ) {
          event.preventDefault();
        }
      })
      // support: IE <9
      // Preventing the default action in mousedown doesn't prevent IE
      // from focusing the element, so if the anchor gets focused, blur.
      // We don't have to worry about focusing the previously focused
      // element since clicking on a non-focusable element should focus
      // the body anyway.
      .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
        if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
          this.blur();
        }
      });

    this._processTabs();
    options.active = this._initialActive();

    // Take disabling tabs via class attribute from HTML
    // into account and update option properly.
    if ( $.isArray( options.disabled ) ) {
      options.disabled = $.unique( options.disabled.concat(
        $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
          return that.tabs.index( li );
        })
      ) ).sort();
    }

    // check for length avoids error when initializing empty list
    if ( this.options.active !== false && this.anchors.length ) {
      this.active = this._findActive( options.active );
    } else {
      this.active = $();
    }

    this._refresh();

    if ( this.active.length ) {
      this.load( options.active );
    }
  },

  _initialActive: function() {
    var active = this.options.active,
      collapsible = this.options.collapsible,
      locationHash = location.hash.substring( 1 );

    if ( active === null ) {
      // check the fragment identifier in the URL
      if ( locationHash ) {
        this.tabs.each(function( i, tab ) {
          if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
            active = i;
            return false;
          }
        });
      }

      // check for a tab marked active via a class
      if ( active === null ) {
        active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
      }

      // no active tab, set to false
      if ( active === null || active === -1 ) {
        active = this.tabs.length ? 0 : false;
      }
    }

    // handle numbers: negative, out of range
    if ( active !== false ) {
      active = this.tabs.index( this.tabs.eq( active ) );
      if ( active === -1 ) {
        active = collapsible ? false : 0;
      }
    }

    // don't allow collapsible: false and active: false
    if ( !collapsible && active === false && this.anchors.length ) {
      active = 0;
    }

    return active;
  },

  _getCreateEventData: function() {
    return {
      tab: this.active,
      panel: !this.active.length ? $() : this._getPanelForTab( this.active )
    };
  },

  _tabKeydown: function( event ) {
    var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
      selectedIndex = this.tabs.index( focusedTab ),
      goingForward = true;

    if ( this._handlePageNav( event ) ) {
      return;
    }

    switch ( event.keyCode ) {
      case $.ui.keyCode.RIGHT:
      case $.ui.keyCode.DOWN:
        selectedIndex++;
        break;
      case $.ui.keyCode.UP:
      case $.ui.keyCode.LEFT:
        goingForward = false;
        selectedIndex--;
        break;
      case $.ui.keyCode.END:
        selectedIndex = this.anchors.length - 1;
        break;
      case $.ui.keyCode.HOME:
        selectedIndex = 0;
        break;
      case $.ui.keyCode.SPACE:
        // Activate only, no collapsing
        event.preventDefault();
        clearTimeout( this.activating );
        this._activate( selectedIndex );
        return;
      case $.ui.keyCode.ENTER:
        // Toggle (cancel delayed activation, allow collapsing)
        event.preventDefault();
        clearTimeout( this.activating );
        // Determine if we should collapse or activate
        this._activate( selectedIndex === this.options.active ? false : selectedIndex );
        return;
      default:
        return;
    }

    // Focus the appropriate tab, based on which key was pressed
    event.preventDefault();
    clearTimeout( this.activating );
    selectedIndex = this._focusNextTab( selectedIndex, goingForward );

    // Navigating with control key will prevent automatic activation
    if ( !event.ctrlKey ) {
      // Update aria-selected immediately so that AT think the tab is already selected.
      // Otherwise AT may confuse the user by stating that they need to activate the tab,
      // but the tab will already be activated by the time the announcement finishes.
      focusedTab.attr( "aria-selected", "false" );
      this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );

      this.activating = this._delay(function() {
        this.option( "active", selectedIndex );
      }, this.delay );
    }
  },

  _panelKeydown: function( event ) {
    if ( this._handlePageNav( event ) ) {
      return;
    }

    // Ctrl+up moves focus to the current tab
    if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
      event.preventDefault();
      this.active.focus();
    }
  },

  // Alt+page up/down moves focus to the previous/next tab (and activates)
  _handlePageNav: function( event ) {
    if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
      this._activate( this._focusNextTab( this.options.active - 1, false ) );
      return true;
    }
    if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
      this._activate( this._focusNextTab( this.options.active + 1, true ) );
      return true;
    }
  },

  _findNextTab: function( index, goingForward ) {
    var lastTabIndex = this.tabs.length - 1;

    function constrain() {
      if ( index > lastTabIndex ) {
        index = 0;
      }
      if ( index < 0 ) {
        index = lastTabIndex;
      }
      return index;
    }

    while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
      index = goingForward ? index + 1 : index - 1;
    }

    return index;
  },

  _focusNextTab: function( index, goingForward ) {
    index = this._findNextTab( index, goingForward );
    this.tabs.eq( index ).focus();
    return index;
  },

  _setOption: function( key, value ) {
    if ( key === "active" ) {
      // _activate() will handle invalid values and update this.options
      this._activate( value );
      return;
    }

    if ( key === "disabled" ) {
      // don't use the widget factory's disabled handling
      this._setupDisabled( value );
      return;
    }

    this._super( key, value);

    if ( key === "collapsible" ) {
      this.element.toggleClass( "ui-tabs-collapsible", value );
      // Setting collapsible: false while collapsed; open first panel
      if ( !value && this.options.active === false ) {
        this._activate( 0 );
      }
    }

    if ( key === "event" ) {
      this._setupEvents( value );
    }

    if ( key === "heightStyle" ) {
      this._setupHeightStyle( value );
    }
  },

  _sanitizeSelector: function( hash ) {
    return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
  },

  refresh: function() {
    var options = this.options,
      lis = this.tablist.children( ":has(a[href])" );

    // get disabled tabs from class attribute from HTML
    // this will get converted to a boolean if needed in _refresh()
    options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
      return lis.index( tab );
    });

    this._processTabs();

    // was collapsed or no tabs
    if ( options.active === false || !this.anchors.length ) {
      options.active = false;
      this.active = $();
    // was active, but active tab is gone
    } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
      // all remaining tabs are disabled
      if ( this.tabs.length === options.disabled.length ) {
        options.active = false;
        this.active = $();
      // activate previous tab
      } else {
        this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
      }
    // was active, active tab still exists
    } else {
      // make sure active index is correct
      options.active = this.tabs.index( this.active );
    }

    this._refresh();
  },

  _refresh: function() {
    this._setupDisabled( this.options.disabled );
    this._setupEvents( this.options.event );
    this._setupHeightStyle( this.options.heightStyle );

    this.tabs.not( this.active ).attr({
      "aria-selected": "false",
      "aria-expanded": "false",
      tabIndex: -1
    });
    this.panels.not( this._getPanelForTab( this.active ) )
      .hide()
      .attr({
        "aria-hidden": "true"
      });

    // Make sure one tab is in the tab order
    if ( !this.active.length ) {
      this.tabs.eq( 0 ).attr( "tabIndex", 0 );
    } else {
      this.active
        .addClass( "ui-tabs-active ui-state-active" )
        .attr({
          "aria-selected": "true",
          "aria-expanded": "true",
          tabIndex: 0
        });
      this._getPanelForTab( this.active )
        .show()
        .attr({
          "aria-hidden": "false"
        });
    }
  },

  _processTabs: function() {
    var that = this;

    this.tablist = this._getList()
      .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
      .attr( "role", "tablist" );

    this.tabs = this.tablist.find( "> li:has(a[href])" )
      .addClass( "ui-state-default ui-corner-top" )
      .attr({
        role: "tab",
        tabIndex: -1
      });

    this.anchors = this.tabs.map(function() {
        return $( "a", this )[ 0 ];
      })
      .addClass( "ui-tabs-anchor" )
      .attr({
        role: "presentation",
        tabIndex: -1
      });

    this.panels = $();

    this.anchors.each(function( i, anchor ) {
      var selector, panel, panelId,
        anchorId = $( anchor ).uniqueId().attr( "id" ),
        tab = $( anchor ).closest( "li" ),
        originalAriaControls = tab.attr( "aria-controls" );

      // inline tab
      if ( that._isLocal( anchor ) ) {
        selector = anchor.hash;
        panelId = selector.substring( 1 );
        panel = that.element.find( that._sanitizeSelector( selector ) );
      // remote tab
      } else {
        // If the tab doesn't already have aria-controls,
        // generate an id by using a throw-away element
        panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
        selector = "#" + panelId;
        panel = that.element.find( selector );
        if ( !panel.length ) {
          panel = that._createPanel( panelId );
          panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
        }
        panel.attr( "aria-live", "polite" );
      }

      if ( panel.length) {
        that.panels = that.panels.add( panel );
      }
      if ( originalAriaControls ) {
        tab.data( "ui-tabs-aria-controls", originalAriaControls );
      }
      tab.attr({
        "aria-controls": panelId,
        "aria-labelledby": anchorId
      });
      panel.attr( "aria-labelledby", anchorId );
    });

    this.panels
      .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
      .attr( "role", "tabpanel" );
  },

  // allow overriding how to find the list for rare usage scenarios (#7715)
  _getList: function() {
    return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
  },

  _createPanel: function( id ) {
    return $( "<div>" )
      .attr( "id", id )
      .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
      .data( "ui-tabs-destroy", true );
  },

  _setupDisabled: function( disabled ) {
    if ( $.isArray( disabled ) ) {
      if ( !disabled.length ) {
        disabled = false;
      } else if ( disabled.length === this.anchors.length ) {
        disabled = true;
      }
    }

    // disable tabs
    for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
      if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
        $( li )
          .addClass( "ui-state-disabled" )
          .attr( "aria-disabled", "true" );
      } else {
        $( li )
          .removeClass( "ui-state-disabled" )
          .removeAttr( "aria-disabled" );
      }
    }

    this.options.disabled = disabled;
  },

  _setupEvents: function( event ) {
    var events = {};
    if ( event ) {
      $.each( event.split(" "), function( index, eventName ) {
        events[ eventName ] = "_eventHandler";
      });
    }

    this._off( this.anchors.add( this.tabs ).add( this.panels ) );
    // Always prevent the default action, even when disabled
    this._on( true, this.anchors, {
      click: function( event ) {
        event.preventDefault();
      }
    });
    this._on( this.anchors, events );
    this._on( this.tabs, { keydown: "_tabKeydown" } );
    this._on( this.panels, { keydown: "_panelKeydown" } );

    this._focusable( this.tabs );
    this._hoverable( this.tabs );
  },

  _setupHeightStyle: function( heightStyle ) {
    var maxHeight,
      parent = this.element.parent();

    if ( heightStyle === "fill" ) {
      maxHeight = parent.height();
      maxHeight -= this.element.outerHeight() - this.element.height();

      this.element.siblings( ":visible" ).each(function() {
        var elem = $( this ),
          position = elem.css( "position" );

        if ( position === "absolute" || position === "fixed" ) {
          return;
        }
        maxHeight -= elem.outerHeight( true );
      });

      this.element.children().not( this.panels ).each(function() {
        maxHeight -= $( this ).outerHeight( true );
      });

      this.panels.each(function() {
        $( this ).height( Math.max( 0, maxHeight -
          $( this ).innerHeight() + $( this ).height() ) );
      })
      .css( "overflow", "auto" );
    } else if ( heightStyle === "auto" ) {
      maxHeight = 0;
      this.panels.each(function() {
        maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
      }).height( maxHeight );
    }
  },

  _eventHandler: function( event ) {
    var options = this.options,
      active = this.active,
      anchor = $( event.currentTarget ),
      tab = anchor.closest( "li" ),
      clickedIsActive = tab[ 0 ] === active[ 0 ],
      collapsing = clickedIsActive && options.collapsible,
      toShow = collapsing ? $() : this._getPanelForTab( tab ),
      toHide = !active.length ? $() : this._getPanelForTab( active ),
      eventData = {
        oldTab: active,
        oldPanel: toHide,
        newTab: collapsing ? $() : tab,
        newPanel: toShow
      };

    event.preventDefault();

    if ( tab.hasClass( "ui-state-disabled" ) ||
        // tab is already loading
        tab.hasClass( "ui-tabs-loading" ) ||
        // can't switch durning an animation
        this.running ||
        // click on active header, but not collapsible
        ( clickedIsActive && !options.collapsible ) ||
        // allow canceling activation
        ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
      return;
    }

    options.active = collapsing ? false : this.tabs.index( tab );

    this.active = clickedIsActive ? $() : tab;
    if ( this.xhr ) {
      this.xhr.abort();
    }

    if ( !toHide.length && !toShow.length ) {
      $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
    }

    if ( toShow.length ) {
      this.load( this.tabs.index( tab ), event );
    }
    this._toggle( event, eventData );
  },

  // handles show/hide for selecting tabs
  _toggle: function( event, eventData ) {
    var that = this,
      toShow = eventData.newPanel,
      toHide = eventData.oldPanel;

    this.running = true;

    function complete() {
      that.running = false;
      that._trigger( "activate", event, eventData );
    }

    function show() {
      eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );

      if ( toShow.length && that.options.show ) {
        that._show( toShow, that.options.show, complete );
      } else {
        toShow.show();
        complete();
      }
    }

    // start out by hiding, then showing, then completing
    if ( toHide.length && this.options.hide ) {
      this._hide( toHide, this.options.hide, function() {
        eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
        show();
      });
    } else {
      eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
      toHide.hide();
      show();
    }

    toHide.attr( "aria-hidden", "true" );
    eventData.oldTab.attr({
      "aria-selected": "false",
      "aria-expanded": "false"
    });
    // If we're switching tabs, remove the old tab from the tab order.
    // If we're opening from collapsed state, remove the previous tab from the tab order.
    // If we're collapsing, then keep the collapsing tab in the tab order.
    if ( toShow.length && toHide.length ) {
      eventData.oldTab.attr( "tabIndex", -1 );
    } else if ( toShow.length ) {
      this.tabs.filter(function() {
        return $( this ).attr( "tabIndex" ) === 0;
      })
      .attr( "tabIndex", -1 );
    }

    toShow.attr( "aria-hidden", "false" );
    eventData.newTab.attr({
      "aria-selected": "true",
      "aria-expanded": "true",
      tabIndex: 0
    });
  },

  _activate: function( index ) {
    var anchor,
      active = this._findActive( index );

    // trying to activate the already active panel
    if ( active[ 0 ] === this.active[ 0 ] ) {
      return;
    }

    // trying to collapse, simulate a click on the current active header
    if ( !active.length ) {
      active = this.active;
    }

    anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
    this._eventHandler({
      target: anchor,
      currentTarget: anchor,
      preventDefault: $.noop
    });
  },

  _findActive: function( index ) {
    return index === false ? $() : this.tabs.eq( index );
  },

  _getIndex: function( index ) {
    // meta-function to give users option to provide a href string instead of a numerical index.
    if ( typeof index === "string" ) {
      index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
    }

    return index;
  },

  _destroy: function() {
    if ( this.xhr ) {
      this.xhr.abort();
    }

    this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );

    this.tablist
      .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
      .removeAttr( "role" );

    this.anchors
      .removeClass( "ui-tabs-anchor" )
      .removeAttr( "role" )
      .removeAttr( "tabIndex" )
      .removeUniqueId();

    this.tabs.add( this.panels ).each(function() {
      if ( $.data( this, "ui-tabs-destroy" ) ) {
        $( this ).remove();
      } else {
        $( this )
          .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
            "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
          .removeAttr( "tabIndex" )
          .removeAttr( "aria-live" )
          .removeAttr( "aria-busy" )
          .removeAttr( "aria-selected" )
          .removeAttr( "aria-labelledby" )
          .removeAttr( "aria-hidden" )
          .removeAttr( "aria-expanded" )
          .removeAttr( "role" );
      }
    });

    this.tabs.each(function() {
      var li = $( this ),
        prev = li.data( "ui-tabs-aria-controls" );
      if ( prev ) {
        li
          .attr( "aria-controls", prev )
          .removeData( "ui-tabs-aria-controls" );
      } else {
        li.removeAttr( "aria-controls" );
      }
    });

    this.panels.show();

    if ( this.options.heightStyle !== "content" ) {
      this.panels.css( "height", "" );
    }
  },

  enable: function( index ) {
    var disabled = this.options.disabled;
    if ( disabled === false ) {
      return;
    }

    if ( index === undefined ) {
      disabled = false;
    } else {
      index = this._getIndex( index );
      if ( $.isArray( disabled ) ) {
        disabled = $.map( disabled, function( num ) {
          return num !== index ? num : null;
        });
      } else {
        disabled = $.map( this.tabs, function( li, num ) {
          return num !== index ? num : null;
        });
      }
    }
    this._setupDisabled( disabled );
  },

  disable: function( index ) {
    var disabled = this.options.disabled;
    if ( disabled === true ) {
      return;
    }

    if ( index === undefined ) {
      disabled = true;
    } else {
      index = this._getIndex( index );
      if ( $.inArray( index, disabled ) !== -1 ) {
        return;
      }
      if ( $.isArray( disabled ) ) {
        disabled = $.merge( [ index ], disabled ).sort();
      } else {
        disabled = [ index ];
      }
    }
    this._setupDisabled( disabled );
  },

  load: function( index, event ) {
    index = this._getIndex( index );
    var that = this,
      tab = this.tabs.eq( index ),
      anchor = tab.find( ".ui-tabs-anchor" ),
      panel = this._getPanelForTab( tab ),
      eventData = {
        tab: tab,
        panel: panel
      };

    // not remote
    if ( this._isLocal( anchor[ 0 ] ) ) {
      return;
    }

    this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );

    // support: jQuery <1.8
    // jQuery <1.8 returns false if the request is canceled in beforeSend,
    // but as of 1.8, $.ajax() always returns a jqXHR object.
    if ( this.xhr && this.xhr.statusText !== "canceled" ) {
      tab.addClass( "ui-tabs-loading" );
      panel.attr( "aria-busy", "true" );

      this.xhr
        .success(function( response ) {
          // support: jQuery <1.8
          // http://bugs.jquery.com/ticket/11778
          setTimeout(function() {
            panel.html( response );
            that._trigger( "load", event, eventData );
          }, 1 );
        })
        .complete(function( jqXHR, status ) {
          // support: jQuery <1.8
          // http://bugs.jquery.com/ticket/11778
          setTimeout(function() {
            if ( status === "abort" ) {
              that.panels.stop( false, true );
            }

            tab.removeClass( "ui-tabs-loading" );
            panel.removeAttr( "aria-busy" );

            if ( jqXHR === that.xhr ) {
              delete that.xhr;
            }
          }, 1 );
        });
    }
  },

  _ajaxSettings: function( anchor, event, eventData ) {
    var that = this;
    return {
      url: anchor.attr( "href" ),
      beforeSend: function( jqXHR, settings ) {
        return that._trigger( "beforeLoad", event,
          $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
      }
    };
  },

  _getPanelForTab: function( tab ) {
    var id = $( tab ).attr( "aria-controls" );
    return this.element.find( this._sanitizeSelector( "#" + id ) );
  }
});



}));