GazeTK

/*! jQuery UI - v1.11.4 - 2015-03-11

* http://jqueryui.com

* Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js

* Copyright 2015 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.4

 * http://jqueryui.com

 *

 * Copyright 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.4",

        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( includeHidden ) {

                var position = this.css( "position" ),

                        excludeStaticParent = position === "absolute",

                        overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,

                        scrollParent = this.parents().filter( function() {

                                var parent = $( this );

                                if ( excludeStaticParent && parent.css( "position" ) === "static" ) {

                                        return false;

                                }

                                return overflowRegex.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.4

 * http://jqueryui.com

 *

 * Copyright 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 ) {

                var events, elem, i;

                for ( i = 0; (elem = elems[i]) != null; i++ ) {

                        try {

                                // Only trigger remove when necessary to save time

                                events = $._data( elem, "events" );

                                if ( events && events.remove ) {

                                        $( 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;

                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 {

                        // Allow multiple hashes to be passed on init

                        if ( args.length ) {

                                options = $.widget.extend.apply( null, [ options ].concat(args) );

                        }

                        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.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.options = $.widget.extend( {},

                        this.options,

                        this._getCreateOptions(),

                        options );

                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 );

                // Clear the stack to avoid memory leaks (#10056)

                this.bindings = $( this.bindings.not( element ).get() );

                this.focusable = $( this.focusable.not( element ).get() );

                this.hoverable = $( this.hoverable.not( element ).get() );

        },

        _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 Mouse 1.11.4

 * http://jqueryui.com

 *

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * http://api.jqueryui.com/mouse/

 */

var mouseHandled = false;

$( document ).mouseup( function() {

        mouseHandled = false;

});

var mouse = $.widget("ui.mouse", {

        version: "1.11.4",

        options: {

                cancel: "input,textarea,button,select,option",

                distance: 1,

                delay: 0

        },

        _mouseInit: function() {

                var that = this;

                this.element

                        .bind("mousedown." + this.widgetName, function(event) {

                                return that._mouseDown(event);

                        })

                        .bind("click." + this.widgetName, function(event) {

                                if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {

                                        $.removeData(event.target, that.widgetName + ".preventClickEvent");

                                        event.stopImmediatePropagation();

                                        return false;

                                }

                        });

                this.started = false;

        },

        // TODO: make sure destroying one instance of mouse doesn't mess with

        // other instances of mouse

        _mouseDestroy: function() {

                this.element.unbind("." + this.widgetName);

                if ( this._mouseMoveDelegate ) {

                        this.document

                                .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)

                                .unbind("mouseup." + this.widgetName, this._mouseUpDelegate);

                }

        },

        _mouseDown: function(event) {

                // don't let more than one widget handle mouseStart

                if ( mouseHandled ) {

                        return;

                }

                this._mouseMoved = false;

                // we may have missed mouseup (out of window)

                (this._mouseStarted && this._mouseUp(event));

                this._mouseDownEvent = event;

                var that = this,

                        btnIsLeft = (event.which === 1),

                        // event.target.nodeName works around a bug in IE 8 with

                        // disabled inputs (#7620)

                        elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);

                if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {

                        return true;

                }

                this.mouseDelayMet = !this.options.delay;

                if (!this.mouseDelayMet) {

                        this._mouseDelayTimer = setTimeout(function() {

                                that.mouseDelayMet = true;

                        }, this.options.delay);

                }

                if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {

                        this._mouseStarted = (this._mouseStart(event) !== false);

                        if (!this._mouseStarted) {

                                event.preventDefault();

                                return true;

                        }

                }

                // Click event may never have fired (Gecko & Opera)

                if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {

                        $.removeData(event.target, this.widgetName + ".preventClickEvent");

                }

                // these delegates are required to keep context

                this._mouseMoveDelegate = function(event) {

                        return that._mouseMove(event);

                };

                this._mouseUpDelegate = function(event) {

                        return that._mouseUp(event);

                };

                this.document

                        .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )

                        .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );

                event.preventDefault();

                mouseHandled = true;

                return true;

        },

        _mouseMove: function(event) {

                // Only check for mouseups outside the document if you've moved inside the document

                // at least once. This prevents the firing of mouseup in the case of IE<9, which will

                // fire a mousemove event if content is placed under the cursor. See #7778

                // Support: IE <9

                if ( this._mouseMoved ) {

                        // IE mouseup check - mouseup happened when mouse was out of window

                        if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {

                                return this._mouseUp(event);

                        // Iframe mouseup check - mouseup occurred in another document

                        } else if ( !event.which ) {

                                return this._mouseUp( event );

                        }

                }

                if ( event.which || event.button ) {

                        this._mouseMoved = true;

                }

                if (this._mouseStarted) {

                        this._mouseDrag(event);

                        return event.preventDefault();

                }

                if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {

                        this._mouseStarted =

                                (this._mouseStart(this._mouseDownEvent, event) !== false);

                        (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));

                }

                return !this._mouseStarted;

        },

        _mouseUp: function(event) {

                this.document

                        .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )

                        .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );

                if (this._mouseStarted) {

                        this._mouseStarted = false;

                        if (event.target === this._mouseDownEvent.target) {

                                $.data(event.target, this.widgetName + ".preventClickEvent", true);

                        }

                        this._mouseStop(event);

                }

                mouseHandled = false;

                return false;

        },

        _mouseDistanceMet: function(event) {

                return (Math.max(

                                Math.abs(this._mouseDownEvent.pageX - event.pageX),

                                Math.abs(this._mouseDownEvent.pageY - event.pageY)

                        ) >= this.options.distance

                );

        },

        _mouseDelayMet: function(/* event */) {

                return this.mouseDelayMet;

        },

        // These are placeholder methods, to be overriden by extending plugin

        _mouseStart: function(/* event */) {},

        _mouseDrag: function(/* event */) {},

        _mouseStop: function(/* event */) {},

        _mouseCapture: function(/* event */) { return true; }

});

/*!

 * jQuery UI Position 1.11.4

 * http://jqueryui.com

 *

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * http://api.jqueryui.com/position/

 */

(function() {

$.ui = $.ui || {};

var cachedScrollbarWidth, supportsOffsetFractions,

        max = Math.max,

        abs = Math.abs,

        round = Math.round,

        rhorizontal = /left|center|right/,

        rvertical = /top|center|bottom/,

        roffset = /[\+\-]\d+(\.[\d]+)?%?/,

        rposition = /^\w+/,

        rpercent = /%$/,

        _position = $.fn.position;

function getOffsets( offsets, width, height ) {

        return [

                parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),

                parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )

        ];

}

function parseCss( element, property ) {

        return parseInt( $.css( element, property ), 10 ) || 0;

}

function getDimensions( elem ) {

        var raw = elem[0];

        if ( raw.nodeType === 9 ) {

                return {

                        width: elem.width(),

                        height: elem.height(),

                        offset: { top: 0, left: 0 }

                };

        }

        if ( $.isWindow( raw ) ) {

                return {

                        width: elem.width(),

                        height: elem.height(),

                        offset: { top: elem.scrollTop(), left: elem.scrollLeft() }

                };

        }

        if ( raw.preventDefault ) {

                return {

                        width: 0,

                        height: 0,

                        offset: { top: raw.pageY, left: raw.pageX }

                };

        }

        return {

                width: elem.outerWidth(),

                height: elem.outerHeight(),

                offset: elem.offset()

        };

}

$.position = {

        scrollbarWidth: function() {

                if ( cachedScrollbarWidth !== undefined ) {

                        return cachedScrollbarWidth;

                }

                var w1, w2,

                        div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),

                        innerDiv = div.children()[0];

                $( "body" ).append( div );

                w1 = innerDiv.offsetWidth;

                div.css( "overflow", "scroll" );

                w2 = innerDiv.offsetWidth;

                if ( w1 === w2 ) {

                        w2 = div[0].clientWidth;

                }

                div.remove();

                return (cachedScrollbarWidth = w1 - w2);

        },

        getScrollInfo: function( within ) {

                var overflowX = within.isWindow || within.isDocument ? "" :

                                within.element.css( "overflow-x" ),

                        overflowY = within.isWindow || within.isDocument ? "" :

                                within.element.css( "overflow-y" ),

                        hasOverflowX = overflowX === "scroll" ||

                                ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),

                        hasOverflowY = overflowY === "scroll" ||

                                ( overflowY === "auto" && within.height < within.element[0].scrollHeight );

                return {

                        width: hasOverflowY ? $.position.scrollbarWidth() : 0,

                        height: hasOverflowX ? $.position.scrollbarWidth() : 0

                };

        },

        getWithinInfo: function( element ) {

                var withinElement = $( element || window ),

                        isWindow = $.isWindow( withinElement[0] ),

                        isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;

                return {

                        element: withinElement,

                        isWindow: isWindow,

                        isDocument: isDocument,

                        offset: withinElement.offset() || { left: 0, top: 0 },

                        scrollLeft: withinElement.scrollLeft(),

                        scrollTop: withinElement.scrollTop(),

                        // support: jQuery 1.6.x

                        // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows

                        width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),

                        height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()

                };

        }

};

$.fn.position = function( options ) {

        if ( !options || !options.of ) {

                return _position.apply( this, arguments );

        }

        // make a copy, we don't want to modify arguments

        options = $.extend( {}, options );

        var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,

                target = $( options.of ),

                within = $.position.getWithinInfo( options.within ),

                scrollInfo = $.position.getScrollInfo( within ),

                collision = ( options.collision || "flip" ).split( " " ),

                offsets = {};

        dimensions = getDimensions( target );

        if ( target[0].preventDefault ) {

                // force left top to allow flipping

                options.at = "left top";

        }

        targetWidth = dimensions.width;

        targetHeight = dimensions.height;

        targetOffset = dimensions.offset;

        // clone to reuse original targetOffset later

        basePosition = $.extend( {}, targetOffset );

        // force my and at to have valid horizontal and vertical positions

        // if a value is missing or invalid, it will be converted to center

        $.each( [ "my", "at" ], function() {

                var pos = ( options[ this ] || "" ).split( " " ),

                        horizontalOffset,

                        verticalOffset;

                if ( pos.length === 1) {

                        pos = rhorizontal.test( pos[ 0 ] ) ?

                                pos.concat( [ "center" ] ) :

                                rvertical.test( pos[ 0 ] ) ?

                                        [ "center" ].concat( pos ) :

                                        [ "center", "center" ];

                }

                pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";

                pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";

                // calculate offsets

                horizontalOffset = roffset.exec( pos[ 0 ] );

                verticalOffset = roffset.exec( pos[ 1 ] );

                offsets[ this ] = [