Changeset 62747

trunk/src/js/_enqueues/vendor/jquery/ui/accordion.js

-              r58218
+              r62747
 /*!
  * jQuery UI Accordion 1.13.3
+ * jQuery UI Accordion 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>label: Accordion
 //>>group: Widgets
-/* eslint-disable max-len */
 //>>description: Displays collapsible content panels for presenting information in a limited amount of space.
-/* eslint-enable max-len */
 //>>docs: https://api.jqueryui.com/accordion/
 //>>demos: https://jqueryui.com/accordion/
 …
 return $.widget( "ui.accordion", {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 active: 0,
 …
                 event: "click",
                 header: function( elem ) {
+                        return elem.find( "> li > :first-child" ).add( elem.find( "> :not(li)" ).even() );
+                        return elem
+                                .find( "> li > :first-child" )
+                                .add(
+                                        elem.find( "> :not(li)" )
+                                                // Support: jQuery <3.5 only
+                                                // We could use `.even()` but that's unavailable in older jQuery.
+                                                .filter( function( i ) {
+                                                        return i % 2 === 0;
+                                                } )
+                                );
                 },
                 heightStyle: "auto",
 …
                 this.element.attr( "aria-disabled", value );
-                // Support: IE8 Only
-                // #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
-                // so we need to add the disabled class to the headers and panels
                 this._toggleClass( null, "ui-state-disabled", !!value );
-                this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
-                        !!value );
         },
 …
                         ._addClass( prev, "ui-accordion-header-collapsed" );
-                // Work around for rendering bug in IE (#5421)
-                if ( toHide.length ) {
-                        toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
+                }
                 this._trigger( "activate", null, data );
+        }

trunk/src/js/_enqueues/vendor/jquery/ui/autocomplete.js

