text: /*!
   * jQuery UI Dialog 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/dialog/
   */
  (function (factory) {
      if (typeof define === "function" && define.amd) {
  
          // AMD. Register as an anonymous module.
          define([
              "jquery",
              "./core",
              "./widget",
              "./button",
              "./draggable",
              "./mouse",
              "./position",
              "./resizable"
          ], factory);
      } else {
  
          // Browser globals
          factory(jQuery);
      }
  }(function ($) {
  
      return $.widget("ui.dialog", {
          version: "1.11.4",
          options: {
              appendTo: "body",
              autoOpen: true,
              buttons: [],
              closeOnEscape: true,
              closeText: "Close",
              dialogClass: "",
              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");
              this.options.title = this.options.title || this.originalTitle;
  
              this._createWrapper();
  
              this.element
                  .show()
                  .removeAttr("title")
                  .addClass("ui-dialog-content ui-widget-content")
                  .appendTo(this.uiDialog);
  
              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()
                  .removeClass("ui-dialog-content ui-widget-content")
                  .css(this.originalCss)
                  // Without detaching first, the following becomes really slow
                  .detach();
  
              this.uiDialog.stop(true, true).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 activeElement,
                  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").focus().length) {
  
                  // support: IE9
                  // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
                  try {
                      activeElement = this.document[0].activeElement;
  
                      // Support: IE9, IE10
                      // If the <body> is blurred, IE will switch windows, see #4520
                      if (activeElement && activeElement.nodeName.toLowerCase() !== "body") {
  
                          // 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
                          $(activeElement).blur();
                      }
                  } catch (error) {
                  }
              }
  
              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 = $(this.document[0].activeElement);
  
              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 openening 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).focus();
          },
  
          _keepFocus: function (event) {
              function checkFocus() {
                  var activeElement = this.document[0].activeElement,
                      isActive = this.uiDialog[0] === activeElement ||
                          $.contains(this.uiDialog[0], activeElement);
                  if (!isActive) {
                      this._focusTabbable();
                  }
              }
  
              event.preventDefault();
              checkFocus.call(this);
              // support: IE
              // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
              // so we check again later
              this._delay(checkFocus);
          },
  
          _createWrapper: function () {
              this.uiDialog = $("<div>")
                  .addClass("ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
                      this.options.dialogClass)
                  .hide()
                  .attr({
                      // Setting tabIndex makes the div focusable
                      tabIndex: -1,
                      role: "dialog"
                  })
                  .appendTo(this._appendTo());
  
              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
                      if (event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented()) {
                          return;
                      }
                      var tabbables = this.uiDialog.find(":tabbable"),
                          first = tabbables.filter(":first"),
                          last = tabbables.filter(":last");
  
                      if (( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey) {
                          this._delay(function () {
                              first.focus();
                          });
                          event.preventDefault();
                      } else if (( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey) {
                          this._delay(function () {
                              last.focus();
                          });
                          event.preventDefault();
                      }
                  },
                  mousedown: function (event) {
                      if (this._moveToTop(event)) {
                          this._focusTabbable();
                      }
                  }
              });
  
              // We assume that any existing aria-describedby attribute means
              // that the dialog content is marked up properly
              // otherwise we brute force the content as the description
              if (!this.element.find("[aria-describedby]").length) {
                  this.uiDialog.attr({
                      "aria-describedby": this.element.uniqueId().attr("id")
                  });
              }
          },
  
          _createTitlebar: function () {
              var uiDialogTitle;
  
              this.uiDialogTitlebar = $("<div>")
                  .addClass("ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix")
                  .prependTo(this.uiDialog);
              this._on(this.uiDialogTitlebar, {
                  mousedown: function (event) {
                      // Don't prevent click on close button (#8838)
                      // Focusing a dialog that is partially scrolled out of view
                      // causes the browser to scroll it into view, preventing the click event
                      if (!$(event.target).closest(".ui-dialog-titlebar-close")) {
                          // Dialog isn't getting focus when dragging (#8063)
                          this.uiDialog.focus();
                      }
                  }
              });
  
              // support: IE
              // Use type="button" to prevent enter keypresses in textboxes from closing the
              // dialog in IE (#9312)
              this.uiDialogTitlebarClose = $("<button type='button'></button>")
                  .button({
                      label: this.options.closeText,
                      icons: {
                          primary: "ui-icon-closethick"
                      },
                      text: false
                  })
                  .addClass("ui-dialog-titlebar-close")
                  .appendTo(this.uiDialogTitlebar);
              this._on(this.uiDialogTitlebarClose, {
                  click: function (event) {
                      event.preventDefault();
                      this.close(event);
                  }
              });
  
              uiDialogTitle = $("<span>")
                  .uniqueId()
                  .addClass("ui-dialog-title")
                  .prependTo(this.uiDialogTitlebar);
              this._title(uiDialogTitle);
  
              this.uiDialog.attr({
                  "aria-labelledby": uiDialogTitle.attr("id")
              });
          },
  
          _title: function (title) {
              if (!this.options.title) {
                  title.html("&#160;");
              }
              title.text(this.options.title);
          },
  
          _createButtonPane: function () {
              this.uiDialogButtonPane = $("<div>")
                  .addClass("ui-dialog-buttonpane ui-widget-content ui-helper-clearfix");
  
              this.uiButtonSet = $("<div>")
                  .addClass("ui-dialog-buttonset")
                  .appendTo(this.uiDialogButtonPane);
  
              this._createButtons();
          },
  
          _createButtons: function () {
              var that = this,
                  buttons = this.options.buttons;
  
              // if we already have a button pane, remove it
              this.uiDialogButtonPane.remove();
              this.uiButtonSet.empty();
  
              if ($.isEmptyObject(buttons) || ($.isArray(buttons) && !buttons.length)) {
                  this.uiDialog.removeClass("ui-dialog-buttons");
                  return;
              }
  
              $.each(buttons, function (name, props) {
                  var click, buttonOptions;
                  props = $.isFunction(props) ?
                  {click: props, text: name} :
                      props;
                  // Default to a non-submitting button
                  props = $.extend({type: "button"}, props);
                  // Change the context for the click callback to be the main element
                  click = props.click;
                  props.click = function () {
                      click.apply(that.element[0], arguments);
                  };
                  buttonOptions = {
                      icons: props.icons,
                      text: props.showText
                  };
                  delete props.icons;
                  delete props.showText;
                  $("<button></button>", props)
                      .button(buttonOptions)
                      .appendTo(that.uiButtonSet);
              });
              this.uiDialog.addClass("ui-dialog-buttons");
              this.uiDialogButtonPane.appendTo(this.uiDialog);
          },
  
          _makeDraggable: function () {
              var that = this,
                  options = this.options;
  
              function filteredUi(ui) {
                  return {
                      position: ui.position,
                      offset: ui.offset
                  };
              }
  
              this.uiDialog.draggable({
                  cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
                  handle: ".ui-dialog-titlebar",
                  containment: "document",
                  start: function (event, ui) {
                      $(this).addClass("ui-dialog-dragging");
                      that._blockFrames();
                      that._trigger("dragStart", event, filteredUi(ui));
                  },
                  drag: function (event, ui) {
                      that._trigger("drag", event, filteredUi(ui));
                  },
                  stop: function (event, ui) {
                      var left = ui.offset.left - that.document.scrollLeft(),
                          top = ui.offset.top - that.document.scrollTop();
  
                      options.position = {
                          my: "left top",
                          at: "left" + (left >= 0 ? "+" : "") + left + " " +
                          "top" + (top >= 0 ? "+" : "") + top,
                          of: that.window
                      };
                      $(this).removeClass("ui-dialog-dragging");
                      that._unblockFrames();
                      that._trigger("dragStop", event, filteredUi(ui));
                  }
              });
          },
  
          _makeResizable: function () {
              var that = this,
                  options = this.options,
                  handles = options.resizable,
              // .ui-resizable has position: relative defined in the stylesheet
              // but dialogs have to use absolute or fixed positioning
                  position = this.uiDialog.css("position"),
                  resizeHandles = typeof handles === "string" ?
                      handles :
                      "n,e,s,w,se,sw,ne,nw";
  
              function filteredUi(ui) {
                  return {
                      originalPosition: ui.originalPosition,
                      originalSize: ui.originalSize,
                      position: ui.position,
                      size: ui.size
                  };
              }
  
              this.uiDialog.resizable({
                      cancel: ".ui-dialog-content",
                      containment: "document",
                      alsoResize: this.element,
                      maxWidth: options.maxWidth,
                      maxHeight: options.maxHeight,
                      minWidth: options.minWidth,
                      minHeight: this._minHeight(),
                      handles: resizeHandles,
                      start: function (event, ui) {
                          $(this).addClass("ui-dialog-resizing");
                          that._blockFrames();
                          that._trigger("resizeStart", event, filteredUi(ui));
                      },
                      resize: function (event, ui) {
                          that._trigger("resize", event, filteredUi(ui));
                      },
                      stop: function (event, ui) {
                          var offset = that.uiDialog.offset(),
                              left = offset.left - that.document.scrollLeft(),
                              top = offset.top - that.document.scrollTop();
  
                          options.height = that.uiDialog.height();
                          options.width = that.uiDialog.width();
                          options.position = {
                              my: "left top",
                              at: "left" + (left >= 0 ? "+" : "") + left + " " +
                              "top" + (top >= 0 ? "+" : "") + top,
                              of: that.window
                          };
                          $(this).removeClass("ui-dialog-resizing");
                          that._unblockFrames();
                          that._trigger("resizeStop", event, filteredUi(ui));
                      }
                  })
                  .css("position", position);
          },
  
          _trackFocus: function () {
              this._on(this.widget(), {
                  focusin: function (event) {
                      this._makeFocusTarget();
                      this._focusedElement = $(event.target);
                  }
              });
          },
  
          _makeFocusTarget: function () {
              this._untrackInstance();
              this._trackingInstances().unshift(this);
          },
  
          _untrackInstance: function () {
              var instances = this._trackingInstances(),
                  exists = $.inArray(this, instances);
              if (exists !== -1) {
                  instances.splice(exists, 1);
              }
          },
  
          _trackingInstances: function () {
              var instances = this.document.data("ui-dialog-instances");
              if (!instances) {
                  instances = [];
                  this.document.data("ui-dialog-instances", instances);
              }
              return instances;
          },
  
          _minHeight: function () {
              var options = this.options;
  
              return options.height === "auto" ?
                  options.minHeight :
                  Math.min(options.minHeight, options.height);
          },
  
          _position: function () {
              // Need to show the dialog to get the actual offset in the position plugin
              var isVisible = this.uiDialog.is(":visible");
              if (!isVisible) {
                  this.uiDialog.show();
              }
              this.uiDialog.position(this.options.position);
              if (!isVisible) {
                  this.uiDialog.hide();
              }
          },
  
          _setOptions: function (options) {
              var that = this,
                  resize = false,
                  resizableOptions = {};
  
              $.each(options, function (key, value) {
                  that._setOption(key, value);
  
                  if (key in that.sizeRelatedOptions) {
                      resize = true;
                  }
                  if (key in that.resizableRelatedOptions) {
                      resizableOptions[key] = value;
                  }
              });
  
              if (resize) {
                  this._size();
                  this._position();
              }
              if (this.uiDialog.is(":data(ui-resizable)")) {
                  this.uiDialog.resizable("option", resizableOptions);
              }
          },
  
          _setOption: function (key, value) {
              var isDraggable, isResizable,
                  uiDialog = this.uiDialog;
  
              if (key === "dialogClass") {
                  uiDialog
                      .removeClass(this.options.dialogClass)
                      .addClass(value);
              }
  
              if (key === "disabled") {
                  return;
              }
  
              this._super(key, value);
  
              if (key === "appendTo") {
                  this.uiDialog.appendTo(this._appendTo());
              }
  
              if (key === "buttons") {
                  this._createButtons();
              }
  
              if (key === "closeText") {
                  this.uiDialogTitlebarClose.button({
                      // Ensure that we always pass a string
                      label: "" + value
                  });
              }
  
              if (key === "draggable") {
                  isDraggable = uiDialog.is(":data(ui-draggable)");
                  if (isDraggable && !value) {
                      uiDialog.draggable("destroy");
                  }
  
                  if (!isDraggable && value) {
                      this._makeDraggable();
                  }
              }
  
              if (key === "position") {
                  this._position();
              }
  
              if (key === "resizable") {
                  // currently resizable, becoming non-resizable
                  isResizable = uiDialog.is(":data(ui-resizable)");
                  if (isResizable && !value) {
                      uiDialog.resizable("destroy");
                  }
  
                  // currently resizable, changing handles
                  if (isResizable && typeof value === "string") {
                      uiDialog.resizable("option", "handles", value);
                  }
  
                  // currently non-resizable, becoming resizable
                  if (!isResizable && value !== false) {
                      this._makeResizable();
                  }
              }
  
              if (key === "title") {
                  this._title(this.uiDialogTitlebar.find(".ui-dialog-title"));
              }
          },
  
          _size: function () {
              // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
              // divs will both have width and height set, so we need to reset them
              var nonContentHeight, minContentHeight, maxContentHeight,
                  options = this.options;
  
              // Reset content sizing
              this.element.show().css({
                  width: "auto",
                  minHeight: 0,
                  maxHeight: "none",
                  height: 0
              });
  
              if (options.minWidth > options.width) {
                  options.width = options.minWidth;
              }
  
              // reset wrapper sizing
              // determine the height of all the non-content elements
              nonContentHeight = this.uiDialog.css({
                      height: "auto",
                      width: options.width
                  })
                  .outerHeight();
              minContentHeight = Math.max(0, options.minHeight - nonContentHeight);
              maxContentHeight = typeof options.maxHeight === "number" ?
                  Math.max(0, options.maxHeight - nonContentHeight) :
                  "none";
  
              if (options.height === "auto") {
                  this.element.css({
                      minHeight: minContentHeight,
                      maxHeight: maxContentHeight,
                      height: "auto"
                  });
              } else {
                  this.element.height(Math.max(0, options.height - nonContentHeight));
              }
  
              if (this.uiDialog.is(":data(ui-resizable)")) {
                  this.uiDialog.resizable("option", "minHeight", this._minHeight());
              }
          },
  
          _blockFrames: function () {
              this.iframeBlocks = this.document.find("iframe").map(function () {
                  var iframe = $(this);
  
                  return $("<div>")
                      .css({
                          position: "absolute",
                          width: iframe.outerWidth(),
                          height: iframe.outerHeight()
                      })
                      .appendTo(iframe.parent())
                      .offset(iframe.offset())[0];
              });
          },
  
          _unblockFrames: function () {
              if (this.iframeBlocks) {
                  this.iframeBlocks.remove();
                  delete this.iframeBlocks;
              }
          },
  
          _allowInteraction: function (event) {
              if ($(event.target).closest(".ui-dialog").length) {
                  return true;
              }
  
              // TODO: Remove hack when datepicker implements
              // the .ui-front logic (#8989)
              return !!$(event.target).closest(".ui-datepicker").length;
          },
  
          _createOverlay: function () {
              if (!this.options.modal) {
                  return;
              }
  
              // We use a delay in case the overlay is created from an
              // event that we're going to be cancelling (#2804)
              var isOpening = true;
              this._delay(function () {
                  isOpening = false;
              });
  
              if (!this.document.data("ui-dialog-overlays")) {
  
                  // Prevent use of anchors and inputs
                  // Using _on() for an event handler shared across many instances is
                  // safe because the dialogs stack and must be closed in reverse order
                  this._on(this.document, {
                      focusin: function (event) {
                          if (isOpening) {
                              return;
                          }
  
                          if (!this._allowInteraction(event)) {
                              event.preventDefault();
                              this._trackingInstances()[0]._focusTabbable();
                          }
                      }
                  });
              }
  
              this.overlay = $("<div>")
                  .addClass("ui-widget-overlay ui-front")
                  .appendTo(this._appendTo());
              this._on(this.overlay, {
                  mousedown: "_keepFocus"
              });
              this.document.data("ui-dialog-overlays",
                  (this.document.data("ui-dialog-overlays") || 0) + 1);
          },
  
          _destroyOverlay: function () {
              if (!this.options.modal) {
                  return;
              }
  
              if (this.overlay) {
                  var overlays = this.document.data("ui-dialog-overlays") - 1;
  
                  if (!overlays) {
                      this.document
                          .unbind("focusin")
                          .removeData("ui-dialog-overlays");
                  } else {
                      this.document.data("ui-dialog-overlays", overlays);
                  }
  
                  this.overlay.remove();
                  this.overlay = null;
              }
          }
      });
  
  }));
  