/*!

 * jQuery UI Dialog 1.13.3

 * https://jqueryui.com

 *

 * Copyright OpenJS Foundation and other contributors

 * Released under the MIT license.

 * https://jquery.org/license

 */

//>>label: Dialog

//>>group: Widgets

//>>description: Displays customizable dialog windows.

//>>docs: https://api.jqueryui.com/dialog/

//>>demos: https://jqueryui.com/dialog/

//>>css.structure: ../../themes/base/core.css

//>>css.structure: ../../themes/base/dialog.css

//>>css.theme: ../../themes/base/theme.css

( function( factory ) {

	"use strict";

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

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./button",

			"./draggable",

			"./mouse",

			"./resizable",

			"../focusable",

			"../keycode",

			"../position",

			"../safe-active-element",

			"../safe-blur",

			"../tabbable",

			"../unique-id",

			"../version",

			"../widget"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

$.widget( "ui.dialog", {

	version: "1.13.3",

	options: {

		appendTo: "body",

		autoOpen: true,

		buttons: [],

		classes: {

			"ui-dialog": "ui-corner-all",

			"ui-dialog-titlebar": "ui-corner-all"

		},

		closeOnEscape: true,

		closeText: "Close",

		draggable: true,

		hide: null,

		height: "auto",

		maxHeight: null,

		maxWidth: null,

		minHeight: 150,

		minWidth: 150,

		modal: false,

		position: {

			my: "center",

			at: "center",

			of: window,

			collision: "fit",

			// Ensure the titlebar is always visible

			using: function( pos ) {

				var topOffset = $( this ).css( pos ).offset().top;

				if ( topOffset < 0 ) {

					$( this ).css( "top", pos.top - topOffset );

				}

			}

		},

		resizable: true,

		show: null,

		title: null,

		width: 300,

		// Callbacks

		beforeClose: null,

		close: null,

		drag: null,

		dragStart: null,

		dragStop: null,

		focus: null,

		open: null,

		resize: null,

		resizeStart: null,

		resizeStop: null

	},

	sizeRelatedOptions: {

		buttons: true,

		height: true,

		maxHeight: true,

		maxWidth: true,

		minHeight: true,

		minWidth: true,

		width: true

	},

	resizableRelatedOptions: {

		maxHeight: true,

		maxWidth: true,

		minHeight: true,

		minWidth: true

	},

	_create: function() {

		this.originalCss = {

			display: this.element[ 0 ].style.display,

			width: this.element[ 0 ].style.width,

			minHeight: this.element[ 0 ].style.minHeight,

			maxHeight: this.element[ 0 ].style.maxHeight,

			height: this.element[ 0 ].style.height

		};

		this.originalPosition = {

			parent: this.element.parent(),

			index: this.element.parent().children().index( this.element )

		};

		this.originalTitle = this.element.attr( "title" );

		if ( this.options.title == null && this.originalTitle != null ) {

			this.options.title = this.originalTitle;

		}

		// Dialogs can't be disabled

		if ( this.options.disabled ) {

			this.options.disabled = false;

		}

		this._createWrapper();

		this.element

			.show()

			.removeAttr( "title" )

			.appendTo( this.uiDialog );

		this._addClass( "ui-dialog-content", "ui-widget-content" );

		this._createTitlebar();

		this._createButtonPane();

		if ( this.options.draggable && $.fn.draggable ) {

			this._makeDraggable();

		}

		if ( this.options.resizable && $.fn.resizable ) {

			this._makeResizable();

		}

		this._isOpen = false;

		this._trackFocus();

	},

	_init: function() {

		if ( this.options.autoOpen ) {

			this.open();

		}

	},

	_appendTo: function() {

		var element = this.options.appendTo;

		if ( element && ( element.jquery || element.nodeType ) ) {

			return $( element );

		}

		return this.document.find( element || "body" ).eq( 0 );

	},

	_destroy: function() {

		var next,

			originalPosition = this.originalPosition;

		this._untrackInstance();

		this._destroyOverlay();

		this.element

			.removeUniqueId()

			.css( this.originalCss )

			// Without detaching first, the following becomes really slow

			.detach();

		this.uiDialog.remove();

		if ( this.originalTitle ) {

			this.element.attr( "title", this.originalTitle );

		}

		next = originalPosition.parent.children().eq( originalPosition.index );

		// Don't try to place the dialog next to itself (#8613)

		if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {

			next.before( this.element );

		} else {

			originalPosition.parent.append( this.element );

		}

	},

	widget: function() {

		return this.uiDialog;

	},

	disable: $.noop,

	enable: $.noop,

	close: function( event ) {

		var that = this;

		if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {

			return;

		}

		this._isOpen = false;

		this._focusedElement = null;

		this._destroyOverlay();

		this._untrackInstance();

		if ( !this.opener.filter( ":focusable" ).trigger( "focus" ).length ) {

			// Hiding a focused element doesn't trigger blur in WebKit

			// so in case we have nothing to focus on, explicitly blur the active element

			// https://bugs.webkit.org/show_bug.cgi?id=47182

			$.ui.safeBlur( $.ui.safeActiveElement( this.document[ 0 ] ) );

		}

		this._hide( this.uiDialog, this.options.hide, function() {

			that._trigger( "close", event );

		} );

	},

	isOpen: function() {

		return this._isOpen;

	},

	moveToTop: function() {

		this._moveToTop();

	},

	_moveToTop: function( event, silent ) {

		var moved = false,

			zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map( function() {

				return +$( this ).css( "z-index" );

			} ).get(),

			zIndexMax = Math.max.apply( null, zIndices );

		if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {

			this.uiDialog.css( "z-index", zIndexMax + 1 );

			moved = true;

		}

		if ( moved && !silent ) {

			this._trigger( "focus", event );

		}

		return moved;

	},

	open: function() {

		var that = this;

		if ( this._isOpen ) {

			if ( this._moveToTop() ) {

				this._focusTabbable();

			}

			return;

		}

		this._isOpen = true;

		this.opener = $( $.ui.safeActiveElement( this.document[ 0 ] ) );

		this._size();

		this._position();

		this._createOverlay();

		this._moveToTop( null, true );

		// Ensure the overlay is moved to the top with the dialog, but only when

		// opening. The overlay shouldn't move after the dialog is open so that

		// modeless dialogs opened after the modal dialog stack properly.

		if ( this.overlay ) {

			this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );

		}

		this._show( this.uiDialog, this.options.show, function() {

			that._focusTabbable();

			that._trigger( "focus" );

		} );

		// Track the dialog immediately upon opening in case a focus event

		// somehow occurs outside of the dialog before an element inside the

		// dialog is focused (#10152)

		this._makeFocusTarget();

		this._trigger( "open" );

	},

	_focusTabbable: function() {

		// Set focus to the first match:

		// 1. An element that was focused previously

		// 2. First element inside the dialog matching [autofocus]

		// 3. Tabbable element inside the content element

		// 4. Tabbable element inside the buttonpane

		// 5. The close button

		// 6. The dialog itself

		var hasFocus = this._focusedElement;

		if ( !hasFocus ) {

			hasFocus = this.element.find( "[autofocus]" );

		}

		if ( !hasFocus.length ) {

			hasFocus = this.element.find( ":tabbable" );

		}

		if ( !hasFocus.length ) {

			hasFocus = this.uiDialogButtonPane.find( ":tabbable" );

		}

		if ( !hasFocus.length ) {

			hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );

		}

		if ( !hasFocus.length ) {

			hasFocus = this.uiDialog;

		}

		hasFocus.eq( 0 ).trigger( "focus" );

	},

	_restoreTabbableFocus: function() {

		var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),

			isActive = this.uiDialog[ 0 ] === activeElement ||

				$.contains( this.uiDialog[ 0 ], activeElement );

		if ( !isActive ) {

			this._focusTabbable();

		}

	},

	_keepFocus: function( event ) {

		event.preventDefault();

		this._restoreTabbableFocus();

		// support: IE

		// IE <= 8 doesn't prevent moving focus even with event.preventDefault()

		// so we check again later

		this._delay( this._restoreTabbableFocus );

	},

	_createWrapper: function() {

		this.uiDialog = $( "<div>" )

			.hide()

			.attr( {

				// Setting tabIndex makes the div focusable

				tabIndex: -1,

				role: "dialog"

			} )

			.appendTo( this._appendTo() );

		this._addClass( this.uiDialog, "ui-dialog", "ui-widget ui-widget-content ui-front" );

		this._on( this.uiDialog, {

			keydown: function( event ) {

				if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&

						event.keyCode === $.ui.keyCode.ESCAPE ) {

					event.preventDefault();

					this.close( event );

					return;

				}

				// Prevent tabbing out of dialogs