-              r58218
+              r62747
 /*!
  * jQuery UI Autocomplete 1.13.3
+ * jQuery UI Autocomplete 1.14.2
  * https://jqueryui.com
+ *
 …
                         "../keycode",
                         "../position",
-                        "../safe-active-element",
                         "../version",
                         "../widget"
 …
 $.widget( "ui.autocomplete", {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<input>",
         options: {
 …
                 // Textareas are always multi-line
                 // Inputs are always single-line, even if inside a contentEditable element
                 // IE also treats inputs as contentEditable
                 // All other element types are determined by whether or not they're contentEditable
                 this.isMultiLine = isTextarea || !isInput && this._isContentEditable( this.element );
+                // All other element types are determined by whether they're contentEditable
+                this.isMultiLine = isTextarea ||
+                        !isInput && this.element.prop( "contentEditable" ) === "true";
                 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
 …
                                                 // Different browsers have different default behavior for escape
                                                 // Single press can mean undo or clear
-                                                // Double press in IE means clear the whole form
                                                 event.preventDefault();
+                                        }
 …
                         } )
                         .hide()
-                        // Support: IE 11 only, Edge <= 14
-                        // For other browsers, we preventDefault() on the mousedown event
-                        // to keep the dropdown from taking focus from the input. This doesn't
-                        // work for IE/Edge, causing problems with selection and scrolling (#9638)
-                        // Happily, IE and Edge support an "unselectable" attribute that
-                        // prevents an element from receiving focus, exactly what we want here.
-                        .attr( {
-                                "unselectable": "on"
-                        } )
                         .menu( "instance" );
 …
                                 var label, item;
                                 // support: Firefox
+                                // Support: Firefox
                                 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
                                 if ( this.isNewMenu ) {
 …
                                 // Only trigger when focus was lost (click on menu)
                                 if ( this.element[ 0 ] !== $.ui.safeActiveElement( this.document[ 0 ] ) ) {
+                                if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
                                         this.element.trigger( "focus" );
                                         this.previous = previous;
-                                        // #6109 - IE triggers two focus events and the second
-                                        // is asynchronous, so we need to reset the previous
-                                        // term synchronously and asynchronously :-(
-                                        this._delay( function() {
-                                                this.previous = previous;
-                                                this.selectedItem = item;
-                                        } );
+                                }
 …
                         event.preventDefault();
+                }
-        },
-        // Support: Chrome <=50
-        // We should be able to just use this.element.prop( "isContentEditable" )
-        // but hidden elements always report false in Chrome.
-        // https://code.google.com/p/chromium/issues/detail?id=313082
-        _isContentEditable: function( element ) {
-                if ( !element.length ) {
-                        return false;
+                }
-                var editable = element.prop( "contentEditable" );
-                if ( editable === "inherit" ) {
-                        return this._isContentEditable( element.parent() );
+                }
-                return editable === "true";
+        }
 } );

trunk/src/js/_enqueues/vendor/jquery/ui/button.js

-              r58218
+              r62747
 /*!
  * jQuery UI Button 1.13.3
+ * jQuery UI Button 1.14.2
  * https://jqueryui.com
+ *
 …
 $.widget( "ui.button", {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<button>",
         options: {
 …
                                                 event.preventDefault();
                                                 // Support: PhantomJS <= 1.9, IE 8 Only
                                                 // If a native click is available use it so we actually cause navigation
                                                 // otherwise just trigger a click event
+                                                // If a native click is available use it, so we
+                                                // actually cause navigation. Otherwise, just trigger
+                                                // a click event.
                                                 if ( this.element[ 0 ].click ) {
                                                         this.element[ 0 ].click();
 …
 // DEPRECATED
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Text and Icons options

trunk/src/js/_enqueues/vendor/jquery/ui/checkboxradio.js

-              r58218
+              r62747
 /*!
  * jQuery UI Checkboxradio 1.13.3
+ * jQuery UI Checkboxradio 1.14.2
  * https://jqueryui.com
+ *
 …
 $.widget( "ui.checkboxradio", [ $.ui.formResetMixin, {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 disabled: null,
 …
                 var group;
                 var name = this.element[ 0 ].name;
                 var nameSelector = "input[name='" + $.escapeSelector( name ) + "']";
+                var nameSelector = "input[name='" + CSS.escape( name ) + "']";
                 if ( !name ) {
 …
                         // Not inside a form, check all inputs that also are not inside a form
                         group = $( nameSelector ).filter( function() {
                                 return $( this )._form().length === 0;
+                                return $( $( this ).prop( "form" ) ).length === 0;
                         } );
+                }

trunk/src/js/_enqueues/vendor/jquery/ui/controlgroup.js

-              r58218
+              r62747
 /*!
  * jQuery UI Controlgroup 1.13.3
+ * jQuery UI Controlgroup 1.14.2
  * https://jqueryui.com
+ *
 …
 return $.widget( "ui.controlgroup", {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<div>",
         options: {

trunk/src/js/_enqueues/vendor/jquery/ui/core.js

-              r58218
+              r62747
 /*! jQuery UI - v1.13.3 - 2024-04-26
+/*! jQuery UI - v1.14.2 - 2026-07-15
 * https://jqueryui.com
+* Includes: widget.js, position.js, data.js, disable-selection.js, effect.js, effects/effect-blind.js, effects/effect-bounce.js, effects/effect-clip.js, effects/effect-drop.js, effects/effect-explode.js, effects/effect-fade.js, effects/effect-fold.js, effects/effect-highlight.js, effects/effect-puff.js, effects/effect-pulsate.js, effects/effect-scale.js, effects/effect-shake.js, effects/effect-size.js, effects/effect-slide.js, effects/effect-transfer.js, focusable.js, form-reset-mixin.js, jquery-patch.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js, widgets/accordion.js, widgets/autocomplete.js, widgets/button.js, widgets/checkboxradio.js, widgets/controlgroup.js, widgets/datepicker.js, widgets/dialog.js, widgets/draggable.js, widgets/droppable.js, widgets/menu.js, widgets/mouse.js, widgets/progressbar.js, widgets/resizable.js, widgets/selectable.js, widgets/selectmenu.js, widgets/slider.js, widgets/sortable.js, widgets/spinner.js, widgets/tabs.js, widgets/tooltip.js
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
+* Includes: widget.js, position.js, data.js, disable-selection.js, focusable.js, form-reset-mixin.js, jquery-patch.js, keycode.js, labels.js, scroll-parent.js, tabbable.js, unique-id.js
+* Copyright OpenJS Foundation and other contributors; Licensed MIT */
 ( function( factory ) {
         "use strict";
 …
                 factory( jQuery );
+        }
 } ( function( $ ) {
+} )( function( $ ) {
 "use strict";
-// Source: version.js
 $.ui = $.ui || {};
 $.ui.version = "1.13.3";
+// Source: data.js
+var version = $.ui.version = "1.14.2";
 /*!
  * jQuery UI :data 1.13.3
+ * jQuery UI Widget 1.14.2
  * https://jqueryui.com
+ *
 …
  */
 //>>label: :data Selector
+//>>label: Widget
 //>>group: Core
+//>>description: Selects elements which have data stored under the specified key.
+//>>docs: https://api.jqueryui.com/data-selector/
+$.extend( $.expr.pseudos, {
+        data: $.expr.createPseudo ?
+                $.expr.createPseudo( function( dataName ) {
+                        return function( elem ) {
+                                return !!$.data( elem, dataName );
+//>>description: Provides a factory for creating stateful widgets with a common API.
+//>>docs: https://api.jqueryui.com/jQuery.widget/
+//>>demos: https://jqueryui.com/widget/
+var widgetUuid = 0;
+var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
+var widgetSlice = Array.prototype.slice;
+$.cleanData = ( function( orig ) {
+        return function( elems ) {
+                var events, elem, i;
+                for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
+                        // Only trigger remove when necessary to save time
+                        events = $._data( elem, "events" );
+                        if ( events && events.remove ) {
+                                $( elem ).triggerHandler( "remove" );
+                        }
+                }
+                orig( elems );
+        };
+} )( $.cleanData );
+$.widget = function( name, base, prototype ) {
+        var existingConstructor, constructor, basePrototype;
+        // ProxiedPrototype allows the provided prototype to remain unmodified
+        // so that it can be used as a mixin for multiple widgets (#8876)
+        var proxiedPrototype = {};
+        var namespace = name.split( "." )[ 0 ];
+        name = name.split( "." )[ 1 ];
+        if ( name === "__proto__" || name === "constructor" ) {
+                return $.error( "Invalid widget name: " + name );
+        }
+        var fullName = namespace + "-" + name;
+        if ( !prototype ) {
+                prototype = base;
+                base = $.Widget;
+        }
+        if ( Array.isArray( prototype ) ) {
+                prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
+        }
+        // Create selector for plugin
+        $.expr.pseudos[ 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 || !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 ( typeof value !== "function" ) {
+                        proxiedPrototype[ prop ] = value;
+                        return;
+                }
+                proxiedPrototype[ prop ] = ( function() {
+                        function _super() {
+                                return base.prototype[ prop ].apply( this, arguments );
+                        }
+                        function _superApply( args ) {
+                                return base.prototype[ prop ].apply( this, args );
+                        }
+                        return function() {
+                                var __super = this._super;
+                                var __superApply = this._superApply;
+                                var returnValue;
+                                this._super = _super;
+                                this._superApply = _superApply;
+                                returnValue = value.apply( this, arguments );
+                                this._super = __super;
+                                this._superApply = __superApply;
+                                return returnValue;
                         };
+                } ) :
+                // Support: jQuery <1.8
+                function( elem, i, match ) {
+                        return !!$.data( elem, match[ 3 ] );
+                }
+                } )();
+        } );
+        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 = widgetSlice.call( arguments, 1 );
+        var inputIndex = 0;
+        var inputLength = input.length;
+        var key;
+        var value;
+        for ( ; inputIndex < inputLength; inputIndex++ ) {
+                for ( key in input[ inputIndex ] ) {
+                        value = input[ inputIndex ][ key ];
+                        if ( widgetHasOwnProperty.call( input[ inputIndex ], 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";
+                var args = widgetSlice.call( arguments, 1 );
+                var returnValue = this;
+                if ( isMethodCall ) {
+                        // If this is an empty collection, we need to have the instance method
+                        // return undefined instead of the jQuery instance
+                        if ( !this.length && options === "instance" ) {
+                                returnValue = undefined;
+                        } else {
+                                this.each( function() {
+                                        var methodValue;
+                                        var 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 ( typeof instance[ options ] !== "function" ||
+                                                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: {
+                classes: {},
+                disabled: false,
+                // Callbacks
+                create: null
+        },
+        _createWidget: function( options, element ) {
+                element = $( element || this.defaultElement || this )[ 0 ];
+                this.element = $( element );
+                this.uuid = widgetUuid++;
+                this.eventNamespace = "." + this.widgetName + this.uuid;
+                this.bindings = $();
+                this.hoverable = $();
+                this.focusable = $();
+                this.classesElementLookup = {};
+                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();
+                if ( this.options.disabled ) {
+                        this._setOptionDisabled( this.options.disabled );
+                }
+                this._trigger( "create", null, this._getCreateEventData() );
+                this._init();
+        },
+        _getCreateOptions: function() {
+                return {};
+        },
+        _getCreateEventData: $.noop,
+        _create: $.noop,
+        _init: $.noop,
+        destroy: function() {
+                var that = this;
+                this._destroy();
+                $.each( this.classesElementLookup, function( key, value ) {
+                        that._removeClass( value, key );
+                } );
+                // We can probably remove the unbind calls in 2.0
+                // all event bindings should go through this._on()
+                this.element
+                        .off( this.eventNamespace )
+                        .removeData( this.widgetFullName );
+                this.widget()
+                        .off( this.eventNamespace )
+                        .removeAttr( "aria-disabled" );
+                // Clean up events and states
+                this.bindings.off( this.eventNamespace );
+        },
+        _destroy: $.noop,
+        widget: function() {
+                return this.element;
+        },
+        option: function( key, value ) {
+                var options = key;
+                var parts;
+                var curOption;
+                var 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 ) {
+                if ( key === "classes" ) {
+                        this._setOptionClasses( value );
+                }
+                this.options[ key ] = value;
+                if ( key === "disabled" ) {
+                        this._setOptionDisabled( value );
+                }
+                return this;
+        },
+        _setOptionClasses: function( value ) {
+                var classKey, elements, currentElements;
+                for ( classKey in value ) {
+                        currentElements = this.classesElementLookup[ classKey ];
+                        if ( value[ classKey ] === this.options.classes[ classKey ] ||
+                                        !currentElements ||
+                                        !currentElements.length ) {
+                                continue;
+                        }
+                        // We are doing this to create a new jQuery object because the _removeClass() call
+                        // on the next line is going to destroy the reference to the current elements being
+                        // tracked. We need to save a copy of this collection so that we can add the new classes
+                        // below.
+                        elements = $( currentElements.get() );
+                        this._removeClass( currentElements, classKey );
+                        // We don't use _addClass() here, because that uses this.options.classes
+                        // for generating the string of classes. We want to use the value passed in from
+                        // _setOption(), this is the new value of the classes option which was passed to
+                        // _setOption(). We pass this value directly to _classes().
+                        elements.addClass( this._classes( {
+                                element: elements,
+                                keys: classKey,
+                                classes: value,
+                                add: true
+                        } ) );
+                }
+        },
+        _setOptionDisabled: function( value ) {
+                this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
+                // If the widget is becoming disabled, then nothing is interactive
+                if ( value ) {
+                        this._removeClass( this.hoverable, null, "ui-state-hover" );
+                        this._removeClass( this.focusable, null, "ui-state-focus" );
+                }
+        },
+        enable: function() {
+                return this._setOptions( { disabled: false } );
+        },
+        disable: function() {
+                return this._setOptions( { disabled: true } );
+        },
+        _classes: function( options ) {
+                var full = [];
+                var that = this;
+                options = $.extend( {
+                        element: this.element,
+                        classes: this.options.classes || {}
+                }, options );
+                function bindRemoveEvent() {
+                        var nodesToBind = [];
+                        options.element.each( function( _, element ) {
+                                var isTracked = $.map( that.classesElementLookup, function( elements ) {
+                                        return elements;
+                                } )
+                                        .some( function( elements ) {
+                                                return elements.is( element );
+                                        } );
+                                if ( !isTracked ) {
+                                        nodesToBind.push( element );
+                                }
+                        } );
+                        that._on( $( nodesToBind ), {
+                                remove: "_untrackClassesElement"
+                        } );
+                }
+                function processClassString( classes, checkOption ) {
+                        var current, i;
+                        for ( i = 0; i < classes.length; i++ ) {
+                                current = that.classesElementLookup[ classes[ i ] ] || $();
+                                if ( options.add ) {
+                                        bindRemoveEvent();
+                                        current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
+                                } else {
+                                        current = $( current.not( options.element ).get() );
+                                }
+                                that.classesElementLookup[ classes[ i ] ] = current;
+                                full.push( classes[ i ] );
+                                if ( checkOption && options.classes[ classes[ i ] ] ) {
+                                        full.push( options.classes[ classes[ i ] ] );
+                                }
+                        }
+                }
+                if ( options.keys ) {
+                        processClassString( options.keys.match( /\S+/g ) || [], true );
+                }
+                if ( options.extra ) {
+                        processClassString( options.extra.match( /\S+/g ) || [] );
+                }
+                return full.join( " " );
+        },
+        _untrackClassesElement: function( event ) {
+                var that = this;
+                $.each( that.classesElementLookup, function( key, value ) {
+                        if ( $.inArray( event.target, value ) !== -1 ) {
+                                that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
+                        }
+                } );
+                this._off( $( event.target ) );
+        },
+        _removeClass: function( element, keys, extra ) {
+                return this._toggleClass( element, keys, extra, false );
+        },
+        _addClass: function( element, keys, extra ) {
+                return this._toggleClass( element, keys, extra, true );
+        },
+        _toggleClass: function( element, keys, extra, add ) {
+                add = ( typeof add === "boolean" ) ? add : extra;
+                var shift = ( typeof element === "string" || element === null ),
+                        options = {
+                                extra: shift ? keys : extra,
+                                keys: shift ? element : keys,
+                                element: shift ? this.element : element,
+                                add: add
+                        };
+                options.element.toggleClass( this._classes( options ), add );
+                return this;
+        },
+        _on: function( suppressDisabledCheck, element, handlers ) {
+                var delegateElement;
+                var 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*(.*)$/ );
+                        var eventName = match[ 1 ] + instance.eventNamespace;
+                        var selector = match[ 2 ];
+                        if ( selector ) {
+                                delegateElement.on( eventName, selector, handlerProxy );
+                        } else {
+                                element.on( eventName, handlerProxy );
+                        }
+                } );
+        },
+        _off: function( element, eventName ) {
+                eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
+                        this.eventNamespace;
+                element.off( 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 ) {
+                                this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
+                        },
+                        mouseleave: function( event ) {
+                                this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
+                        }
+                } );
+        },
+        _focusable: function( element ) {
+                this.focusable = this.focusable.add( element );
+                this._on( element, {
+                        focusin: function( event ) {
+                                this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
+                        },
+                        focusout: function( event ) {
+                                this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
+                        }
+                } );
+        },
+        _trigger: function( type, event, data ) {
+                var prop, orig;
+                var 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 !( typeof callback === "function" &&
+                        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;
+                var effectName = !options ?
+                        method :
+                        options === true || typeof options === "number" ?
+                                defaultEffect :
+                                options.effect || defaultEffect;
+                options = options || {};
+                if ( typeof options === "number" ) {
+                        options = { duration: options };
+                } else if ( options === true ) {
+                        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();
+                        } );
+                }
+        };
 } );
+// Source: disable-selection.js
+var widget = $.widget;
 /*!
+ * jQuery UI Disable Selection 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: disableSelection
+//>>group: Core
+//>>description: Disable selection of text content within the set of matched elements.
+//>>docs: https://api.jqueryui.com/disableSelection/
+// This file is deprecated
+$.fn.extend( {
+        disableSelection: ( function() {
+                var eventType = "onselectstart" in document.createElement( "div" ) ?
+                        "selectstart" :
+                        "mousedown";
+                return function() {
+                        return this.on( eventType + ".ui-disableSelection", function( event ) {
+                                event.preventDefault();
+                        } );
+                };
+        } )(),
+        enableSelection: function() {
+                return this.off( ".ui-disableSelection" );
+        }
+} );
+// Source: focusable.js
+/*!
+ * jQuery UI Focusable 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: :focusable Selector
+//>>group: Core
+//>>description: Selects elements which can be focused.
+//>>docs: https://api.jqueryui.com/focusable-selector/
+// Selectors
+$.ui.focusable = function( element, hasTabindex ) {
+        var map, mapName, img, focusableIfVisible, fieldset,
+                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 + "']" );
+                return img.length > 0 && img.is( ":visible" );
+        }
+        if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
+                focusableIfVisible = !element.disabled;
+                if ( focusableIfVisible ) {
+                        // Form controls within a disabled fieldset are disabled.
+                        // However, controls within the fieldset's legend do not get disabled.
+                        // Since controls generally aren't placed inside legends, we skip
+                        // this portion of the check.
+                        fieldset = $( element ).closest( "fieldset" )[ 0 ];
+                        if ( fieldset ) {
+                                focusableIfVisible = !fieldset.disabled;
+                        }
+                }
+        } else if ( "a" === nodeName ) {
+                focusableIfVisible = element.href || hasTabindex;
+        } else {
+                focusableIfVisible = hasTabindex;
+        }
+        return focusableIfVisible && $( element ).is( ":visible" ) && visible( $( element ) );
+};
+// Support: IE 8 only
+// IE 8 doesn't resolve inherit to visible/hidden for computed values
+function visible( element ) {
+        var visibility = element.css( "visibility" );
+        while ( visibility === "inherit" ) {
+                element = element.parent();
+                visibility = element.css( "visibility" );
+        }
+        return visibility === "visible";
+}
+$.extend( $.expr.pseudos, {
+        focusable: function( element ) {
+                return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
+        }
+} );
+// Support: IE8 Only
+// IE8 does not support the form attribute and when it is supplied. It overwrites the form prop
+// with a string, so we need to find the proper form.
+$.fn._form = function() {
+        return typeof this[ 0 ].form === "string" ? this.closest( "form" ) : $( this[ 0 ].form );
+};
+// Source: form-reset-mixin.js
+/*!
+ * jQuery UI Form Reset Mixin 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: Form Reset Mixin
+//>>group: Core
+//>>description: Refresh input widgets when their form is reset
+//>>docs: https://api.jqueryui.com/form-reset-mixin/
+$.ui.formResetMixin = {
+        _formResetHandler: function() {
+                var form = $( this );
+                // Wait for the form reset to actually happen before refreshing
+                setTimeout( function() {
+                        var instances = form.data( "ui-form-reset-instances" );
+                        $.each( instances, function() {
+                                this.refresh();
+                        } );
+                } );
+        },
+        _bindFormResetHandler: function() {
+                this.form = this.element._form();
+                if ( !this.form.length ) {
+                        return;
+                }
+                var instances = this.form.data( "ui-form-reset-instances" ) || [];
+                if ( !instances.length ) {
+                        // We don't use _on() here because we use a single event handler per form
+                        this.form.on( "reset.ui-form-reset", this._formResetHandler );
+                }
+                instances.push( this );
+                this.form.data( "ui-form-reset-instances", instances );
+        },
+        _unbindFormResetHandler: function() {
+                if ( !this.form.length ) {
+                        return;
+                }
+                var instances = this.form.data( "ui-form-reset-instances" );
+                instances.splice( $.inArray( this, instances ), 1 );
+                if ( instances.length ) {
+                        this.form.data( "ui-form-reset-instances", instances );
+                } else {
+                        this.form
+                                .removeData( "ui-form-reset-instances" )
+                                .off( "reset.ui-form-reset" );
+                }
+        }
+};
+// Source: ie.js
+// This file is deprecated
+$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
+// Source: jquery-patch.js
+/*!
+ * jQuery UI Support for jQuery core 1.8.x and newer 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ *
+ */
+//>>label: jQuery 1.8+ Support
+//>>group: Core
+//>>description: Support version 1.8.x and newer of jQuery core
+// Support: jQuery 1.9.x or older
+// $.expr[ ":" ] is deprecated.
+if ( !$.expr.pseudos ) {
+        $.expr.pseudos = $.expr[ ":" ];
+}
+// Support: jQuery 1.11.x or older
+// $.unique has been renamed to $.uniqueSort
+if ( !$.uniqueSort ) {
+        $.uniqueSort = $.unique;
+}
+// Support: jQuery 2.2.x or older.
+// This method has been defined in jQuery 3.0.0.
+// Code from https://github.com/jquery/jquery/blob/e539bac79e666bba95bba86d690b4e609dca2286/src/selector/escapeSelector.js
+if ( !$.escapeSelector ) {
+        // CSS string/identifier serialization
+        // https://drafts.csswg.org/cssom/#common-serializing-idioms
+        var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
+        var fcssescape = function( ch, asCodePoint ) {
+                if ( asCodePoint ) {
+                        // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+                        if ( ch === "\0" ) {
+                                return "\uFFFD";
+                        }
+                        // Control characters and (dependent upon position) numbers get escaped as code points
+                        return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+                }
+                // Other potentially-special ASCII characters get backslash-escaped
+                return "\\" + ch;
+        };
+        $.escapeSelector = function( sel ) {
+                return ( sel + "" ).replace( rcssescape, fcssescape );
+        };
+}
+// Support: jQuery 3.4.x or older
+// These methods have been defined in jQuery 3.5.0.
+if ( !$.fn.even || !$.fn.odd ) {
+        $.fn.extend( {
+                even: function() {
+                        return this.filter( function( i ) {
+                                return i % 2 === 0;
+                        } );
+                },
+                odd: function() {
+                        return this.filter( function( i ) {
+                                return i % 2 === 1;
+                        } );
+                }
+        } );
+}
+// Source: keycode.js
+/*!
+ * jQuery UI Keycode 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: Keycode
+//>>group: Core
+//>>description: Provide keycodes as keynames
+//>>docs: https://api.jqueryui.com/jQuery.ui.keyCode/
+$.ui.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
+};
+// Source: labels.js
+/*!
+ * jQuery UI Labels 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: labels
+//>>group: Core
+//>>description: Find all the labels associated with a given input
+//>>docs: https://api.jqueryui.com/labels/
+$.fn.labels = function() {
+        var ancestor, selector, id, labels, ancestors;
+        if ( !this.length ) {
+                return this.pushStack( [] );
+        }
+        // Check control.labels first
+        if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
+                return this.pushStack( this[ 0 ].labels );
+        }
+        // Support: IE <= 11, FF <= 37, Android <= 2.3 only
+        // Above browsers do not support control.labels. Everything below is to support them
+        // as well as document fragments. control.labels does not work on document fragments
+        labels = this.eq( 0 ).parents( "label" );
+        // Look for the label based on the id
+        id = this.attr( "id" );
+        if ( id ) {
+                // We don't search against the document in case the element
+                // is disconnected from the DOM
+                ancestor = this.eq( 0 ).parents().last();
+                // Get a full set of top level ancestors
+                ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
+                // Create a selector for the label based on the id
+                selector = "label[for='" + $.escapeSelector( id ) + "']";
+                labels = labels.add( ancestors.find( selector ).addBack( selector ) );
+        }
+        // Return whatever we have found for labels
+        return this.pushStack( labels );
+};
+// Source: plugin.js
+// $.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 );
+                        }
+                }
+        }
+};
+// Source: position.js
+/*!
+ * jQuery UI Position 1.13.3
+ * jQuery UI Position 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>docs: https://api.jqueryui.com/position/
 //>>demos: https://jqueryui.com/position/
 ( function() {
 …
 } )();
+// Source: safe-active-element.js
+$.ui.safeActiveElement = function( document ) {
+        var activeElement;
+        // Support: IE 9 only
+        // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
+        try {
+                activeElement = document.activeElement;
+        } catch ( error ) {
+                activeElement = document.body;
+        }
+        // Support: IE 9 - 11 only
+        // IE may return null instead of an element
+        // Interestingly, this only seems to occur when NOT in an iframe
+        if ( !activeElement ) {
+                activeElement = document.body;
+        }
+        // Support: IE 11 only
+        // IE11 returns a seemingly empty object in some cases when accessing
+        // document.activeElement from an <iframe>
+        if ( !activeElement.nodeName ) {
+                activeElement = document.body;
+        }
+        return activeElement;
+};
+// Source: safe-blur.js
+$.ui.safeBlur = function( element ) {
+        // Support: IE9 - 10 only
+        // If the <body> is blurred, IE will switch windows, see #9420
+        if ( element && element.nodeName.toLowerCase() !== "body" ) {
+                $( element ).trigger( "blur" );
+        }
+};
+// Source: scroll-parent.js
+var position = $.ui.position;
 /*!
  * jQuery UI Scroll Parent 1.13.3
+ * jQuery UI :data 1.14.2
  * https://jqueryui.com
+ *
 …
  */
+//>>label: :data Selector
+//>>group: Core
+//>>description: Selects elements which have data stored under the specified key.
+//>>docs: https://api.jqueryui.com/data-selector/
+var data = $.extend( $.expr.pseudos, {
+        data: $.expr.createPseudo( function( dataName ) {
+                return function( elem ) {
+                        return !!$.data( elem, dataName );
+                };
+        } )
+} );
+/*!
+ * jQuery UI Disable Selection 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: disableSelection
+//>>group: Core
+//>>description: Disable selection of text content within the set of matched elements.
+//>>docs: https://api.jqueryui.com/disableSelection/
+// This file is deprecated
+var disableSelection = $.fn.extend( {
+        disableSelection: ( function() {
+                var eventType = "onselectstart" in document.createElement( "div" ) ?
+                        "selectstart" :
+                        "mousedown";
+                return function() {
+                        return this.on( eventType + ".ui-disableSelection", function( event ) {
+                                event.preventDefault();
+                        } );
+                };
+        } )(),
+        enableSelection: function() {
+                return this.off( ".ui-disableSelection" );
+        }
+} );
+/*!
+ * jQuery UI Focusable 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: :focusable Selector
+//>>group: Core
+//>>description: Selects elements which can be focused.
+//>>docs: https://api.jqueryui.com/focusable-selector/
+// Selectors
+$.ui.focusable = function( element, hasTabindex ) {
+        var map, mapName, img, focusableIfVisible, fieldset,
+                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 + "']" );
+                return img.length > 0 && img.is( ":visible" );
+        }
+        if ( /^(input|select|textarea|button|object)$/.test( nodeName ) ) {
+                focusableIfVisible = !element.disabled;
+                if ( focusableIfVisible ) {
+                        // Form controls within a disabled fieldset are disabled.
+                        // However, controls within the fieldset's legend do not get disabled.
+                        // Since controls generally aren't placed inside legends, we skip
+                        // this portion of the check.
+                        fieldset = $( element ).closest( "fieldset" )[ 0 ];
+                        if ( fieldset ) {
+                                focusableIfVisible = !fieldset.disabled;
+                        }
+                }
+        } else if ( "a" === nodeName ) {
+                focusableIfVisible = element.href || hasTabindex;
+        } else {
+                focusableIfVisible = hasTabindex;
+        }
+        return focusableIfVisible && $( element ).is( ":visible" ) &&
+                $( element ).css( "visibility" ) === "visible";
+};
+$.extend( $.expr.pseudos, {
+        focusable: function( element ) {
+                return $.ui.focusable( element, $.attr( element, "tabindex" ) != null );
+        }
+} );
+var focusable = $.ui.focusable;
+/*!
+ * jQuery UI Form Reset Mixin 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: Form Reset Mixin
+//>>group: Core
+//>>description: Refresh input widgets when their form is reset
+//>>docs: https://api.jqueryui.com/form-reset-mixin/
+var formResetMixin = $.ui.formResetMixin = {
+        _formResetHandler: function() {
+                var form = $( this );
+                // Wait for the form reset to actually happen before refreshing
+                setTimeout( function() {
+                        var instances = form.data( "ui-form-reset-instances" );
+                        $.each( instances, function() {
+                                this.refresh();
+                        } );
+                } );
+        },
+        _bindFormResetHandler: function() {
+                this.form = $( this.element.prop( "form" ) );
+                if ( !this.form.length ) {
+                        return;
+                }
+                var instances = this.form.data( "ui-form-reset-instances" ) || [];
+                if ( !instances.length ) {
+                        // We don't use _on() here because we use a single event handler per form
+                        this.form.on( "reset.ui-form-reset", this._formResetHandler );
+                }
+                instances.push( this );
+                this.form.data( "ui-form-reset-instances", instances );
+        },
+        _unbindFormResetHandler: function() {
+                if ( !this.form.length ) {
+                        return;
+                }
+                var instances = this.form.data( "ui-form-reset-instances" );
+                instances.splice( $.inArray( this, instances ), 1 );
+                if ( instances.length ) {
+                        this.form.data( "ui-form-reset-instances", instances );
+                } else {
+                        this.form
+                                .removeData( "ui-form-reset-instances" )
+                                .off( "reset.ui-form-reset" );
+                }
+        }
+};
+/*!
+ * jQuery UI Legacy jQuery Core patches 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ *
+ */
+//>>label: Legacy jQuery Core patches
+//>>group: Core
+//>>description: Backport `.even()`, `.odd()` and `$.escapeSelector` to older jQuery Core versions (deprecated)
+// Support: jQuery 2.2.x or older.
+// This method has been defined in jQuery 3.0.0.
+// Code from https://github.com/jquery/jquery/blob/e539bac79e666bba95bba86d690b4e609dca2286/src/selector/escapeSelector.js
+if ( !$.escapeSelector ) {
+        $.escapeSelector = function( id ) {
+                return CSS.escape( id + "" );
+        };
+}
+// Support: jQuery 3.4.x or older
+// These methods have been defined in jQuery 3.5.0.
+if ( !$.fn.even || !$.fn.odd ) {
+        $.fn.extend( {
+                even: function() {
+                        return this.filter( function( i ) {
+                                return i % 2 === 0;
+                        } );
+                },
+                odd: function() {
+                        return this.filter( function( i ) {
+                                return i % 2 === 1;
+                        } );
+                }
+        } );
+}
+;
+/*!
+ * jQuery UI Keycode 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: Keycode
+//>>group: Core
+//>>description: Provide keycodes as keynames
+//>>docs: https://api.jqueryui.com/jQuery.ui.keyCode/
+var keycode = $.ui.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
+};
+/*!
+ * jQuery UI Labels 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: labels
+//>>group: Core
+//>>description: Find all the labels associated with a given input
+//>>docs: https://api.jqueryui.com/labels/
+var labels = $.fn.labels = function() {
+        var ancestor, selector, id, labels, ancestors;
+        if ( !this.length ) {
+                return this.pushStack( [] );
+        }
+        // Check control.labels first
+        if ( this[ 0 ].labels && this[ 0 ].labels.length ) {
+                return this.pushStack( this[ 0 ].labels );
+        }
+        // If `control.labels` is empty - e.g. inside of document fragments - find
+        // the labels manually
+        labels = this.eq( 0 ).parents( "label" );
+        // Look for the label based on the id
+        id = this.attr( "id" );
+        if ( id ) {
+                // We don't search against the document in case the element
+                // is disconnected from the DOM
+                ancestor = this.eq( 0 ).parents().last();
+                // Get a full set of top level ancestors
+                ancestors = ancestor.add( ancestor.length ? ancestor.siblings() : this.siblings() );
+                // Create a selector for the label based on the id
+                selector = "label[for='" + CSS.escape( id ) + "']";
+                labels = labels.add( ancestors.find( selector ).addBack( selector ) );
+        }
+        // Return whatever we have found for labels
+        return this.pushStack( labels );
+};
+/*!
+ * jQuery UI Scroll Parent 1.14.2
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
 //>>label: scrollParent
 //>>group: Core
 …
 //>>docs: https://api.jqueryui.com/scrollParent/
+$.fn.scrollParent = function( includeHidden ) {
+var scrollParent = $.fn.scrollParent = function( includeHidden ) {
         var position = this.css( "position" ),
                 excludeStaticParent = position === "absolute",
 …
 };
+// Source: tabbable.js
 /*!
  * jQuery UI Tabbable 1.13.3
+ * jQuery UI Tabbable 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>docs: https://api.jqueryui.com/tabbable-selector/
+$.extend( $.expr.pseudos, {
+var tabbable = $.extend( $.expr.pseudos, {
         tabbable: function( element ) {
                 var tabIndex = $.attr( element, "tabindex" ),
 …
 } );
+// Source: unique-id.js
 /*!
  * jQuery UI Unique ID 1.13.3
+ * jQuery UI Unique ID 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>docs: https://api.jqueryui.com/uniqueId/
+$.fn.extend( {
+var uniqueId = $.fn.extend( {
         uniqueId: ( function() {
                 var uuid = 0;
 …
 } );
+// Source: widget.js
+/*!
+ * jQuery UI Widget 1.13.3
+ * https://jqueryui.com
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license.
+ * https://jquery.org/license
+ */
+//>>label: Widget
+//>>group: Core
+//>>description: Provides a factory for creating stateful widgets with a common API.
+//>>docs: https://api.jqueryui.com/jQuery.widget/
+//>>demos: https://jqueryui.com/widget/
+var widgetUuid = 0;
+var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
+var widgetSlice = Array.prototype.slice;
+$.cleanData = ( function( orig ) {
+        return function( elems ) {
+                var events, elem, i;
+                for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
+                        // Only trigger remove when necessary to save time
+                        events = $._data( elem, "events" );
+                        if ( events && events.remove ) {
+                                $( elem ).triggerHandler( "remove" );
+                        }
+                }
+                orig( elems );
+        };
+} )( $.cleanData );
+$.widget = function( name, base, prototype ) {
+        var existingConstructor, constructor, basePrototype;
+        // ProxiedPrototype allows the provided prototype to remain unmodified
+        // so that it can be used as a mixin for multiple widgets (#8876)
+        var proxiedPrototype = {};
+        var namespace = name.split( "." )[ 0 ];
+        name = name.split( "." )[ 1 ];
+        var fullName = namespace + "-" + name;
+        if ( !prototype ) {
+                prototype = base;
+                base = $.Widget;
+        }
+        if ( Array.isArray( prototype ) ) {
+                prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
+        }
+        // Create selector for plugin
+        $.expr.pseudos[ 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 || !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 ( typeof value !== "function" ) {
+                        proxiedPrototype[ prop ] = value;
+// This is copied from https://github.com/jquery/jquery-ui/blob/1.14.2/ui/plugin.js
+// $.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;
+                }
+                proxiedPrototype[ prop ] = ( function() {
+                        function _super() {
+                                return base.prototype[ prop ].apply( this, arguments );
+                        }
+                        function _superApply( args ) {
+                                return base.prototype[ prop ].apply( this, args );
+                        }
+                        return function() {
+                                var __super = this._super;
+                                var __superApply = this._superApply;
+                                var 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;
+                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 );
+                        }
+                }
+        }
 };
-$.widget.extend = function( target ) {
-        var input = widgetSlice.call( arguments, 1 );
-        var inputIndex = 0;
-        var inputLength = input.length;
-        var key;
-        var value;
-        for ( ; inputIndex < inputLength; inputIndex++ ) {
-                for ( key in input[ inputIndex ] ) {
-                        value = input[ inputIndex ][ key ];
-                        if ( widgetHasOwnProperty.call( input[ inputIndex ], 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";
-                var args = widgetSlice.call( arguments, 1 );
-                var returnValue = this;
-                if ( isMethodCall ) {
-                        // If this is an empty collection, we need to have the instance method
-                        // return undefined instead of the jQuery instance
-                        if ( !this.length && options === "instance" ) {
-                                returnValue = undefined;
-                        } else {
-                                this.each( function() {
-                                        var methodValue;
-                                        var 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 ( typeof instance[ options ] !== "function" ||
-                                                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: {
-                classes: {},
-                disabled: false,
-                // Callbacks
-                create: null
-        },
-        _createWidget: function( options, element ) {
-                element = $( element || this.defaultElement || this )[ 0 ];
-                this.element = $( element );
-                this.uuid = widgetUuid++;
-                this.eventNamespace = "." + this.widgetName + this.uuid;
-                this.bindings = $();
-                this.hoverable = $();
-                this.focusable = $();
-                this.classesElementLookup = {};
-                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();
-                if ( this.options.disabled ) {
-                        this._setOptionDisabled( this.options.disabled );
+                }
-                this._trigger( "create", null, this._getCreateEventData() );
-                this._init();
-        },
-        _getCreateOptions: function() {
-                return {};
-        },
-        _getCreateEventData: $.noop,
-        _create: $.noop,
-        _init: $.noop,
-        destroy: function() {
-                var that = this;
-                this._destroy();
-                $.each( this.classesElementLookup, function( key, value ) {
-                        that._removeClass( value, key );
-                } );
-                // We can probably remove the unbind calls in 2.0
-                // all event bindings should go through this._on()
-                this.element
-                        .off( this.eventNamespace )
-                        .removeData( this.widgetFullName );
-                this.widget()
-                        .off( this.eventNamespace )
-                        .removeAttr( "aria-disabled" );
-                // Clean up events and states
-                this.bindings.off( this.eventNamespace );
-        },
-        _destroy: $.noop,
-        widget: function() {
-                return this.element;
-        },
-        option: function( key, value ) {
-                var options = key;
-                var parts;
-                var curOption;
-                var 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 ) {
-                if ( key === "classes" ) {
-                        this._setOptionClasses( value );
+                }
-                this.options[ key ] = value;
-                if ( key === "disabled" ) {
-                        this._setOptionDisabled( value );
+                }
-                return this;
-        },
-        _setOptionClasses: function( value ) {
-                var classKey, elements, currentElements;
-                for ( classKey in value ) {
-                        currentElements = this.classesElementLookup[ classKey ];
-                        if ( value[ classKey ] === this.options.classes[ classKey ] ||
-                                        !currentElements ||
-                                        !currentElements.length ) {
-                                continue;
+                        }
-                        // We are doing this to create a new jQuery object because the _removeClass() call
-                        // on the next line is going to destroy the reference to the current elements being
-                        // tracked. We need to save a copy of this collection so that we can add the new classes
-                        // below.
-                        elements = $( currentElements.get() );
-                        this._removeClass( currentElements, classKey );
-                        // We don't use _addClass() here, because that uses this.options.classes
-                        // for generating the string of classes. We want to use the value passed in from
-                        // _setOption(), this is the new value of the classes option which was passed to
-                        // _setOption(). We pass this value directly to _classes().
-                        elements.addClass( this._classes( {
-                                element: elements,
-                                keys: classKey,
-                                classes: value,
-                                add: true
-                        } ) );
+                }
-        },
-        _setOptionDisabled: function( value ) {
-                this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
-                // If the widget is becoming disabled, then nothing is interactive
-                if ( value ) {
-                        this._removeClass( this.hoverable, null, "ui-state-hover" );
-                        this._removeClass( this.focusable, null, "ui-state-focus" );
+                }
-        },
-        enable: function() {
-                return this._setOptions( { disabled: false } );
-        },
-        disable: function() {
-                return this._setOptions( { disabled: true } );
-        },
-        _classes: function( options ) {
-                var full = [];
-                var that = this;
-                options = $.extend( {
-                        element: this.element,
-                        classes: this.options.classes || {}
-                }, options );
-                function bindRemoveEvent() {
-                        var nodesToBind = [];
-                        options.element.each( function( _, element ) {
-                                var isTracked = $.map( that.classesElementLookup, function( elements ) {
-                                        return elements;
-                                } )
-                                        .some( function( elements ) {
-                                                return elements.is( element );
-                                        } );
-                                if ( !isTracked ) {
-                                        nodesToBind.push( element );
+                                }
-                        } );
-                        that._on( $( nodesToBind ), {
-                                remove: "_untrackClassesElement"
-                        } );
+                }
-                function processClassString( classes, checkOption ) {
-                        var current, i;
-                        for ( i = 0; i < classes.length; i++ ) {
-                                current = that.classesElementLookup[ classes[ i ] ] || $();
-                                if ( options.add ) {
-                                        bindRemoveEvent();
-                                        current = $( $.uniqueSort( current.get().concat( options.element.get() ) ) );
-                                } else {
-                                        current = $( current.not( options.element ).get() );
+                                }
-                                that.classesElementLookup[ classes[ i ] ] = current;
-                                full.push( classes[ i ] );
-                                if ( checkOption && options.classes[ classes[ i ] ] ) {
-                                        full.push( options.classes[ classes[ i ] ] );
+                                }
+                        }
+                }
-                if ( options.keys ) {
-                        processClassString( options.keys.match( /\S+/g ) || [], true );
+                }
-                if ( options.extra ) {
-                        processClassString( options.extra.match( /\S+/g ) || [] );
+                }
-                return full.join( " " );
-        },
-        _untrackClassesElement: function( event ) {
-                var that = this;
-                $.each( that.classesElementLookup, function( key, value ) {
-                        if ( $.inArray( event.target, value ) !== -1 ) {
-                                that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
+                        }
-                } );
-                this._off( $( event.target ) );
-        },
-        _removeClass: function( element, keys, extra ) {
-                return this._toggleClass( element, keys, extra, false );
-        },
-        _addClass: function( element, keys, extra ) {
-                return this._toggleClass( element, keys, extra, true );
-        },
-        _toggleClass: function( element, keys, extra, add ) {
-                add = ( typeof add === "boolean" ) ? add : extra;
-                var shift = ( typeof element === "string" || element === null ),
-                        options = {
-                                extra: shift ? keys : extra,
-                                keys: shift ? element : keys,
-                                element: shift ? this.element : element,
-                                add: add
-                        };
-                options.element.toggleClass( this._classes( options ), add );
-                return this;
-        },
-        _on: function( suppressDisabledCheck, element, handlers ) {
-                var delegateElement;
-                var 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*(.*)$/ );
-                        var eventName = match[ 1 ] + instance.eventNamespace;
-                        var selector = match[ 2 ];
-                        if ( selector ) {
-                                delegateElement.on( eventName, selector, handlerProxy );
-                        } else {
-                                element.on( eventName, handlerProxy );
+                        }
-                } );
-        },
-        _off: function( element, eventName ) {
-                eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
-                        this.eventNamespace;
-                element.off( 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 ) {
-                                this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
-                        },
-                        mouseleave: function( event ) {
-                                this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
+                        }
-                } );
-        },
-        _focusable: function( element ) {
-                this.focusable = this.focusable.add( element );
-                this._on( element, {
-                        focusin: function( event ) {
-                                this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
-                        },
-                        focusout: function( event ) {
-                                this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
+                        }
-                } );
-        },
-        _trigger: function( type, event, data ) {
-                var prop, orig;
-                var 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 !( typeof callback === "function" &&
-                        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;
-                var effectName = !options ?
-                        method :
-                        options === true || typeof options === "number" ?
-                                defaultEffect :
-                                options.effect || defaultEffect;
-                options = options || {};
-                if ( typeof options === "number" ) {
-                        options = { duration: options };
-                } else if ( options === true ) {
-                        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();
-                        } );
+                }
-        };
 } );
-} ) );

trunk/src/js/_enqueues/vendor/jquery/ui/datepicker.js

-              r58218
+              r62747
 /* eslint-disable max-len, camelcase */
+/* eslint-disable max-len */
 /*!
  * jQuery UI Datepicker 1.13.3
+ * jQuery UI Datepicker 1.14.2
  * https://jqueryui.com
+ *
 …
 "use strict";
 $.extend( $.ui, { datepicker: { version: "1.13.3" } } );
+$.extend( $.ui, { datepicker: { version: "1.14.2" } } );
 var datepicker_instActive;
 …
+                }
+                $.datepicker._hideDatepicker();
                 if ( datepicker_instActive === inst ) {
                         datepicker_instActive = null;
 …
                 try {
                         return $.data( target, "datepicker" );
                 } catch ( err ) {
+                } catch ( _err ) {
                         throw "Missing instance data for this datepicker";
+                }
 …
                                         $.datepicker._updateDatepicker( inst );
+                                }
                         } catch ( err ) {
+                        } catch ( _err ) {
+                        }
+                }
 …
         },
-        // #6694 - don't focus the input if it's already focused
-        // this breaks the change event in IE
-        // Support: IE and jQuery <1.9
         _shouldFocusInput: function( inst ) {
                 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
+                return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" );
         },
 …
                         };
+                        // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
+                        if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
+                        if ( $.effects && ( $.effects.effect[ showAnim ] ) ) {
                                 inst.dpDiv.hide( showAnim, $.datepicker._get( inst, "showOptions" ), duration, postProcess );
                         } else {
 …
                 try {
                         date = this.parseDate( dateFormat, dates, settings ) || defaultDate;
                 } catch ( event ) {
+                } catch ( _err ) {
                         dates = ( noDefault ? "" : dates );
+                }
 …
                                         return $.datepicker.parseDate( $.datepicker._get( inst, "dateFormat" ),
                                                 offset, $.datepicker._getFormatConfig( inst ) );
                                 } catch ( e ) {
+                                } catch ( _e ) {
                                         // Ignore
 …
 $.datepicker.initialized = false;
 $.datepicker.uuid = new Date().getTime();
 $.datepicker.version = "1.13.3";
+$.datepicker.version = "1.14.2";
 return $.datepicker;

trunk/src/js/_enqueues/vendor/jquery/ui/dialog.js

-              r58218
+              r62747
 /*!
  * jQuery UI Dialog 1.13.3
+ * jQuery UI Dialog 1.14.2
  * https://jqueryui.com
+ *
 …
                         "../keycode",
                         "../position",
-                        "../safe-active-element",
-                        "../safe-blur",
                         "../tabbable",
                         "../unique-id",
 …
 $.widget( "ui.dialog", {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 appendTo: "body",
 …
                 show: null,
                 title: null,
+                uiDialogTitleHeadingLevel: 0,
                 width: 300,
 …
                         // 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.document[ 0 ].activeElement ).trigger( "blur" );
+                }
 …
                 this._isOpen = true;
                 this.opener = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
+                this.opener = $( this.document[ 0 ].activeElement );
                 this._size();
 …
         _restoreTabbableFocus: function() {
                 var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),
+                var activeElement = this.document[ 0 ].activeElement,
                         isActive = this.uiDialog[ 0 ] === activeElement ||
                                 $.contains( this.uiDialog[ 0 ], activeElement );
 …
                 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 );
         },
 …
                                 // Setting tabIndex makes the div focusable
                                 tabIndex: -1,
+                                role: "dialog"
+                                role: "dialog",
+                                "aria-modal": this.options.modal ? "true" : null
                         } )
                         .appendTo( this._appendTo() );
 …
                 } );
-                // 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( {
 …
                 } );
+                uiDialogTitle = $( "<span>" ).uniqueId().prependTo( this.uiDialogTitlebar );
+                var uiDialogHeadingLevel = Number.isInteger( this.options.uiDialogTitleHeadingLevel ) &&
+                        this.options.uiDialogTitleHeadingLevel > 0 &&
+                        this.options.uiDialogTitleHeadingLevel <= 6 ?
+                        "h" + this.options.uiDialogTitleHeadingLevel : "span";
+                uiDialogTitle = $( "<" + uiDialogHeadingLevel + ">" )
+                        .uniqueId().prependTo( this.uiDialogTitlebar );
                 this._addClass( uiDialogTitle, "ui-dialog-title" );
                 this._title( uiDialogTitle );
 …
                         this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
+                }
+                if ( key === "modal" ) {
+                        uiDialog.attr( "aria-modal", value ? "true" : null );
+                }
         },
 …
+                }
-                var jqMinor = $.fn.jquery.substring( 0, 4 );
                 // We use a delay in case the overlay is created from an
                 // event that we're going to be cancelling (#2804)
 …
                                         event.preventDefault();
                                         instance._focusTabbable();
-                                        // Support: jQuery >=3.4 <3.7 only
-                                        // In jQuery 3.4-3.6, there are multiple issues with focus/blur
-                                        // trigger chains or when triggering is done on a hidden element
-                                        // at least once.
-                                        // Trigger focus in a delay in addition if needed to avoid the issues.
-                                        // See https://github.com/jquery/jquery/issues/4382
-                                        // See https://github.com/jquery/jquery/issues/4856
-                                        // See https://github.com/jquery/jquery/issues/4950
-                                        if ( jqMinor === "3.4." || jqMinor === "3.5." || jqMinor === "3.6." ) {
-                                                instance._delay( instance._restoreTabbableFocus );
+                                        }
+                                }
                         }.bind( this ) );
 …
 // DEPRECATED
 // TODO: switch return back to widget declaration at top of file when this is removed
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Backcompat for dialogClass option

trunk/src/js/_enqueues/vendor/jquery/ui/draggable.js

-              r58218
+              r62747
 /*!
  * jQuery UI Draggable 1.13.3
+ * jQuery UI Draggable 1.14.2
  * https://jqueryui.com
+ *
 …
                         "../data",
                         "../plugin",
-                        "../safe-active-element",
-                        "../safe-blur",
                         "../scroll-parent",
                         "../version",
 …
 $.widget( "ui.draggable", $.ui.mouse, {
         version: "1.13.3",
+        version: "1.14.2",
         widgetEventPrefix: "drag",
         options: {
 …
         _blurActiveElement: function( event ) {
                 var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),
+                var activeElement = this.document[ 0 ].activeElement,
                         target = $( event.target );
 …
                 // Blur any element that currently has focus, see #4261
                 $.ui.safeBlur( activeElement );
+                $( activeElement ).trigger( "blur" );
         },

trunk/src/js/_enqueues/vendor/jquery/ui/droppable.js

-              r58218
+              r62747
 /*!
  * jQuery UI Droppable 1.13.3
+ * jQuery UI Droppable 1.14.2
  * https://jqueryui.com
+ *
 …
 $.widget( "ui.droppable", {
         version: "1.13.3",
+        version: "1.14.2",
         widgetEventPrefix: "drop",
         options: {
 …
 // DEPRECATED
 // TODO: switch return back to widget declaration at top of file when this is removed
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Backcompat for activeClass and hoverClass options

trunk/src/js/_enqueues/vendor/jquery/ui/effect-blind.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Blind 1.1~~3.3~~
	2	* jQuery UI Effects Blind 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-bounce.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Bounce 1.1~~3.3~~
	2	* jQuery UI Effects Bounce 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-clip.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Clip 1.1~~3.3~~
	2	* jQuery UI Effects Clip 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-drop.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Drop 1.1~~3.3~~
	2	* jQuery UI Effects Drop 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-explode.js

-              r58218
+              r62747
 /*!
  * jQuery UI Effects Explode 1.13.3
+ * jQuery UI Effects Explode 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>label: Explode Effect
 //>>group: Effects
-/* eslint-disable max-len */
 //>>description: Explodes an element in all directions into n pieces. Implodes an element to its original wholeness.
-/* eslint-enable max-len */
 //>>docs: https://api.jqueryui.com/explode-effect/
 //>>demos: https://jqueryui.com/effect/

trunk/src/js/_enqueues/vendor/jquery/ui/effect-fade.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Fade 1.1~~3.3~~
	2	* jQuery UI Effects Fade 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-fold.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Fold 1.1~~3.3~~
	2	* jQuery UI Effects Fold 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-highlight.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Highlight 1.1~~3.3~~
	2	* jQuery UI Effects Highlight 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-puff.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Puff 1.1~~3.3~~
	2	* jQuery UI Effects Puff 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-pulsate.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Pulsate 1.1~~3.3~~
	2	* jQuery UI Effects Pulsate 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-scale.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Scale 1.1~~3.3~~
	2	* jQuery UI Effects Scale 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-shake.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Shake 1.1~~3.3~~
	2	* jQuery UI Effects Shake 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-size.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Size 1.1~~3.3~~
	2	* jQuery UI Effects Size 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-slide.js

r58218	r62747
1	1	/*!
2		* jQuery UI Effects Slide 1.1~~3.3~~
	2	* jQuery UI Effects Slide 1.14.2
3	3	* https://jqueryui.com
4	4	*

trunk/src/js/_enqueues/vendor/jquery/ui/effect-transfer.js

-              r58218
+              r62747
 /*!
  * jQuery UI Effects Transfer 1.13.3
+ * jQuery UI Effects Transfer 1.14.2
  * https://jqueryui.com
+ *
 …
 var effect;
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         effect = $.effects.define( "transfer", function( options, done ) {
                 $( this ).transfer( options, done );

trunk/src/js/_enqueues/vendor/jquery/ui/effect.js

-              r58218
+              r62747
 /*!
  * jQuery UI Effects 1.13.3
+ * jQuery UI Effects 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>label: Effects Core
 //>>group: Effects
-/* eslint-disable max-len */
 //>>description: Extends the internal jQuery effects. Includes morphing and easing. Required by all other effects.
-/* eslint-enable max-len */
 //>>docs: https://api.jqueryui.com/category/effects-core/
 //>>demos: https://jqueryui.com/effect/
 …
 function getElementStyles( elem ) {
         var key, len,
+                style = elem.ownerDocument.defaultView ?
+                        elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
+                        elem.currentStyle,
+                style = elem.ownerDocument.defaultView.getComputedStyle( elem ),
                 styles = {};
+        if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
+                len = style.length;
+                while ( len-- ) {
+                        key = style[ len ];
+                        if ( typeof style[ key ] === "string" ) {
+                                styles[ camelCase( key ) ] = style[ key ];
+                        }
+                }
+        // Support: Opera, IE <9
+        } else {
+                for ( key in style ) {
+                        if ( typeof style[ key ] === "string" ) {
+                                styles[ key ] = style[ key ];
+                        }
+        len = style.length;
+        while ( len-- ) {
+                key = style[ len ];
+                if ( typeof style[ key ] === "string" ) {
+                        styles[ camelCase( key ) ] = style[ key ];
+                }
+        }
 …
         return diff;
+}
-// Support: jQuery <1.8
-if ( !$.fn.addBack ) {
-        $.fn.addBack = function( selector ) {
-                return this.add( selector == null ?
-                        this.prevObject : this.prevObject.filter( selector )
-                );
-        };
+}
 …
+}
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         $.extend( $.effects, {
 …
                                 // eslint-disable-next-line no-unused-expressions
                                 active.id;
                         } catch ( e ) {
+                        } catch ( _e ) {
                                 active = document.body;
+                        }
 …
 $.extend( $.effects, {
         version: "1.13.3",
+        version: "1.14.2",
         define: function( name, mode, effect ) {
 …
                         args.mode = modes.shift();
                         if ( $.uiBackCompat !== false && !defaultMode ) {
+                        if ( $.uiBackCompat === true && !defaultMode ) {
                                 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {

trunk/src/js/_enqueues/vendor/jquery/ui/menu.js

-              r58218
+              r62747
 /*!
  * jQuery UI Menu 1.13.3
+ * jQuery UI Menu 1.14.2
  * https://jqueryui.com
+ *
 …
                         "../keycode",
                         "../position",
-                        "../safe-active-element",
                         "../unique-id",
                         "../version",
 …
 return $.widget( "ui.menu", {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<ul>",
         delay: 300,
 …
                         "click .ui-menu-item": function( event ) {
                                 var target = $( event.target );
                                 var active = $( $.ui.safeActiveElement( this.document[ 0 ] ) );
+                                var active = $( this.document[ 0 ].activeElement );
                                 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
                                         this.select( event );
 …
                                         var notContained = !$.contains(
                                                 this.element[ 0 ],
                                                 $.ui.safeActiveElement( this.document[ 0 ] )
+                                                this.document[ 0 ].activeElement
                                         );
                                         if ( notContained ) {

trunk/src/js/_enqueues/vendor/jquery/ui/mouse.js

-              r58218
+              r62747
 /*!
  * jQuery UI Mouse 1.13.3
+ * jQuery UI Mouse 1.14.2
  * https://jqueryui.com
+ *
 …
                 define( [
                         "jquery",
-                        "../ie",
                         "../version",
                         "../widget"
 …
 return $.widget( "ui.mouse", {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 cancel: "input, textarea, button, select, option",
 …
                 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 );
+                        btnIsLeft = event.which === 1,
+                        elIsCancel = typeof this.options.cancel === "string" ?
+                                $( event.target ).closest( this.options.cancel ).length :
+                                false;
                 if ( !btnIsLeft || elIsCancel || !this._mouseCapture( event ) ) {
                         return true;
 …
                 // 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 ) {
+                // at least once.
+                if ( this._mouseMoved && !event.which ) {
+                        // Support: Safari <=8 - 9
+                        // Safari sets which to 0 if you press any of the following keys
+                        // during a drag (#14461)
+                        if ( event.originalEvent.altKey || event.originalEvent.ctrlKey ||
+                                        event.originalEvent.metaKey || event.originalEvent.shiftKey ) {
+                                this.ignoreMissingWhich = true;
+                        } else if ( !this.ignoreMissingWhich ) {
                                 return this._mouseUp( event );
-                        // Iframe mouseup check - mouseup occurred in another document
-                        } else if ( !event.which ) {
-                                // Support: Safari <=8 - 9
-                                // Safari sets which to 0 if you press any of the following keys
-                                // during a drag (#14461)
-                                if ( event.originalEvent.altKey || event.originalEvent.ctrlKey ||
-                                                event.originalEvent.metaKey || event.originalEvent.shiftKey ) {
-                                        this.ignoreMissingWhich = true;
-                                } else if ( !this.ignoreMissingWhich ) {
-                                        return this._mouseUp( event );
+                                }
+                        }
+                }

trunk/src/js/_enqueues/vendor/jquery/ui/progressbar.js

-              r58218
+              r62747
 /*!
  * jQuery UI Progressbar 1.13.3
+ * jQuery UI Progressbar 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>label: Progressbar
 //>>group: Widgets
-/* eslint-disable max-len */
 //>>description: Displays a status indicator for loading state, standard percentage, and other progress indicators.
-/* eslint-enable max-len */
 //>>docs: https://api.jqueryui.com/progressbar/
 //>>demos: https://jqueryui.com/progressbar/
 …
 return $.widget( "ui.progressbar", {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 classes: {

trunk/src/js/_enqueues/vendor/jquery/ui/resizable.js

-              r58218
+              r62747
 /*!
  * jQuery UI Resizable 1.13.3
+ * jQuery UI Resizable 1.14.2
  * https://jqueryui.com
+ *
 …
 $.widget( "ui.resizable", $.ui.mouse, {
         version: "1.13.3",
+        version: "1.14.2",
         widgetEventPrefix: "resize",
         options: {
 …
         _hasScroll: function( el, a ) {
+                if ( $( el ).css( "overflow" ) === "hidden" ) {
+                var scroll,
+                        has = false,
+                        overflow = $( el ).css( "overflow" );
+                if ( overflow === "hidden" ) {
                         return false;
+                }
+                var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
+                        has = false;
+                if ( overflow === "scroll" ) {
+                        return true;
+                }
+                scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop";
                 if ( el[ scroll ] > 0 ) {
 …
                         has = ( el[ scroll ] > 0 );
                         el[ scroll ] = 0;
                 } catch ( e ) {
+                } catch ( _e ) {
                         // `el` might be a string, then setting `scroll` will throw
 …
                         this.element.css( margins );
+                        this.originalElement.css( "margin", 0 );
+                        // support: Safari
+                        // Support: Safari
                         // Prevent Safari textarea resize
                         this.originalResizeStyle = this.originalElement.css( "resize" );
 …
                                 display: "block"
                         } ) );
-                        // Support: IE9
-                        // avoid IE jump (hard set the margin)
-                        this.originalElement.css( margins );
                         this._proportionallyResize();
 …
         _mouseStart: function( event ) {
                 var curleft, curtop, cursor,
+                var curleft, curtop, cursor, calculatedSize,
                         o = this.options,
                         el = this.element;
 …
                 this.offset = this.helper.offset();
                 this.position = { left: curleft, top: curtop };
+                if ( !this._helper ) {
+                        calculatedSize = this._calculateAdjustedElementDimensions( el );
+                }
                 this.size = this._helper ? {
 …
                                 height: this.helper.height()
                         } : {
                                 width: el.width(),
                                 height: el.height()
+                                width: calculatedSize.width,
+                                height: calculatedSize.height
                         };
 …
                                 height: el.outerHeight()
                         } : {
                                 width: el.width(),
                                 height: el.height()
+                                width: calculatedSize.width,
+                                height: calculatedSize.height
                         };
 …
                         width: widths[ 1 ] + widths[ 3 ]
                 };
+        },
+        _calculateAdjustedElementDimensions: function( element ) {
+                var elWidth, elHeight, paddingBorder,
+                        ce = element.get( 0 );
+                if ( element.css( "box-sizing" ) !== "content-box" ||
+                        ( !this._hasScroll( ce ) && !this._hasScroll( ce, "left" ) ) ) {
+                                return {
+                                        height: parseFloat( element.css( "height" ) ),
+                                        width: parseFloat( element.css( "width" ) )
+                                };
+                }
+                // Check if CSS inline styles are set and use those (usually from previous resizes)
+                elWidth = parseFloat( ce.style.width );
+                elHeight = parseFloat( ce.style.height );
+                paddingBorder = this._getPaddingPlusBorderDimensions( element );
+                elWidth = isNaN( elWidth ) ?
+                        this._getElementTheoreticalSize( element, paddingBorder, "width" ) :
+                        elWidth;
+                elHeight = isNaN( elHeight ) ?
+                        this._getElementTheoreticalSize( element, paddingBorder, "height" ) :
+                        elHeight;
+                return {
+                        height: elHeight,
+                        width: elWidth
+                };
+        },
+        _getElementTheoreticalSize: function( element, extraSize, dimension ) {
+                // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+                var size = Math.max( 0, Math.ceil(
+                        element.get( 0 )[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+                        extraSize[ dimension ] -
+.5
+                // If offsetWidth/offsetHeight is unknown, then we can't determine theoretical size.
+                // Use an explicit zero to avoid NaN.
+                // See https://github.com/jquery/jquery/issues/3964
+                ) ) || 0;
+                return size;
         },
 …
                 $( o.alsoResize ).each( function() {
+                        var el = $( this );
+                        var el = $( this ),
+                                elSize = that._calculateAdjustedElementDimensions( el );
                         el.data( "ui-resizable-alsoresize", {
                                 width: parseFloat( el.css( "width" ) ), height: parseFloat( el.css( "height" ) ),
+                                width: elSize.width, height: elSize.height,
                                 left: parseFloat( el.css( "left" ) ), top: parseFloat( el.css( "top" ) )
                         } );
 …
                 // DEPRECATED
                 // TODO: remove after 1.12
                 if ( $.uiBackCompat !== false && typeof that.options.ghost === "string" ) {
+                if ( $.uiBackCompat === true && typeof that.options.ghost === "string" ) {
                         // Ghost option

trunk/src/js/_enqueues/vendor/jquery/ui/selectable.js

-              r58218
+              r62747
 /*!
  * jQuery UI Selectable 1.13.3
+ * jQuery UI Selectable 1.14.2
  * https://jqueryui.com
+ *
 …
 return $.widget( "ui.selectable", $.ui.mouse, {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 appendTo: "body",

trunk/src/js/_enqueues/vendor/jquery/ui/selectmenu.js

-              r58218
+              r62747
 /*!
  * jQuery UI Selectmenu 1.13.3
+ * jQuery UI Selectmenu 1.14.2
  * https://jqueryui.com
+ *
 …
 //>>label: Selectmenu
 //>>group: Widgets
-/* eslint-disable max-len */
 //>>description: Duplicates and extends the functionality of a native HTML select element, allowing it to be customizable in behavior and appearance far beyond the limitations of a native select.
-/* eslint-enable max-len */
 //>>docs: https://api.jqueryui.com/selectmenu/
 //>>demos: https://jqueryui.com/selectmenu/
 …
 return $.widget( "ui.selectmenu", [ $.ui.formResetMixin, {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<select>",
         options: {
 …
                                 select: function( event, ui ) {
                                         event.preventDefault();
-                                        // Support: IE8
-                                        // If the item was selected via a click, the text selection
-                                        // will be destroyed in IE
-                                        that._setSelection();
                                         that._select( ui.item.data( "ui-selectmenu-item" ), event );
                                 },
 …
+                }
+                if ( window.getSelection ) {
+                        selection = window.getSelection();
+                        selection.removeAllRanges();
+                        selection.addRange( this.range );
+                // Support: IE8
+                } else {
+                        this.range.select();
+                }
+                // Support: IE
+                // Setting the text selection kills the button focus in IE, but
+                // restoring the focus doesn't kill the selection.
+                this.button.trigger( "focus" );
+                selection = window.getSelection();
+                selection.removeAllRanges();
+                selection.addRange( this.range );
         },
 …
                         if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" +
                                 $.escapeSelector( this.ids.button ) ).length ) {
+                                CSS.escape( this.ids.button ) ).length ) {
                                 this.close( event );
+                        }
 …
                 // Prevent text selection from being reset when interacting with the selectmenu (#10144)
                 mousedown: function() {
+                        var selection;
+                        if ( window.getSelection ) {
+                                selection = window.getSelection();
+                                if ( selection.rangeCount ) {
+                                        this.range = selection.getRangeAt( 0 );
+                                }
+                        // Support: IE8
+                        } else {
+                                this.range = document.selection.createRange();
+                        var selection = window.getSelection();
+                        if ( selection.rangeCount ) {
+                                this.range = selection.getRangeAt( 0 );
+                        }
                 },
 …
                 this.menu.outerWidth( Math.max(
                         this.button.outerWidth(),
+                        // Support: IE10
+                        // IE10 wraps long text (possibly a rounding bug)
+                        // so we add 1px to avoid the wrapping
+                        this.menu.width( "" ).outerWidth() + 1
+                        this.menu.width( "" ).outerWidth()
                 ) );
         },

trunk/src/js/_enqueues/vendor/jquery/ui/slider.js

-              r58218
+              r62747
 /*!
  * jQuery UI Slider 1.13.3
+ * jQuery UI Slider 1.14.2
  * https://jqueryui.com
+ *
 …
 return $.widget( "ui.slider", $.ui.mouse, {
         version: "1.13.3",
+        version: "1.14.2",
         widgetEventPrefix: "slide",

trunk/src/js/_enqueues/vendor/jquery/ui/sortable.js

-              r58218
+              r62747
 /*!
  * jQuery UI Sortable 1.13.3
+ * jQuery UI Sortable 1.14.2
  * https://jqueryui.com
+ *
 …
                         "./mouse",
                         "../data",
-                        "../ie",
                         "../scroll-parent",
                         "../version",
 …
 return $.widget( "ui.sortable", $.ui.mouse, {
         version: "1.13.3",
+        version: "1.14.2",
         widgetEventPrefix: "sort",
         ready: false,
 …
                         body = this.document.find( "body" );
+                        // Support: IE
+                        this.storedCursor = body.css( "cursor" );
+                        body.css( "cursor", o.cursor );
+                        this.storedStylesheet =
+                        this._storedStylesheet =
                                 $( "<style>*{ cursor: " + o.cursor + " !important; }</style>" ).appendTo( body );
+                }
 …
+                }
+                // This needs to be actually done for all browsers, since pageX/pageY includes this
+                // information with an ugly IE fix
+                if ( this.offsetParent[ 0 ] === this.document[ 0 ].body ||
+                                ( this.offsetParent[ 0 ].tagName &&
+                                this.offsetParent[ 0 ].tagName.toLowerCase() === "html" && $.ui.ie ) ) {
+                // This needs to be actually done for all browsers, since pageX/pageY includes
+                // this information.
+                if ( this.offsetParent[ 0 ] === this.document[ 0 ].body ) {
                         po = { top: 0, left: 0 };
+                }
 …
                 //Do what was originally in plugins
                 if ( this.storedCursor ) {
                         this.document.find( "body" ).css( "cursor", this.storedCursor );
                         this.storedStylesheet.remove();
+                if ( this._storedStylesheet ) {
+                        this._storedStylesheet.remove();
+                        this._storedStylesheet = null;
+                }
                 if ( this._storedOpacity ) {

trunk/src/js/_enqueues/vendor/jquery/ui/spinner.js

-              r58218
+              r62747
 /*!
  * jQuery UI Spinner 1.13.3
+ * jQuery UI Spinner 1.14.2
  * https://jqueryui.com
+ *
 …
                         "../version",
                         "../keycode",
-                        "../safe-active-element",
                         "../widget"
                 ], factory );
 …
 $.widget( "ui.spinner", {
         version: "1.13.3",
+        version: "1.14.2",
         defaultElement: "<input>",
         widgetEventPrefix: "spin",
 …
                 },
                 blur: function( event ) {
-                        if ( this.cancelBlur ) {
-                                delete this.cancelBlur;
-                                return;
+                        }
                         this._stop();
                         this._refresh();
 …
+                        }
                 },
                 mousewheel: function( event, delta ) {
                         var activeElement = $.ui.safeActiveElement( this.document[ 0 ] );
+                wheel: function( event ) {
+                        var activeElement = this.document[ 0 ].activeElement;
                         var isActive = this.element[ 0 ] === activeElement;
+                        var delta = event.deltaY || event.originalEvent && event.originalEvent.deltaY;
                         if ( !isActive || !delta ) {
 …
+                        }
                         this._spin( ( delta > 0 ? 1 : -1 ) * this.options.step, event );
+                        this._spin( ( delta > 0 ? -1 : 1 ) * this.options.step, event );
                         clearTimeout( this.mousewheelTimer );
                         this.mousewheelTimer = this._delay( function() {
 …
                         event.preventDefault();
                 },
+                // DEPRECATED
+                // Kept for backwards compatibility. Please use the modern `wheel`
+                // event. The `delta` parameter is provided by the jQuery Mousewheel
+                // plugin if one is loaded.
+                mousewheel: function( event, delta ) {
+                        if ( !event.isTrigger ) {
+                                // If this is not a trigger call, the `wheel` handler will
+                                // fire as well, let's not duplicate it.
+                                return;
+                        }
+                        var wheelEvent = $.Event( event );
+                        wheelEvent.type = "wheel";
+                        if ( delta ) {
+                                wheelEvent.deltaY = -delta;
+                        }
+                        return this._events.wheel.call( this, wheelEvent );
+                },
                 "mousedown .ui-spinner-button": function( event ) {
                         var previous;
 …
                         // when the input first received focus. If the input is not focused
                         // then we need to set this.previous based on the value before spinning.
                         previous = this.element[ 0 ] === $.ui.safeActiveElement( this.document[ 0 ] ) ?
+                        previous = this.element[ 0 ] === this.document[ 0 ].activeElement ?
                                 this.previous : this.element.val();
                         function checkFocus() {
                                 var isActive = this.element[ 0 ] === $.ui.safeActiveElement( this.document[ 0 ] );
+                                var isActive = this.element[ 0 ] === this.document[ 0 ].activeElement;
                                 if ( !isActive ) {
                                         this.element.trigger( "focus" );
                                         this.previous = previous;
-                                        // support: IE
-                                        // IE sets focus asynchronously, so we need to check if focus
-                                        // moved off of the input because the user clicked on the button.
-                                        this._delay( function() {
-                                                this.previous = previous;
-                                        } );
+                                }
+                        }
 …
                         event.preventDefault();
                         checkFocus.call( this );
-                        // Support: IE
-                        // IE doesn't prevent moving focus even with event.preventDefault()
-                        // so we set a flag to know when we should ignore the blur event
-                        // and check (again) if focus moved off of the input.
-                        this.cancelBlur = true;
-                        this._delay( function() {
-                                delete this.cancelBlur;
-                                checkFocus.call( this );
-                        } );
                         if ( this._start( event ) === false ) {
 …
 // DEPRECATED
 // TODO: switch return back to widget declaration at top of file when this is removed
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Backcompat for spinner html extension points

trunk/src/js/_enqueues/vendor/jquery/ui/tabs.js

-              r58218
+              r62747
 /*!
  * jQuery UI Tabs 1.13.3
+ * jQuery UI Tabs 1.14.2
  * https://jqueryui.com
+ *
 …
                         "jquery",
                         "../keycode",
-                        "../safe-active-element",
                         "../unique-id",
                         "../version",
 …
 $.widget( "ui.tabs", {
         version: "1.13.3",
+        version: "1.14.2",
         delay: 300,
         options: {
 …
         },
+        _isLocal: ( function() {
+                var rhash = /#.*$/;
+                return function( anchor ) {
+                        var anchorUrl, locationUrl;
+                        anchorUrl = anchor.href.replace( rhash, "" );
+                        locationUrl = location.href.replace( rhash, "" );
+                        // Decoding may throw an error if the URL isn't UTF-8 (#9518)
+                        try {
+                                anchorUrl = decodeURIComponent( anchorUrl );
+                        } catch ( error ) {}
+                        try {
+                                locationUrl = decodeURIComponent( locationUrl );
+                        } catch ( error ) {}
+                        return anchor.hash.length > 1 && anchorUrl === locationUrl;
+                };
+        } )(),
+        _isLocal: function( anchor ) {
+                var anchorUrl = new URL( anchor.href ),
+                        locationUrl = new URL( location.href );
+                return anchor.hash.length > 1 &&
+                        // `href` may contain a hash but also username & password;
+                        // we want to ignore them, so we check the three fields
+                        // below instead.
+                        anchorUrl.origin === locationUrl.origin &&
+                        anchorUrl.pathname === locationUrl.pathname &&
+                        anchorUrl.search === locationUrl.search;
+        },
         _create: function() {
 …
                 var active = this.options.active,
                         collapsible = this.options.collapsible,
+                        locationHash = location.hash.substring( 1 );
+                        locationHash = location.hash.substring( 1 ),
+                        locationHashDecoded = decodeURIComponent( locationHash );
                 if ( active === null ) {
 …
+                                        }
                                 } );
+                                // If not found, decode the hash & try again.
+                                // See the comment in `_processTabs` under the `_isLocal` check
+                                // for more information.
+                                if ( active === null ) {
+                                        this.tabs.each( function( i, tab ) {
+                                                if ( $( tab ).attr( "aria-controls" ) === locationHashDecoded ) {
+                                                        active = i;
+                                                        return false;
+                                                }
+                                        } );
+                                }
+                        }
 …
         _tabKeydown: function( event ) {
                 var focusedTab = $( $.ui.safeActiveElement( this.document[ 0 ] ) ).closest( "li" ),
+                var focusedTab = $( this.document[ 0 ].activeElement ).closest( "li" ),
                         selectedIndex = this.tabs.index( focusedTab ),
                         goingForward = true;
 …
         },
-        _sanitizeSelector: function( hash ) {
-                return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
-        },
         refresh: function() {
                 var options = this.options,
 …
                                         event.preventDefault();
+                                }
-                        } )
-                        // Support: IE <9
-                        // Preventing the default action in mousedown doesn't prevent IE
-                        // from focusing the element, so if the anchor gets focused, blur.
-                        // We don't have to worry about focusing the previously focused
-                        // element since clicking on a non-focusable element should focus
-                        // the body anyway.
-                        .on( "focus" + this.eventNamespace, ".ui-tabs-anchor", function() {
-                                if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
-                                        this.blur();
+                                }
                         } );
 …
                         // Inline tab
                         if ( that._isLocal( anchor ) ) {
+                                // The "scrolling to a fragment" section of the HTML spec:
+                                // https://html.spec.whatwg.org/#scrolling-to-a-fragment
+                                // uses a concept of document's indicated part:
+                                // https://html.spec.whatwg.org/#the-indicated-part-of-the-document
+                                // Slightly below there's an algorithm to compute the indicated
+                                // part:
+                                // https://html.spec.whatwg.org/#the-indicated-part-of-the-document
+                                // First, the algorithm tries the hash as-is, without decoding.
+                                // Then, if one is not found, the same is attempted with a decoded
+                                // hash. Replicate this logic.
                                 selector = anchor.hash;
                                 panelId = selector.substring( 1 );
+                                panel = that.element.find( that._sanitizeSelector( selector ) );
+                                panel = that.element.find( "#" + CSS.escape( panelId ) );
+                                if ( !panel.length ) {
+                                        panelId = decodeURIComponent( panelId );
+                                        panel = that.element.find( "#" + CSS.escape( panelId ) );
+                                }
                         // remote tab
 …
                 if ( typeof index === "string" ) {
                         index = this.anchors.index( this.anchors.filter( "[href$='" +
                                 $.escapeSelector( index ) + "']" ) );
+                                CSS.escape( index ) + "']" ) );
+                }
 …
                 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
+                // Support: jQuery <1.8
+                // jQuery <1.8 returns false if the request is canceled in beforeSend,
+                // but as of 1.8, $.ajax() always returns a jqXHR object.
+                if ( this.xhr && this.xhr.statusText !== "canceled" ) {
+                if ( this.xhr.statusText !== "canceled" ) {
                         this._addClass( tab, "ui-tabs-loading" );
                         panel.attr( "aria-busy", "true" );
 …
                         this.xhr
                                 .done( function( response, status, jqXHR ) {
+                                        // support: jQuery <1.8
+                                        // https://bugs.jquery.com/ticket/11778
+                                        setTimeout( function() {
+                                                panel.html( response );
+                                                that._trigger( "load", event, eventData );
+                                                complete( jqXHR, status );
+                                        }, 1 );
+                                        panel.html( response );
+                                        that._trigger( "load", event, eventData );
+                                        complete( jqXHR, status );
                                 } )
                                 .fail( function( jqXHR, status ) {
+                                        // support: jQuery <1.8
+                                        // https://bugs.jquery.com/ticket/11778
+                                        setTimeout( function() {
+                                                complete( jqXHR, status );
+                                        }, 1 );
+                                        complete( jqXHR, status );
                                 } );
+                }
 …
                 var that = this;
                 return {
+                        // Support: IE <11 only
+                        // Strip any hash that exists to prevent errors with the Ajax request
+                        url: anchor.attr( "href" ).replace( /#.*$/, "" ),
+                        url: anchor.attr( "href" ),
                         beforeSend: function( jqXHR, settings ) {
                                 return that._trigger( "beforeLoad", event,
 …
         _getPanelForTab: function( tab ) {
                 var id = $( tab ).attr( "aria-controls" );
                 return this.element.find( this._sanitizeSelector( "#" + id ) );
+                return this.element.find( "#" + CSS.escape( id ) );
+        }
 } );
 …
 // DEPRECATED
 // TODO: Switch return back to widget declaration at top of file when this is removed
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Backcompat for ui-tab class (now ui-tabs-tab)

trunk/src/js/_enqueues/vendor/jquery/ui/tooltip.js

-              r58218
+              r62747
 /*!
  * jQuery UI Tooltip 1.13.3
+ * jQuery UI Tooltip 1.14.2
  * https://jqueryui.com
+ *
 …
 $.widget( "ui.tooltip", {
         version: "1.13.3",
+        version: "1.14.2",
         options: {
                 classes: {
 …
                 content = contentOption.call( target[ 0 ], function( response ) {
+                        // IE may instantly serve a cached response for ajax requests
+                        // delay this call to _open so the other call to _open runs first
+                        that._delay( function() {
+                                // Ignore async response if tooltip was closed already
+                                if ( !target.data( "ui-tooltip-open" ) ) {
+                                        return;
+                                }
+                                // JQuery creates a special event for focusin when it doesn't
+                                // exist natively. To improve performance, the native event
+                                // object is reused and the type is changed. Therefore, we can't
+                                // rely on the type being correct after the event finished
+                                // bubbling, so we set it back to the previous value. (#8740)
+                                if ( event ) {
+                                        event.type = eventType;
+                                }
+                                this._open( event, target, response );
+                        } );
+                        // Ignore async response if tooltip was closed already
+                        if ( !target.data( "ui-tooltip-open" ) ) {
+                                return;
+                        }
+                        // JQuery creates a special event for focusin when it doesn't
+                        // exist natively. To improve performance, the native event
+                        // object is reused and the type is changed. Therefore, we can't
+                        // rely on the type being correct after the event finished
+                        // bubbling, so we set it back to the previous value. (#8740)
+                        if ( event ) {
+                                event.type = eventType;
+                        }
+                        that._open( event, target, response );
                 } );
                 if ( content ) {
 …
 // DEPRECATED
 // TODO: Switch return back to widget declaration at top of file when this is removed
 if ( $.uiBackCompat !== false ) {
+if ( $.uiBackCompat === true ) {
         // Backcompat for tooltipClass option

trunk/src/wp-includes/script-loader.php

-              r62741
+              r62747
          * A notable change is that 'jquery-ui-core' now contains 'jquery-ui-position' and 'jquery-ui-widget'.
          */
+        $scripts->add( 'jquery-ui-core', "/wp-includes/js/jquery/ui/core$suffix.js", array( 'jquery' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-core', "/wp-includes/js/jquery/ui/effect$suffix.js", array( 'jquery' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-blind', "/wp-includes/js/jquery/ui/effect-blind$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-bounce', "/wp-includes/js/jquery/ui/effect-bounce$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-clip', "/wp-includes/js/jquery/ui/effect-clip$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-drop', "/wp-includes/js/jquery/ui/effect-drop$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-explode', "/wp-includes/js/jquery/ui/effect-explode$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-fade', "/wp-includes/js/jquery/ui/effect-fade$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-fold', "/wp-includes/js/jquery/ui/effect-fold$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-highlight', "/wp-includes/js/jquery/ui/effect-highlight$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-puff', "/wp-includes/js/jquery/ui/effect-puff$suffix.js", array( 'jquery-effects-core', 'jquery-effects-scale' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-pulsate', "/wp-includes/js/jquery/ui/effect-pulsate$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-scale', "/wp-includes/js/jquery/ui/effect-scale$suffix.js", array( 'jquery-effects-core', 'jquery-effects-size' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-shake', "/wp-includes/js/jquery/ui/effect-shake$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-size', "/wp-includes/js/jquery/ui/effect-size$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-slide', "/wp-includes/js/jquery/ui/effect-slide$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-effects-transfer', "/wp-includes/js/jquery/ui/effect-transfer$suffix.js", array( 'jquery-effects-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-ui-core', "/wp-includes/js/jquery/ui/core$suffix.js", array( 'jquery' ), '1.14.2', 1 );
+        $scripts->add_inline_script( 'jquery-ui-core', 'jQuery.uiBackCompat = true;', 'before' );
+        $scripts->add( 'jquery-effects-core', "/wp-includes/js/jquery/ui/effect$suffix.js", array( 'jquery' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-blind', "/wp-includes/js/jquery/ui/effect-blind$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-bounce', "/wp-includes/js/jquery/ui/effect-bounce$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-clip', "/wp-includes/js/jquery/ui/effect-clip$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-drop', "/wp-includes/js/jquery/ui/effect-drop$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-explode', "/wp-includes/js/jquery/ui/effect-explode$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-fade', "/wp-includes/js/jquery/ui/effect-fade$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-fold', "/wp-includes/js/jquery/ui/effect-fold$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-highlight', "/wp-includes/js/jquery/ui/effect-highlight$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-puff', "/wp-includes/js/jquery/ui/effect-puff$suffix.js", array( 'jquery-effects-core', 'jquery-effects-scale' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-pulsate', "/wp-includes/js/jquery/ui/effect-pulsate$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-scale', "/wp-includes/js/jquery/ui/effect-scale$suffix.js", array( 'jquery-effects-core', 'jquery-effects-size' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-shake', "/wp-includes/js/jquery/ui/effect-shake$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-size', "/wp-includes/js/jquery/ui/effect-size$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-slide', "/wp-includes/js/jquery/ui/effect-slide$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-effects-transfer', "/wp-includes/js/jquery/ui/effect-transfer$suffix.js", array( 'jquery-effects-core' ), '1.14.2', 1 );
         // Widgets
         $scripts->add( 'jquery-ui-accordion', "/wp-includes/js/jquery/ui/accordion$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-autocomplete', "/wp-includes/js/jquery/ui/autocomplete$suffix.js", array( 'jquery-ui-menu', 'wp-a11y' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-button', "/wp-includes/js/jquery/ui/button$suffix.js", array( 'jquery-ui-core', 'jquery-ui-controlgroup', 'jquery-ui-checkboxradio' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-datepicker', "/wp-includes/js/jquery/ui/datepicker$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-dialog', "/wp-includes/js/jquery/ui/dialog$suffix.js", array( 'jquery-ui-resizable', 'jquery-ui-draggable', 'jquery-ui-button' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-menu', "/wp-includes/js/jquery/ui/menu$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-mouse', "/wp-includes/js/jquery/ui/mouse$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-progressbar', "/wp-includes/js/jquery/ui/progressbar$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-selectmenu', "/wp-includes/js/jquery/ui/selectmenu$suffix.js", array( 'jquery-ui-menu' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-slider', "/wp-includes/js/jquery/ui/slider$suffix.js", array( 'jquery-ui-mouse' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-spinner', "/wp-includes/js/jquery/ui/spinner$suffix.js", array( 'jquery-ui-button' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-tabs', "/wp-includes/js/jquery/ui/tabs$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-tooltip', "/wp-includes/js/jquery/ui/tooltip$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         // New in 1.12.1
         $scripts->add( 'jquery-ui-checkboxradio', "/wp-includes/js/jquery/ui/checkboxradio$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-controlgroup', "/wp-includes/js/jquery/ui/controlgroup$suffix.js", array( 'jquery-ui-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-ui-accordion', "/wp-includes/js/jquery/ui/accordion$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-autocomplete', "/wp-includes/js/jquery/ui/autocomplete$suffix.js", array( 'jquery-ui-menu', 'wp-a11y' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-button', "/wp-includes/js/jquery/ui/button$suffix.js", array( 'jquery-ui-core', 'jquery-ui-controlgroup', 'jquery-ui-checkboxradio' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-datepicker', "/wp-includes/js/jquery/ui/datepicker$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-dialog', "/wp-includes/js/jquery/ui/dialog$suffix.js", array( 'jquery-ui-resizable', 'jquery-ui-draggable', 'jquery-ui-button' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-menu', "/wp-includes/js/jquery/ui/menu$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-mouse', "/wp-includes/js/jquery/ui/mouse$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-progressbar', "/wp-includes/js/jquery/ui/progressbar$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-selectmenu', "/wp-includes/js/jquery/ui/selectmenu$suffix.js", array( 'jquery-ui-menu' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-slider', "/wp-includes/js/jquery/ui/slider$suffix.js", array( 'jquery-ui-mouse' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-spinner', "/wp-includes/js/jquery/ui/spinner$suffix.js", array( 'jquery-ui-button' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-tabs', "/wp-includes/js/jquery/ui/tabs$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-tooltip', "/wp-includes/js/jquery/ui/tooltip$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        // Added in jQuery UI 1.12.1.
+        $scripts->add( 'jquery-ui-checkboxradio', "/wp-includes/js/jquery/ui/checkboxradio$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-controlgroup', "/wp-includes/js/jquery/ui/controlgroup$suffix.js", array( 'jquery-ui-core' ), '1.14.2', 1 );
         // Interactions
         $scripts->add( 'jquery-ui-draggable', "/wp-includes/js/jquery/ui/draggable$suffix.js", array( 'jquery-ui-mouse' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-droppable', "/wp-includes/js/jquery/ui/droppable$suffix.js", array( 'jquery-ui-draggable' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-resizable', "/wp-includes/js/jquery/ui/resizable$suffix.js", array( 'jquery-ui-mouse' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-selectable', "/wp-includes/js/jquery/ui/selectable$suffix.js", array( 'jquery-ui-mouse' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-sortable', "/wp-includes/js/jquery/ui/sortable$suffix.js", array( 'jquery-ui-mouse' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-ui-draggable', "/wp-includes/js/jquery/ui/draggable$suffix.js", array( 'jquery-ui-mouse' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-droppable', "/wp-includes/js/jquery/ui/droppable$suffix.js", array( 'jquery-ui-draggable' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-resizable', "/wp-includes/js/jquery/ui/resizable$suffix.js", array( 'jquery-ui-mouse' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-selectable', "/wp-includes/js/jquery/ui/selectable$suffix.js", array( 'jquery-ui-mouse' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-sortable', "/wp-includes/js/jquery/ui/sortable$suffix.js", array( 'jquery-ui-mouse' ), '1.14.2', 1 );
         /*
 …
          * Listed here for back-compat.
          */
         $scripts->add( 'jquery-ui-position', false, array( 'jquery-ui-core' ), '1.13.3', 1 );
         $scripts->add( 'jquery-ui-widget', false, array( 'jquery-ui-core' ), '1.13.3', 1 );
+        $scripts->add( 'jquery-ui-position', false, array( 'jquery-ui-core' ), '1.14.2', 1 );
+        $scripts->add( 'jquery-ui-widget', false, array( 'jquery-ui-core' ), '1.14.2', 1 );
         // Deprecated, not used in core, most functionality is included in jQuery 1.3.

Context Navigation

Legend:

Download in other formats: