enmi-conf.org: comparison wp/wp-admin/js/customize-controls.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-admin/js/customize-controls.js

changeset 16	a86126ab1dd4
parent 9	177826044cd9
child 18	be944660c56a

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
 		 * @augments   wp.customize.Notification
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} code - Code.
-		 * @param {object} params - Params.
+		 * @param {Object} params - Params.
 		 */
 		initialize: function( code, params ) {
 			var notification = this;
 			api.Notification.prototype.initialize.call( notification, code, params );
 			notification.containerClasses += ' notification-overlay';
 		 * Stop propagation on escape key presses, but also dismiss notification if it is dismissible.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {jQuery.Event} event - Event.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		handleEscape: function( event ) {
 			var notification = this;
 			if ( 27 === event.which ) {
 				event.stopPropagation();
 		 * @since 4.9.0
 		 *
 		 * @constructs wp.customize.Notifications
 		 * @augments   wp.customize.Values
 		 *
-		 * @param {object}  options - Options.
+		 * @param {Object}  options - Options.
 		 * @param {jQuery}  [options.container] - Container element for notifications. This can be injected later.
 		 * @param {boolean} [options.alt] - Whether alternative style should be used when rendering notifications.
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function( options ) {
 			var collection = this;
 			api.Values.prototype.initialize.call( collection, options );
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string|wp.customize.Notification} notification - Notification object to add. Alternatively code may be supplied, and in that case the second notificationObject argument must be supplied.
 		 * @param {wp.customize.Notification} [notificationObject] - Notification to add when first argument is the code string.
-		 * @returns {wp.customize.Notification} Added notification (or existing instance if it was already added).
+		 * @return {wp.customize.Notification} Added notification (or existing instance if it was already added).
 		 */
 		add: function( notification, notificationObject ) {
 			var collection = this, code, instance;
 			if ( 'string' === typeof notification ) {
 				code = notification;
 		 * Get list of notifications.
 		 *
 		 * Notifications may be sorted by type followed by added time.
 		 *
 		 * @since 4.9.0
-		 * @param {object}  args - Args.
+		 * @param {Object}  args - Args.
 		 * @param {boolean} [args.sort=false] - Whether to return the notifications sorted.
 		 * @return {Array.<wp.customize.Notification>} Notifications.
 		 */
 		get: function( args ) {
 			var collection = this, notifications, errorTypePriorities, params;
 		/**
 		 * Render notifications area.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		render: function() {
 			var collection = this,
 				notifications, hadOverlayNotification = false, hasOverlayNotification, overlayNotifications = [],
 				previousNotificationsByCode = {},
 		 * Constrain focus on focus container.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {jQuery.Event} event - Event.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		constrainFocus: function constrainFocus( event ) {
 			var collection = this, focusableElements;
 			// Prevent keys from escaping.
 		 *
 		 * @since 3.4.0
 		 *
 		 * @param {string}  id                          - The setting ID.
 		 * @param {*}       value                       - The initial value of the setting.
-		 * @param {object}  [options={}]                - Options.
+		 * @param {Object}  [options={}]                - Options.
 		 * @param {string}  [options.transport=refresh] - The transport to use for previewing. Supports 'refresh' and 'postMessage'.
 		 * @param {boolean} [options.dirty=false]       - Whether the setting should be considered initially dirty.
-		 * @param {object}  [options.previewer]         - The Previewer instance to sync with. Defaults to wp.customize.previewer.
+		 * @param {Object}  [options.previewer]         - The Previewer instance to sync with. Defaults to wp.customize.previewer.
 		 */
 		initialize: function( id, value, options ) {
 			var setting = this, params;
 			params = _.extend(
 				{ previewer: api.previewer },
 		 * previewer.send() call to then fallback to refresh will not work.
 		 *
 		 * @since 3.4.0
 		 * @access public
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		preview: function() {
 			var setting = this, transport;
 			transport = setting.transport;
 		/**
 		 * Find controls associated with this setting.
 		 *
 		 * @since 4.6.0
-		 * @returns {wp.customize.Control[]} Controls associated with setting.
+		 * @return {wp.customize.Control[]} Controls associated with setting.
 		 */
 		findControls: function() {
 			var setting = this, controls = [];
 			api.control.each( function( control ) {
 				_.each( control.settings, function( controlSetting ) {
 	 * @alias wp.customize.dirtyValues
 	 *
 	 * @since 4.7.0
 	 * @access public
 	 *
-	 * @param {object} [options] Options.
+	 * @param {Object} [options] Options.
 	 * @param {boolean} [options.unsaved=false] Whether only values not saved yet into a changeset will be returned (differential changes).
-	 * @returns {object} Dirty setting values.
+	 * @return {Object} Dirty setting values.
 	 */
 	api.dirtyValues = function dirtyValues( options ) {
 		var values = {};
 		api.each( function( setting ) {
 			var settingRevision;
 	 * @alias wp.customize.requestChangesetUpdate
 	 *
 	 * @since 4.7.0
 	 * @access public
 	 *
-	 * @param {object}  [changes] - Mapping of setting IDs to setting params each normally including a value property, or mapping to null.
+	 * @param {Object}  [changes] - Mapping of setting IDs to setting params each normally including a value property, or mapping to null.
 	 *                             If not provided, then the changes will still be obtained from unsaved dirty settings.
-	 * @param {object}  [args] - Additional options for the save request.
+	 * @param {Object}  [args] - Additional options for the save request.
 	 * @param {boolean} [args.autosave=false] - Whether changes will be stored in autosave revision if the changeset has been promoted from an auto-draft.
 	 * @param {boolean} [args.force=false] - Send request to update even when there are no changes to submit. This can be used to request the latest status of the changeset on the server.
 	 * @param {string}  [args.title] - Title to update in the changeset. Optional.
 	 * @param {string}  [args.date] - Date to update in the changeset. Optional.
-	 * @returns {jQuery.Promise} Promise resolving with the response data.
+	 * @return {jQuery.Promise} Promise resolving with the response data.
 	 */
 	api.requestChangesetUpdate = function requestChangesetUpdate( changes, args ) {
 		var deferred, request, submittedChanges = {}, data, submittedArgs;
 		deferred = new $.Deferred();
 		if ( ! submittedArgs.force && _.isEmpty( submittedChanges ) && null === submittedArgs.title && null === submittedArgs.date ) {
 			deferred.resolve( {} );
 			return deferred.promise();
 		}
-		// A status would cause a revision to be made, and for this wp.customize.previewer.save() should be used. Status is also disallowed for revisions regardless.
+		// A status would cause a revision to be made, and for this wp.customize.previewer.save() should be used.
+		// Status is also disallowed for revisions regardless.
 		if ( submittedArgs.status ) {
 			return deferred.reject( { code: 'illegal_status_in_changeset_update' } ).promise();
 		}
 		// Dates not beung allowed for revisions are is a technical limitation of post revisions.
 	 *
 	 * @since 4.1.0
 	 *
 	 * @param {(wp.customize.Panel|wp.customize.Section|wp.customize.Control)} a
 	 * @param {(wp.customize.Panel|wp.customize.Section|wp.customize.Control)} b
-	 * @returns {Number}
+	 * @return {number}
 	 */
 	api.utils.prioritySort = function ( a, b ) {
 		if ( a.priority() === b.priority() && typeof a.params.instanceNumber === 'number' && typeof b.params.instanceNumber === 'number' ) {
 			return a.params.instanceNumber - b.params.instanceNumber;
 		} else {
 	 * @alias wp.customize.utils.isKeydownButNotEnterEvent
 	 *
 	 * @since 4.1.0
 	 *
 	 * @param {jQuery.Event} event
-	 * @returns {boolean}
+	 * @return {boolean}
 	 */
 	api.utils.isKeydownButNotEnterEvent = function ( event ) {
 		return ( 'keydown' === event.type && 13 !== event.which );
 	};
 	 *
 	 * @since 4.1.0
 	 *
 	 * @param {Array|jQuery} listA
 	 * @param {Array|jQuery} listB
-	 * @returns {boolean}
+	 * @return {boolean}
 	 */
 	api.utils.areElementListsEqual = function ( listA, listB ) {
 		var equal = (
-			listA.length === listB.length && // if lists are different lengths, then naturally they are not equal
+			listA.length === listB.length && // If lists are different lengths, then naturally they are not equal.
-			-1 === _.indexOf( _.map( // are there any false values in the list returned by map?
+			-1 === _.indexOf( _.map(         // Are there any false values in the list returned by map?
-				_.zip( listA, listB ), // pair up each element between the two lists
+				_.zip( listA, listB ),       // Pair up each element between the two lists.
 				function ( pair ) {
-					return $( pair[0] ).is( pair[1] ); // compare to see if each pair are equal
+					return $( pair[0] ).is( pair[1] ); // Compare to see if each pair is equal.
 				}
-			), false ) // check for presence of false in map's return value
+			), false ) // Check for presence of false in map's return value.
 		);
 		return equal;
 	};
 	/**
 	 * @alias wp.customize.utils.highlightButton
 	 *
 	 * @since 4.9.0
 	 *
 	 * @param {jQuery} button - The element to highlight.
-	 * @param {object} [options] - Options.
+	 * @param {Object} [options] - Options.
 	 * @param {number} [options.delay=0] - Delay in milliseconds.
 	 * @param {jQuery} [options.focusTarget] - A target for user focus that defaults to the highlighted element.
 	 *                                         If the user focuses the target before the delay passes, the reminder
 	 *                                         is canceled. This option exists to accommodate compound buttons
 	 *                                         containing auxiliary UI, such as the Publish button augmented with a
 	 *                                         Settings button.
-	 * @returns {Function} An idempotent function that cancels the reminder.
+	 * @return {Function} An idempotent function that cancels the reminder.
 	 */
 	api.utils.highlightButton = function highlightButton( button, options ) {
 		var animationClass = 'button-see-me',
 			canceled = false,
 			params;
 	 *
 	 * @alias wp.customize.utils.getCurrentTimestamp
 	 *
 	 * @since 4.9.0
 	 *
-	 * @returns {int} Current timestamp.
+	 * @return {number} Current timestamp.
 	 */
 	api.utils.getCurrentTimestamp = function getCurrentTimestamp() {
 		var currentDate, currentClientTimestamp, timestampDifferential;
 		currentClientTimestamp = _.now();
 		currentDate = new Date( api.settings.initialServerDate.replace( /-/g, '/' ) );
 	 *
 	 * @alias wp.customize.utils.getRemainingTime
 	 *
 	 * @since 4.9.0
 	 *
-	 * @param {string|int|Date} datetime - Date time or timestamp of the future date.
+	 * @param {string|number|Date} datetime - Date time or timestamp of the future date.
-	 * @return {int} remainingTime - Remaining time in milliseconds.
+	 * @return {number} remainingTime - Remaining time in milliseconds.
 	 */
 	api.utils.getRemainingTime = function getRemainingTime( datetime ) {
 		var millisecondsDivider = 1000, remainingTime, timestamp;
 		if ( datetime instanceof Date ) {
 			timestamp = datetime.getTime();
 	 *
 	 * @since 4.7.0
 	 *
 	 * @ignore
 	 *
-	 * @returns {string|null} Normalized `transitionend` event name or null if CSS transitions are not supported.
+	 * @return {string|null} Normalized `transitionend` event name or null if CSS transitions are not supported.
 	 */
 	normalizedTransitionendEventName = (function () {
 		var el, transitions, prop;
 		el = document.createElement( 'div' );
 		transitions = {
 		 * @since 4.1.0
 		 *
 		 * @borrows wp.customize~focus as focus
 		 *
 		 * @param {string}  id - The ID for the container.
-		 * @param {object}  options - Object containing one property: params.
+		 * @param {Object}  options - Object containing one property: params.
 		 * @param {string}  options.title - Title shown when panel is collapsed and expanded.
 		 * @param {string}  [options.description] - Description shown at the top of the panel.
 		 * @param {number}  [options.priority=100] - The sort priority for the panel.
 		 * @param {string}  [options.templateId] - Template selector for container.
 		 * @param {string}  [options.type=default] - The type of the panel. See wp.customize.panelConstructor.
 		 * @param {string}  [options.content] - The markup to be used for the panel container. If empty, a JS template is used.
 		 * @param {boolean} [options.active=true] - Whether the panel is active or not.
-		 * @param {object}  [options.params] - Deprecated wrapper for the above properties.
+		 * @param {Object}  [options.params] - Deprecated wrapper for the above properties.
 		 */
 		initialize: function ( id, options ) {
 			var container = this;
 			container.id = id;
 		/**
 		 * Get the element that will contain the notifications.
 		 *
 		 * @since 4.9.0
-		 * @returns {jQuery} Notification container element.
+		 * @return {jQuery} Notification container element.
 		 */
 		getNotificationsContainerElement: function() {
 			var container = this;
 			return container.contentContainer.find( '.customize-control-notifications-container:first' );
 		},
 		/**
 		 * Set up notifications.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		setupNotifications: function() {
 			var container = this, renderNotifications;
 			container.notifications.container = container.getNotificationsContainerElement();
 		/**
 		 * Get the child models associated with this parent, sorting them by their priority Value.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @param {String} parentType
+		 * @param {string} parentType
-		 * @param {String} childType
+		 * @param {string} childType
-		 * @returns {Array}
+		 * @return {Array}
 		 */
 		_children: function ( parentType, childType ) {
 			var parent = this,
 				children = [];
 			api[ childType ].each( function ( child ) {
 					} );
 				}
 			}
 			if ( ! $.contains( document, headContainer.get( 0 ) ) ) {
-				// If the element is not in the DOM, then jQuery.fn.slideUp() does nothing. In this case, a hard toggle is required instead.
+				// If the element is not in the DOM, then jQuery.fn.slideUp() does nothing.
+				// In this case, a hard toggle is required instead.
 				headContainer.toggle( active );
 				if ( args.completeCallback ) {
 					args.completeCallback();
 				}
 			} else if ( active ) {
 		},
 		/**
 		 * @since 4.1.0
 		 *
-		 * @params {Boolean} active
+		 * @param {boolean} active
-		 * @param {Object}   [params]
+		 * @param {Object}  [params]
-		 * @returns {Boolean} false if state already applied
+		 * @return {boolean} False if state already applied.
 		 */
 		_toggleActive: function ( active, params ) {
 			var self = this;
 			params = params || {};
 			if ( ( active && this.active.get() ) || ( ! active && ! this.active.get() ) ) {
 			}
 		},
 		/**
 		 * @param {Object} [params]
-		 * @returns {Boolean} false if already active
+		 * @return {boolean} False if already active.
 		 */
 		activate: function ( params ) {
 			return this._toggleActive( true, params );
 		},
 		/**
 		 * @param {Object} [params]
-		 * @returns {Boolean} false if already inactive
+		 * @return {boolean} False if already inactive.
 		 */
 		deactivate: function ( params ) {
 			return this._toggleActive( false, params );
 		},
 		},
 		/**
 		 * Handle the toggle logic for expand/collapse.
 		 *
-		 * @param {Boolean}  expanded - The new state to apply.
+		 * @param {boolean}  expanded - The new state to apply.
 		 * @param {Object}   [params] - Object containing options for expand/collapse.
 		 * @param {Function} [params.completeCallback] - Function to call when expansion/collapse is complete.
-		 * @returns {Boolean} false if state already applied or active state is false
+		 * @return {boolean} False if state already applied or active state is false.
 		 */
 		_toggleExpanded: function( expanded, params ) {
 			var instance = this, previousCompleteCallback;
 			params = params || {};
 			previousCompleteCallback = params.completeCallback;
 			}
 		},
 		/**
 		 * @param {Object} [params]
-		 * @returns {Boolean} false if already expanded or if inactive.
+		 * @return {boolean} False if already expanded or if inactive.
 		 */
 		expand: function ( params ) {
 			return this._toggleExpanded( true, params );
 		},
 		/**
 		 * @param {Object} [params]
-		 * @returns {Boolean} false if already collapsed.
+		 * @return {boolean} False if already collapsed.
 		 */
 		collapse: function ( params ) {
 			return this._toggleExpanded( false, params );
 		},
 		 *
 		 * @since 4.7.0
 		 * @private
 		 *
 		 * @param {function} completeCallback Function to be called after transition is completed.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		_animateChangeExpanded: function( completeCallback ) {
 			// Return if CSS transitions are not supported.
 			if ( ! normalizedTransitionendEventName ) {
 				if ( completeCallback ) {
 		 * method to handle animating the panel/section into and out of view.
 		 *
 		 * @since 4.7.0
 		 * @access public
 		 *
-		 * @returns {jQuery} Detached content element.
+		 * @return {jQuery} Detached content element.
 		 */
 		getContent: function() {
 			var construct = this,
 				container = construct.container,
 				content = container.find( '.accordion-section-content, .control-panel-content' ).first(),
 		 * @augments   wp.customize~Container
 		 *
 		 * @since 4.1.0
 		 *
 		 * @param {string}  id - The ID for the section.
-		 * @param {object}  options - Options.
+		 * @param {Object}  options - Options.
 		 * @param {string}  options.title - Title shown when section is collapsed and expanded.
 		 * @param {string}  [options.description] - Description shown at the top of the section.
 		 * @param {number}  [options.priority=100] - The sort priority for the section.
 		 * @param {string}  [options.type=default] - The type of the section. See wp.customize.sectionConstructor.
 		 * @param {string}  [options.content] - The markup to be used for the section container. If empty, a JS template is used.
 		 * @param {boolean} [options.active=true] - Whether the section is active or not.
 		 * @param {string}  options.panel - The ID for the panel this section is associated with.
 		 * @param {string}  [options.customizeAction] - Additional context information shown before the section title when expanded.
-		 * @param {object}  [options.params] - Deprecated wrapper for the above properties.
+		 * @param {Object}  [options.params] - Deprecated wrapper for the above properties.
 		 */
 		initialize: function ( id, options ) {
 			var section = this, params;
 			params = options.params || options;
 							}
 							section.deferred.embedded.resolve();
 						});
 					} );
 				} else {
-					// There is no panel, so embed the section in the root of the customizer
+					// There is no panel, so embed the section in the root of the customizer.
 					parentContainer = api.ensure( section.containerPaneParent );
 					if ( ! section.headContainer.parent().is( parentContainer ) ) {
 						parentContainer.append( section.headContainer );
 					}
 					if ( ! section.contentContainer.parent().is( section.headContainer ) ) {
 			// Expand/Collapse accordion sections on click.
 			section.container.find( '.accordion-section-title, .customize-section-back' ).on( 'click keydown', function( event ) {
 				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 					return;
 				}
-				event.preventDefault(); // Keep this AFTER the key filter above
+				event.preventDefault(); // Keep this AFTER the key filter above.
 				if ( section.expanded() ) {
 					section.collapse();
 				} else {
 					section.expand();
 		/**
 		 * Return whether this section has any active controls.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @returns {Boolean}
+		 * @return {boolean}
 		 */
 		isContextuallyActive: function () {
 			var section = this,
 				controls = section.controls(),
 				activeCount = 0;
 		/**
 		 * Get the controls that are associated with this section, sorted by their priority Value.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @returns {Array}
+		 * @return {Array}
 		 */
 		controls: function () {
 			return this._children( 'section', 'control' );
 		},
 		/**
 		 * Update UI to reflect expanded state.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @param {Boolean} expanded
+		 * @param {boolean} expanded
 		 * @param {Object}  args
 		 */
 		onChangeExpanded: function ( expanded, args ) {
 			var section = this,
 				container = section.headContainer.closest( '.wp-full-overlay-sidebar-content' ),
 		 * @augments   wp.customize.Section
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} id - ID.
-		 * @param {object} options - Options.
+		 * @param {Object} options - Options.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function( id, options ) {
 			var section = this;
 			section.headerContainer = $();
 			section.$window = $( window );
 		 */
 		embed: function() {
 			var inject,
 				section = this;
-			// Watch for changes to the panel state
+			// Watch for changes to the panel state.
 			inject = function( panelId ) {
 				var parentContainer;
 				api.panel( panelId, function( panel ) {
-					// The panel has been registered, wait for it to become ready/initialized
+					// The panel has been registered, wait for it to become ready/initialized.
 					panel.deferred.embedded.done( function() {
 						parentContainer = panel.contentContainer;
 						if ( ! section.headContainer.parent().is( parentContainer ) ) {
 							parentContainer.find( '.customize-themes-full-container-container' ).before( section.headContainer );
 						}
 						section.deferred.embedded.resolve();
 					});
 				} );
 			};
 			section.panel.bind( inject );
-			inject( section.panel.get() ); // Since a section may never get a panel, assume that it won't ever get one
+			inject( section.panel.get() ); // Since a section may never get a panel, assume that it won't ever get one.
 		},
 		/**
 		 * Set up.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function() {
 			var section = this;
 			section.overlay = section.container.find( '.theme-overlay' );
 			section.template = wp.template( 'customize-themes-details-view' );
 			section.container.on( 'keydown', function( event ) {
 				if ( ! section.overlay.find( '.theme-wrap' ).is( ':visible' ) ) {
 					return;
 				}
-				// Pressing the right arrow key fires a theme:next event
+				// Pressing the right arrow key fires a theme:next event.
 				if ( 39 === event.keyCode ) {
 					section.nextTheme();
 				}
-				// Pressing the left arrow key fires a theme:previous event
+				// Pressing the left arrow key fires a theme:previous event.
 				if ( 37 === event.keyCode ) {
 					section.previousTheme();
 				}
-				// Pressing the escape key fires a theme:collapse event
+				// Pressing the escape key fires a theme:collapse event.
 				if ( 27 === event.keyCode ) {
 					if ( section.$body.hasClass( 'modal-open' ) ) {
 						// Escape from the details modal.
 						section.closeDetails();
 		 * use the section's own active state instead. This prevents empty search
 		 * results for theme sections from causing the section to become inactive.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {Boolean}
+		 * @return {boolean}
 		 */
 		isContextuallyActive: function () {
 			return this.active();
 		},
 		/**
 		 * Attach events.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		attachEvents: function () {
 			var section = this, debounced;
 			// Expand/Collapse accordion sections on click.
 			section.container.find( '.customize-section-back' ).on( 'click keydown', function( event ) {
 				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 					return;
 				}
-				event.preventDefault(); // Keep this AFTER the key filter above
+				event.preventDefault(); // Keep this AFTER the key filter above.
 				section.collapse();
 			});
 			section.headerContainer = $( '#accordion-section-' + section.id );
 		/**
 		 * Update UI to reflect expanded state
 		 *
 		 * @since 4.2.0
 		 *
-		 * @param {Boolean}  expanded
+		 * @param {boolean}  expanded
 		 * @param {Object}   args
-		 * @param {Boolean}  args.unchanged
+		 * @param {boolean}  args.unchanged
 		 * @param {Function} args.completeCallback
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onChangeExpanded: function ( expanded, args ) {
-			// Note: there is a second argument 'args' passed
+			// Note: there is a second argument 'args' passed.
 			var section = this,
 				container = section.contentContainer.closest( '.customize-themes-full-container' );
-			// Immediately call the complete callback if there were no changes
+			// Immediately call the complete callback if there were no changes.
 			if ( args.unchanged ) {
 				if ( args.completeCallback ) {
 					args.completeCallback();
 				}
 				return;
 				// Try to load controls if none are loaded yet.
 				if ( 0 === section.loaded ) {
 					section.loadThemes();
 				}
-				// Collapse any sibling sections/panels
+				// Collapse any sibling sections/panels.
 				api.section.each( function ( otherSection ) {
 					var searchTerm;
 					if ( otherSection !== section ) {
 		/**
 		 * Return the section's content element without detaching from the parent.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {jQuery}
+		 * @return {jQuery}
 		 */
 		getContent: function() {
 			return this.container.find( '.control-section-content' );
 		},
 		/**
 		 * Load theme data via Ajax and add themes to the section as controls.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		loadThemes: function() {
 			var section = this, params, page, request;
 			if ( section.loading ) {
 						}
 					}
 					_.delay( section.renderScreenshots, 100 ); // Wait for the controls to become visible.
-					if ( 'local' === section.params.filter_type || 100 > themes.length ) { // If we have less than the requested 100 themes, it's the end of the list.
+					if ( 'local' === section.params.filter_type || 100 > themes.length ) {
+						// If we have less than the requested 100 themes, it's the end of the list.
 						section.fullyLoaded = true;
 					}
 				} else {
 					if ( 0 === section.loaded ) {
 						section.container.find( '.no-themes' ).show();
 		/**
 		 * Loads controls into the section from data received from loadThemes().
 		 *
 		 * @since 4.9.0
-		 * @param {Array} themes - Array of theme data to create controls with.
+		 * @param {Array}  themes - Array of theme data to create controls with.
-		 * @param {integer} page - Page of results being loaded.
+		 * @param {number} page   - Page of results being loaded.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		loadControls: function( themes, page ) {
 			var newThemeControls = [],
 				section = this;
 		/**
 		 * Determines whether more themes should be loaded, and loads them.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		loadMore: function() {
 			var section = this, container, bottom, threshold;
 			if ( ! section.fullyLoaded && ! section.loading ) {
 				container = section.container.closest( '.customize-themes-full-container' );
 				bottom = container.scrollTop() + container.height();
-				threshold = container.prop( 'scrollHeight' ) - 3000; // Use a fixed distance to the bottom of loaded results to avoid unnecessarily loading results sooner when using a percentage of scroll distance.
+				// Use a fixed distance to the bottom of loaded results to avoid unnecessarily
+				// loading results sooner when using a percentage of scroll distance.
+				threshold = container.prop( 'scrollHeight' ) - 3000;
 				if ( bottom > threshold ) {
 					section.loadThemes();
 				}
 			}
 		 * Event handler for search input that filters visible controls.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} term - The raw search input value.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		filterSearch: function( term ) {
 			var count = 0,
 				visible = false,
 				section = this,
 		 * Event handler for search input that determines if the terms have changed and loads new controls as needed.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {wp.customize.ThemesSection} section - The current theme section, passed through the debouncer.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		checkTerm: function( section ) {
 			var newTerm;
 			if ( 'remote' === section.params.filter_type ) {
 				newTerm = section.contentContainer.find( '.wp-filter-search' ).val();
 		/**
 		 * Check for filters checked in the feature filter list and initialize a new query.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		filtersChecked: function() {
 			var section = this,
 			    items = section.container.find( '.filter-group' ).find( ':checkbox' ),
 			    tags = [];
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} newTerm - New term.
 		 * @param {Array} newTags - New tags.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initializeNewQuery: function( newTerm, newTags ) {
 			var section = this;
 			// Clear the controls in the section.
 		/**
 		 * Render control's screenshot if the control comes into view.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		renderScreenshots: function() {
 			var section = this;
 			// Fill queue initially, or check for more if empty.
 		/**
 		 * Get visible count.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {int} Visible count.
+		 * @return {number} Visible count.
 		 */
 		getVisibleCount: function() {
 			return this.contentContainer.find( 'li.customize-control:visible' ).length;
 		},
 		/**
 		 * Update the number of themes in the section.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		updateCount: function( count ) {
 			var section = this, countEl, displayed;
 			if ( ! count && 0 !== count ) {
 		/**
 		 * Advance the modal to the next theme.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		nextTheme: function () {
 			var section = this;
 			if ( section.getNextTheme() ) {
 				section.showDetails( section.getNextTheme(), function() {
 		/**
 		 * Get the next theme model.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {wp.customize.ThemeControl|boolean} Next theme.
+		 * @return {wp.customize.ThemeControl|boolean} Next theme.
 		 */
 		getNextTheme: function () {
 			var section = this, control, nextControl, sectionControls, i;
 			control = api.control( section.params.action + '_theme_' + section.currentTheme );
 			sectionControls = section.controls();
 		/**
 		 * Advance the modal to the previous theme.
 		 *
 		 * @since 4.2.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		previousTheme: function () {
 			var section = this;
 			if ( section.getPreviousTheme() ) {
 				section.showDetails( section.getPreviousTheme(), function() {
 		/**
 		 * Get the previous theme model.
 		 *
 		 * @since 4.2.0
-		 * @returns {wp.customize.ThemeControl|boolean} Previous theme.
+		 * @return {wp.customize.ThemeControl|boolean} Previous theme.
 		 */
 		getPreviousTheme: function () {
 			var section = this, control, nextControl, sectionControls, i;
 			control = api.control( section.params.action + '_theme_' + section.currentTheme );
 			sectionControls = section.controls();
 		/**
 		 * Disable buttons when we're viewing the first or last theme.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		updateLimits: function () {
 			if ( ! this.getNextTheme() ) {
 				this.overlay.find( '.right' ).addClass( 'disabled' );
 			}
 		 * @since 4.7.0
 		 * @access public
 		 *
 		 * @deprecated
 		 * @param {string} themeId Theme ID.
-		 * @returns {jQuery.promise} Promise.
+		 * @return {jQuery.promise} Promise.
 		 */
 		loadThemePreview: function( themeId ) {
 			return api.ThemesPanel.prototype.loadThemePreview.call( this, themeId );
 		},
 		/**
 		 * Render & show the theme details for a given theme model.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @param {object} theme - Theme.
+		 * @param {Object} theme - Theme.
 		 * @param {Function} [callback] - Callback once the details have been shown.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		showDetails: function ( theme, callback ) {
 			var section = this, panel = api.panel( 'themes' );
 			section.currentTheme = theme.id;
 			section.overlay.html( section.template( theme ) )
 		/**
 		 * Close the theme details modal.
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		closeDetails: function () {
 			var section = this;
 			section.$body.removeClass( 'modal-open' );
 			section.overlay.fadeOut( 'fast' );
 		 * Keep tab focus within the theme details modal.
 		 *
 		 * @since 4.2.0
 		 *
 		 * @param {jQuery} el - Element to contain focus.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		containFocus: function( el ) {
 			var tabbables;
 			el.on( 'keydown', function( event ) {
 				// Return if it's not the tab key
-				// When navigating with prev/next focus is already handled
+				// When navigating with prev/next focus is already handled.
 				if ( 9 !== event.keyCode ) {
 					return;
 				}
-				// uses jQuery UI to get the tabbable elements
+				// Uses jQuery UI to get the tabbable elements.
 				tabbables = $( ':tabbable', el );
-				// Keep focus within the overlay
+				// Keep focus within the overlay.
 				if ( tabbables.last()[0] === event.target && ! event.shiftKey ) {
 					tabbables.first().focus();
 					return false;
 				} else if ( tabbables.first()[0] === event.target && event.shiftKey ) {
 					tabbables.last().focus();
 		 * @constructs wp.customize.OuterSection
 		 * @augments   wp.customize.Section
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function() {
 			var section = this;
 			section.containerParent = '#customize-outer-theme-controls';
 			section.containerPaneParent = '.customize-outer-pane-parent';
 		 * Overrides api.Section.prototype.onChangeExpanded to prevent collapse/expand effect
 		 * on other sections and panels.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @param {Boolean}  expanded - The expanded state to transition to.
+		 * @param {boolean}  expanded - The expanded state to transition to.
 		 * @param {Object}   [args] - Args.
 		 * @param {boolean}  [args.unchanged] - Whether the state is already known to not be changed, and so short-circuit with calling completeCallback early.
 		 * @param {Function} [args.completeCallback] - Function to call when the slideUp/slideDown has completed.
 		 * @param {Object}   [args.duration] - The duration for the animation.
 		 */
 		 * @augments   wp.customize~Container
 		 *
 		 * @since 4.1.0
 		 *
 		 * @param {string}  id - The ID for the panel.
-		 * @param {object}  options - Object containing one property: params.
+		 * @param {Object}  options - Object containing one property: params.
 		 * @param {string}  options.title - Title shown when panel is collapsed and expanded.
 		 * @param {string}  [options.description] - Description shown at the top of the panel.
 		 * @param {number}  [options.priority=100] - The sort priority for the panel.
 		 * @param {string}  [options.type=default] - The type of the panel. See wp.customize.panelConstructor.
 		 * @param {string}  [options.content] - The markup to be used for the panel container. If empty, a JS template is used.
 		 * @param {boolean} [options.active=true] - Whether the panel is active or not.
-		 * @param {object}  [options.params] - Deprecated wrapper for the above properties.
+		 * @param {Object}  [options.params] - Deprecated wrapper for the above properties.
 		 */
 		initialize: function ( id, options ) {
 			var panel = this, params;
 			params = options.params || options;
 		 * @since 4.1.0
 		 */
 		embed: function () {
 			var panel = this,
 				container = $( '#customize-theme-controls' ),
-				parentContainer = $( '.customize-pane-parent' ); // @todo This should be defined elsewhere, and to be configurable
+				parentContainer = $( '.customize-pane-parent' ); // @todo This should be defined elsewhere, and to be configurable.
 			if ( ! panel.headContainer.parent().is( parentContainer ) ) {
 				parentContainer.append( panel.headContainer );
 			}
 			if ( ! panel.contentContainer.parent().is( panel.headContainer ) ) {
 			// Expand/Collapse accordion sections on click.
 			panel.headContainer.find( '.accordion-section-title' ).on( 'click keydown', function( event ) {
 				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 					return;
 				}
-				event.preventDefault(); // Keep this AFTER the key filter above
+				event.preventDefault(); // Keep this AFTER the key filter above.
 				if ( ! panel.expanded() ) {
 					panel.expand();
 				}
 			});
 			// Close panel.
 			panel.container.find( '.customize-panel-back' ).on( 'click keydown', function( event ) {
 				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 					return;
 				}
-				event.preventDefault(); // Keep this AFTER the key filter above
+				event.preventDefault(); // Keep this AFTER the key filter above.
 				if ( panel.expanded() ) {
 					panel.collapse();
 				}
 			});
 		/**
 		 * Get the sections that are associated with this panel, sorted by their priority Value.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @returns {Array}
+		 * @return {Array}
 		 */
 		sections: function () {
 			return this._children( 'panel', 'section' );
 		},
 		/**
 		 * Return whether this panel has any active sections.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @returns {boolean} Whether contextually active.
+		 * @return {boolean} Whether contextually active.
 		 */
 		isContextuallyActive: function () {
 			var panel = this,
 				sections = panel.sections(),
 				activeCount = 0;
 		/**
 		 * Update UI to reflect expanded state.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @param {Boolean}  expanded
+		 * @param {boolean}  expanded
 		 * @param {Object}   args
-		 * @param {Boolean}  args.unchanged
+		 * @param {boolean}  args.unchanged
 		 * @param {Function} args.completeCallback
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onChangeExpanded: function ( expanded, args ) {
-			// Immediately call the complete callback if there were no changes
+			// Immediately call the complete callback if there were no changes.
 			if ( args.unchanged ) {
 				if ( args.completeCallback ) {
 					args.completeCallback();
 				}
 				return;
 			}
-			// Note: there is a second argument 'args' passed
+			// Note: there is a second argument 'args' passed.
 			var panel = this,
 				accordionSection = panel.contentContainer,
 				overlay = accordionSection.closest( '.wp-full-overlay' ),
 				container = accordionSection.closest( '.wp-full-overlay-sidebar-content' ),
 				topPanel = panel.headContainer.find( '.accordion-section-title' ),
 				backBtn = accordionSection.find( '.customize-panel-back' ),
 				childSections = panel.sections(),
 				skipTransition;
 			if ( expanded && ! accordionSection.hasClass( 'current-panel' ) ) {
-				// Collapse any sibling sections/panels
+				// Collapse any sibling sections/panels.
 				api.section.each( function ( section ) {
 					if ( panel.id !== section.panel() ) {
 						section.collapse( { duration: 0 } );
 					}
 				});
 		 * @augments   wp.customize.Panel
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} id - The ID for the panel.
-		 * @param {object} options - Options.
+		 * @param {Object} options - Options.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function( id, options ) {
 			var panel = this;
 			panel.installingThemes = [];
 			api.Panel.prototype.initialize.call( panel, id, options );
 		 * Determine whether a given theme can be switched to, or in general.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} [slug] - Theme slug.
-		 * @returns {boolean} Whether the theme can be switched to.
+		 * @return {boolean} Whether the theme can be switched to.
 		 */
 		canSwitchTheme: function canSwitchTheme( slug ) {
 			if ( slug && slug === api.settings.theme.stylesheet ) {
 				return true;
 			}
 		/**
 		 * Attach events.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		attachEvents: function() {
 			var panel = this;
 			// Attach regular panel events.
 			api.Panel.prototype.attachEvents.apply( panel );
-			// Temporary since supplying SFTP credentials does not work yet. See #42184
+			// Temporary since supplying SFTP credentials does not work yet. See #42184.
 			if ( api.settings.theme._canInstall && api.settings.theme._filesystemCredentialsNeeded ) {
 				panel.notifications.add( new api.Notification( 'theme_install_unavailable', {
 					message: api.l10n.themeInstallUnavailable,
 					type: 'info',
 					dismissible: true
 		/**
 		 * Update UI to reflect expanded state
 		 *
 		 * @since 4.9.0
 		 *
-		 * @param {Boolean}  expanded - Expanded state.
+		 * @param {boolean}  expanded - Expanded state.
 		 * @param {Object}   args - Args.
-		 * @param {Boolean}  args.unchanged - Whether or not the state changed.
+		 * @param {boolean}  args.unchanged - Whether or not the state changed.
 		 * @param {Function} args.completeCallback - Callback to execute when the animation completes.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onChangeExpanded: function( expanded, args ) {
 			var panel = this, overlay, sections, hasExpandedSection = false;
 			// Expand/collapse the panel normally.
 			api.Panel.prototype.onChangeExpanded.apply( this, [ expanded, args ] );
-			// Immediately call the complete callback if there were no changes
+			// Immediately call the complete callback if there were no changes.
 			if ( args.unchanged ) {
 				if ( args.completeCallback ) {
 					args.completeCallback();
 				}
 				return;
 		 * Install a theme via wp.updates.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {jQuery.Event} event - Event.
-		 * @returns {jQuery.promise} Promise.
+		 * @return {jQuery.promise} Promise.
 		 */
 		installTheme: function( event ) {
 			var panel = this, preview, onInstallSuccess, slug = $( event.target ).data( 'slug' ), deferred = $.Deferred(), request;
 			preview = $( event.target ).hasClass( 'preview' );
 		 * Load theme preview.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} themeId Theme ID.
-		 * @returns {jQuery.promise} Promise.
+		 * @return {jQuery.promise} Promise.
 		 */
 		loadThemePreview: function( themeId ) {
 			var panel = this, deferred = $.Deferred(), onceProcessingComplete, urlParser, queryParams;
 			// Prevent loading a non-active theme preview when there is a drafted/scheduled changeset.
 		 * Update a theme via wp.updates.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {jQuery.Event} event - Event.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		updateTheme: function( event ) {
 			wp.updates.maybeRequestFilesystemCredentials( event );
 			$( document ).one( 'wp-theme-update-success', function( e, response ) {
 		 * Delete a theme via wp.updates.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {jQuery.Event} event - Event.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		deleteTheme: function( event ) {
 			var theme, section;
 			theme = $( event.target ).data( 'slug' );
 			section = api.section( 'installed_themes' );
 		 * @borrows wp.customize~Container#activate as this#activate
 		 * @borrows wp.customize~Container#deactivate as this#deactivate
 		 * @borrows wp.customize~Container#_toggleActive as this#_toggleActive
 		 *
 		 * @param {string} id                       - Unique identifier for the control instance.
-		 * @param {object} options                  - Options hash for the control instance.
+		 * @param {Object} options                  - Options hash for the control instance.
-		 * @param {object} options.type             - Type of control (e.g. text, radio, dropdown-pages, etc.)
+		 * @param {Object} options.type             - Type of control (e.g. text, radio, dropdown-pages, etc.)
 		 * @param {string} [options.content]        - The HTML content for the control or at least its container. This should normally be left blank and instead supplying a templateId.
 		 * @param {string} [options.templateId]     - Template ID for control's content.
 		 * @param {string} [options.priority=10]    - Order of priority to show the control within the section.
 		 * @param {string} [options.active=true]    - Whether the control is active.
 		 * @param {string} options.section          - The ID of the section the control belongs to.
 		 * @param {mixed}  options.settings.default - The ID of the setting the control relates to.
 		 * @param {string} options.settings.data    - @todo Is this used?
 		 * @param {string} options.label            - Label.
 		 * @param {string} options.description      - Description.
 		 * @param {number} [options.instanceNumber] - Order in which this instance was created in relation to other instances.
-		 * @param {object} [options.params]         - Deprecated wrapper for the above properties.
+		 * @param {Object} [options.params]         - Deprecated wrapper for the above properties.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function( id, options ) {
 			var control = this, deferredSettingIds = [], settings, gatherSettings;
 			control.params = _.extend(
 				{},
 				control.defaults,
-				control.params || {}, // In case sub-class already defines.
+				control.params || {}, // In case subclass already defines.
 				options.params || options || {} // The options.params property is deprecated, but it is checked first for back-compat.
 			);
 			if ( ! api.Control.instanceCounter ) {
 				api.Control.instanceCounter = 0;
 		 * Link elements between settings and inputs.
 		 *
 		 * @since 4.7.0
 		 * @access public
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		linkElements: function () {
 			var control = this, nodes, radios, element;
 			nodes = control.container.find( '[data-customize-setting-link], [data-customize-setting-key-link]' );
 		 */
 		embed: function () {
 			var control = this,
 				inject;
-			// Watch for changes to the section state
+			// Watch for changes to the section state.
 			inject = function ( sectionId ) {
 				var parentContainer;
-				if ( ! sectionId ) { // @todo allow a control to be embedded without a section, for instance a control embedded in the front end.
+				if ( ! sectionId ) { // @todo Allow a control to be embedded without a section, for instance a control embedded in the front end.
 					return;
 				}
-				// Wait for the section to be registered
+				// Wait for the section to be registered.
 				api.section( sectionId, function ( section ) {
-					// Wait for the section to be ready/initialized
+					// Wait for the section to be ready/initialized.
 					section.deferred.embedded.done( function () {
 						parentContainer = ( section.contentContainer.is( 'ul' ) ) ? section.contentContainer : section.contentContainer.find( 'ul:first' );
 						if ( ! control.container.parent().is( parentContainer ) ) {
 							parentContainer.append( control.container );
 							control.renderContent();
 		},
 		/**
 		 * Triggered when the control's markup has been injected into the DOM.
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function() {
 			var control = this, newItem;
 			if ( 'dropdown-pages' === control.params.type && control.params.allow_addition ) {
 				newItem = control.container.find( '.new-content-item' );
 				});
 				control.container.on( 'click', '.add-content', function() {
 					control.addNewPage();
 				});
 				control.container.on( 'keydown', '.create-item-input', function( e ) {
-					if ( 13 === e.which ) { // Enter
+					if ( 13 === e.which ) { // Enter.
 						control.addNewPage();
 					}
 				});
 			}
 		},
 		 * Control subclasses may override this to return the proper container to render notifications into.
 		 * Injects the notification container for existing controls that lack the necessary container,
 		 * including special handling for nav menu items and widgets.
 		 *
 		 * @since 4.6.0
-		 * @returns {jQuery} Setting validation message element.
+		 * @return {jQuery} Setting validation message element.
 		 */
 		getNotificationsContainerElement: function() {
 			var control = this, controlTitle, notificationsContainer;
 			notificationsContainer = control.container.find( '.customize-control-notifications-container:first' );
 		/**
 		 * Set up notifications.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		setupNotifications: function() {
 			var control = this, renderNotificationsIfVisible, onSectionAssigned;
 			// Add setting notifications to the control notification.
 		 * This does not change the active state, it merely handles the behavior
 		 * for when it does change.
 		 *
 		 * @since 4.1.0
 		 *
-		 * @param {Boolean}  active
+		 * @param {boolean}  active
 		 * @param {Object}   args
-		 * @param {Number}   args.duration
+		 * @param {number}   args.duration
 		 * @param {Function} args.completeCallback
 		 */
 		onChangeActive: function ( active, args ) {
 			if ( args.unchanged ) {
 				if ( args.completeCallback ) {
 				}
 				return;
 			}
 			if ( ! $.contains( document, this.container[0] ) ) {
-				// jQuery.fn.slideUp is not hiding an element if it is not in the DOM
+				// jQuery.fn.slideUp is not hiding an element if it is not in the DOM.
 				this.container.toggle( active );
 				if ( args.completeCallback ) {
 					args.completeCallback();
 				}
 			} else if ( active ) {
 					} else {
 						statuses.hide();
 					}
 				};
-			// Support the .dropdown class to open/close complex elements
+			// Support the .dropdown class to open/close complex elements.
 			this.container.on( 'click keydown', '.dropdown', function( event ) {
 				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 					return;
 				}
 				if ( control.container.hasClass( 'open' ) ) {
 					control.container.parent().parent().find( 'li.library-selected' ).focus();
 				}
-				// Don't want to fire focus and click at same time
+				// Don't want to fire focus and click at same time.
 				toggleFreeze = true;
 				setTimeout(function () {
 					toggleFreeze = false;
 				}, 400);
 			});
 				'url'
 			];
 			templateId = control.templateSelector;
-			// Use default content template when a standard HTML type is used, there isn't a more specific template existing, and the control container is empty.
+			// Use default content template when a standard HTML type is used,
+			// there isn't a more specific template existing, and the control container is empty.
 			if ( templateId === 'customize-control-' + control.params.type + '-content' &&
 				_.contains( standardTypes, control.params.type ) &&
 				! document.getElementById( 'tmpl-' + templateId ) &&
 				0 === control.container.children().length )
 			{
 		/**
 		 * Add a new page to a dropdown-pages control reusing menus code for this.
 		 *
 		 * @since 4.7.0
 		 * @access private
-		 * @returns {void}
+		 *
+		 * @return {void}
 		 */
 		addNewPage: function () {
 			var control = this, promise, toggle, container, input, title, select;
 			if ( 'dropdown-pages' !== control.params.type || ! control.params.allow_addition || ! api.Menus ) {
 			}
 			input.removeClass( 'invalid' );
 			input.attr( 'disabled', 'disabled' );
-			// The menus functions add the page, publish when appropriate, and also add the new page to the dropdown-pages controls.
+			// The menus functions add the page, publish when appropriate,
+			// and also add the new page to the dropdown-pages controls.
 			promise = api.Menus.insertAutoDraftPost( {
 				post_title: title,
 				post_type: 'page'
 			} );
 			promise.done( function( data ) {
 			control.container.on( 'click keydown', '.default-button', control.restoreDefault );
 			control.container.on( 'click keydown', '.remove-button', control.pausePlayer );
 			control.container.on( 'click keydown', '.remove-button', control.removeFile );
 			control.container.on( 'click keydown', '.remove-button', control.cleanupPlayer );
-			// Resize the player controls when it becomes visible (ie when section is expanded)
+			// Resize the player controls when it becomes visible (ie when section is expanded).
 			api.section( control.section() ).container
 				.on( 'expanded', function() {
 					if ( control.player ) {
 						control.player.setControlsSize();
 					}
 		},
 		/**
 		 * Called when the "Remove" link is clicked. Empties the setting.
 		 *
-		 * @param {object} event jQuery Event object
+		 * @param {Object} event jQuery Event object
 		 */
 		removeFile: function( event ) {
 			if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 				return;
 			}
 			api.UploadControl.prototype.ready.apply( this, arguments );
 		},
 		/**
 		 * Callback handler for when an attachment is selected in the media modal.
-		 * Does an additional AJAX request for setting the background context.
+		 * Does an additional Ajax request for setting the background context.
 		 */
 		select: function() {
 			api.UploadControl.prototype.select.apply( this, arguments );
 			wp.ajax.post( 'custom-background-add', {
 		},
 		/**
 		 * After the image has been cropped, apply the cropped image data to the setting.
 		 *
-		 * @param {object} croppedImage Cropped attachment data.
+		 * @param {Object} croppedImage Cropped attachment data.
 		 */
 		onCropped: function( croppedImage ) {
 			this.setImageFromAttachment( croppedImage );
 		},
 		 * control-specific data, to be fed to the imgAreaSelect plugin in
 		 * wp.media.view.Cropper.
 		 *
 		 * @param {wp.media.model.Attachment} attachment
 		 * @param {wp.media.controller.Cropper} controller
-		 * @returns {Object} Options
+		 * @return {Object} Options
 		 */
 		calculateImageSelectOptions: function( attachment, controller ) {
 			var control    = controller.get( 'control' ),
 				flexWidth  = !! parseInt( control.params.flex_width, 10 ),
 				flexHeight = !! parseInt( control.params.flex_height, 10 ),
 		},
 		/**
 		 * Return whether the image must be cropped, based on required dimensions.
 		 *
-		 * @param {bool} flexW
+		 * @param {boolean} flexW
-		 * @param {bool} flexH
+		 * @param {boolean} flexH
-		 * @param {int}  dstW
+		 * @param {number}  dstW
-		 * @param {int}  dstH
+		 * @param {number}  dstH
-		 * @param {int}  imgW
+		 * @param {number}  imgW
-		 * @param {int}  imgH
+		 * @param {number}  imgH
-		 * @return {bool}
+		 * @return {boolean}
 		 */
 		mustBeCropped: function( flexW, flexH, dstW, dstH, imgW, imgH ) {
 			if ( true === flexW && true === flexH ) {
 				return false;
 			}
 		},
 		/**
 		 * Updates the setting and re-renders the control UI.
 		 *
-		 * @param {object} attachment
+		 * @param {Object} attachment
 		 */
 		setImageFromAttachment: function( attachment ) {
 			this.params.attachment = attachment;
 			// Set the Customizer setting; the callback takes care of rendering.
 		},
 		/**
 		 * Updates the setting and re-renders the control UI.
 		 *
-		 * @param {object} attachment
+		 * @param {Object} attachment
 		 */
 		setImageFromAttachment: function( attachment ) {
 			var sizes = [ 'site_icon-32', 'thumbnail', 'full' ], link,
 				icon;
 		},
 		/**
 		 * Called when the "Remove" link is clicked. Empties the setting.
 		 *
-		 * @param {object} event jQuery Event object
+		 * @param {Object} event jQuery Event object
 		 */
 		removeFile: function( event ) {
 			if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
 				return;
 			}
 		 * Returns a new instance of api.HeaderTool.ImageModel based on the currently
 		 * saved header image (if any).
 		 *
 		 * @since 4.2.0
 		 *
-		 * @returns {Object} Options
+		 * @return {Object} Options
 		 */
 		getInitialHeaderImage: function() {
 			if ( ! api.get().header_image || ! api.get().header_image_data || _.contains( [ 'remove-header', 'random-default-image', 'random-uploaded-image' ], api.get().header_image ) ) {
 				return new api.HeaderTool.ImageModel();
 			}
 		 * theme-specific data, to be fed to the imgAreaSelect plugin in
 		 * wp.media.view.Cropper.
 		 *
 		 * @param {wp.media.model.Attachment} attachment
 		 * @param {wp.media.controller.Cropper} controller
-		 * @returns {Object} Options
+		 * @return {Object} Options
 		 */
 		calculateImageSelectOptions: function(attachment, controller) {
 			var xInit = parseInt(_wpCustomizeHeader.data.width, 10),
 				yInit = parseInt(_wpCustomizeHeader.data.height, 10),
 				flexWidth = !! parseInt(_wpCustomizeHeader.data['flex-width'], 10),
 		},
 		/**
 		 * After the image has been cropped, apply the cropped image data to the setting.
 		 *
-		 * @param {object} croppedImage Cropped attachment data.
+		 * @param {Object} croppedImage Cropped attachment data.
 		 */
 		onCropped: function(croppedImage) {
 			var url = croppedImage.url,
 				attachmentId = croppedImage.attachment_id,
 				w = croppedImage.width,
 		},
 		/**
 		 * If cropping was skipped, apply the image data directly to the setting.
 		 *
-		 * @param {object} selection
+		 * @param {Object} selection
 		 */
 		onSkippedCrop: function(selection) {
 			var url = selection.get('url'),
 				w = selection.get('width'),
 				h = selection.get('height');
 		/**
 		 * Creates a new wp.customize.HeaderTool.ImageModel from provided
 		 * header image data and inserts it into the user-uploaded headers
 		 * collection.
 		 *
-		 * @param {String} url
+		 * @param {string} url
-		 * @param {Number} attachmentId
+		 * @param {number} attachmentId
-		 * @param {Number} width
+		 * @param {number} width
-		 * @param {Number} height
+		 * @param {number} height
 		 */
 		setImageFromURL: function(url, attachmentId, width, height) {
 			var choice, data = {};
 			data.url = url;
 				// Prevent the modal from showing when the user clicks the action button.
 				if ( $( event.target ).is( '.theme-actions .button, .update-theme' ) ) {
 					return;
 				}
-				event.preventDefault(); // Keep this AFTER the key filter above
+				event.preventDefault(); // Keep this AFTER the key filter above.
 				section = api.section( control.section() );
 				section.showDetails( control.params.theme, function() {
 					// Temporary special function since supplying SFTP credentials does not work yet. See #42184.
 					if ( api.settings.theme._filesystemCredentialsNeeded ) {
 		/**
 		 * Show or hide the theme based on the presence of the term in the title, description, tags, and author.
 		 *
 		 * @since 4.2.0
 		 * @param {Array} terms - An array of terms to search for.
-		 * @returns {boolean} Whether a theme control was activated or not.
+		 * @return {boolean} Whether a theme control was activated or not.
 		 */
 		filter: function( terms ) {
 			var control = this,
 				matchCount = 0,
 				haystack = control.params.theme.name + ' ' +
 			if ( 0 !== matchCount ) {
 				control.activate();
 				control.params.priority = 101 - matchCount; // Sort results by match count.
 				return true;
 			} else {
-				control.deactivate(); // Hide control
+				control.deactivate(); // Hide control.
 				control.params.priority = 101;
 				return false;
 			}
 		},
 		/**
 		 * Rerender the theme from its JS template with the installed type.
 		 *
 		 * @since 4.9.0
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		rerenderAsInstalled: function( installed ) {
 			var control = this, section;
 			if ( installed ) {
 				control.params.theme.type = 'installed';
 		/**
 		 * Initialize.
 		 *
 		 * @since 4.9.0
 		 * @param {string} id      - Unique identifier for the control instance.
-		 * @param {object} options - Options hash for the control instance.
+		 * @param {Object} options - Options hash for the control instance.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initialize: function( id, options ) {
 			var control = this;
 			control.deferred = _.extend( control.deferred || {}, {
 				codemirror: $.Deferred()
 		/**
 		 * Initialize the editor when the containing section is ready and expanded.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function() {
 			var control = this;
 			if ( ! control.section() ) {
 				control.initEditor();
 		/**
 		 * Initialize editor.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initEditor: function() {
 			var control = this, element, editorSettings = false;
 			// Obtain editorSettings for instantiation.
 		 * Make sure editor gets focused when control is focused.
 		 *
 		 * @since 4.9.0
 		 * @param {Object}   [params] - Focus params.
 		 * @param {Function} [params.completeCallback] - Function to call when expansion is complete.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		focus: function( params ) {
 			var control = this, extendedParams = _.extend( {}, params ), originalCompleteCallback;
 			originalCompleteCallback = extendedParams.completeCallback;
 			extendedParams.completeCallback = function() {
 		/**
 		 * Initialize syntax-highlighting editor.
 		 *
 		 * @since 4.9.0
-		 * @param {object} codeEditorSettings - Code editor settings.
+		 * @param {Object} codeEditorSettings - Code editor settings.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initSyntaxHighlightingEditor: function( codeEditorSettings ) {
 			var control = this, $textarea = control.container.find( 'textarea' ), settings, suspendEditorUpdate = false;
 			settings = _.extend( {}, codeEditorSettings, {
 		/**
 		 * Handle tabbing to the field after the editor.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onTabNext: function onTabNext() {
 			var control = this, controls, controlIndex, section;
 			section = api.section( control.section() );
 			controls = section.controls();
 		/**
 		 * Handle tabbing to the field before the editor.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onTabPrevious: function onTabPrevious() {
 			var control = this, controls, controlIndex, section;
 			section = api.section( control.section() );
 			controls = section.controls();
 		/**
 		 * Update error notice.
 		 *
 		 * @since 4.9.0
 		 * @param {Array} errorAnnotations - Error annotations.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		onUpdateErrorNotice: function onUpdateErrorNotice( errorAnnotations ) {
 			var control = this, message;
 			control.setting.notifications.remove( 'csslint_error' );
 		/**
 		 * Initialize plain-textarea editor when syntax highlighting is disabled.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		initPlainTextareaEditor: function() {
 			var control = this, $textarea = control.container.find( 'textarea' ), textarea = $textarea[0];
 			$textarea.on( 'blur', function onBlur() {
 		/**
 		 * Initialize behaviors.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function ready() {
 			var control = this;
 			control.inputElements = {};
 		 * Parse datetime string.
 		 *
 		 * @since 4.9.0
 		 *
 		 * @param {string} datetime - Date/Time string. Accepts Y-m-d[ H:i[:s]] format.
-		 * @returns {object|null} Returns object containing date components or null if parse error.
+		 * @return {Object|null} Returns object containing date components or null if parse error.
 		 */
 		parseDateTime: function parseDateTime( datetime ) {
 			var control = this, matches, date, midDayHour = 12;
 			if ( datetime ) {
 		/**
 		 * Populate setting value from the inputs.
 		 *
 		 * @since 4.9.0
-		 * @returns {boolean} If setting updated.
+		 * @return {boolean} If setting updated.
 		 */
 		populateSetting: function populateSetting() {
 			var control = this, date;
 			if ( control.validateInputs() || ! control.params.allowPastDate && ! control.isFutureDate() ) {
 		/**
 		 * Check if the date is in the future.
 		 *
 		 * @since 4.9.0
-		 * @returns {boolean} True if future date.
+		 * @return {boolean} True if future date.
 		 */
 		isFutureDate: function isFutureDate() {
 			var control = this;
 			return 0 < api.utils.getRemainingTime( control.convertInputDateToString() );
 		},
 		 * Convert hour in twelve hour format to twenty four hour format.
 		 *
 		 * @since 4.9.0
 		 * @param {string} hourInTwelveHourFormat - Hour in twelve hour format.
 		 * @param {string} meridian - Either 'am' or 'pm'.
-		 * @returns {string} Hour in twenty four hour format.
+		 * @return {string} Hour in twenty four hour format.
 		 */
 		convertHourToTwentyFourHourFormat: function convertHour( hourInTwelveHourFormat, meridian ) {
 			var hourInTwentyFourHourFormat, hour, midDayHour = 12;
 			hour = parseInt( hourInTwelveHourFormat, 10 );
 		/**
 		 * Populates date inputs in date fields.
 		 *
 		 * @since 4.9.0
-		 * @returns {boolean} Whether the inputs were populated.
+		 * @return {boolean} Whether the inputs were populated.
 		 */
 		populateDateInputs: function populateDateInputs() {
 			var control = this, parsed;
 			parsed = control.parseDateTime( control.setting.get() );
 		/**
 		 * Initialize behaviors.
 		 *
 		 * @since 4.9.0
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function ready() {
 			var control = this, element, component, node, url, input, button;
 			_.bindAll( control, 'updatePreviewLink' );
 	 * @since 3.4.0
 	 *
 	 * @type {Function}
 	 * @param {...string} ids - One or more ids for controls to obtain.
 	 * @param {deferredControlsCallback} [callback] - Function called when all supplied controls exist.
-	 * @returns {wp.customize.Control|undefined|jQuery.promise} Control instance or undefined (if function called with one id param), or promise resolving to requested controls.
+	 * @return {wp.customize.Control|undefined|jQuery.promise} Control instance or undefined (if function called with one id param),
+	 *                                                         or promise resolving to requested controls.
 	 *
 	 * @example <caption>Loop over all registered controls.</caption>
 	 * wp.customize.control.each( function( control ) { ... } );
 	 *
 	 * @example <caption>Getting `background_color` control instance.</caption>
 	 * @since 3.4.0
 	 *
 	 * @type {Function}
 	 * @param {...string} ids - One or more ids for sections to obtain.
 	 * @param {deferredSectionsCallback} [callback] - Function called when all supplied sections exist.
-	 * @returns {wp.customize.Section|undefined|jQuery.promise} Section instance or undefined (if function called with one id param), or promise resolving to requested sections.
+	 * @return {wp.customize.Section|undefined|jQuery.promise} Section instance or undefined (if function called with one id param),
+	 *                                                         or promise resolving to requested sections.
 	 *
 	 * @example <caption>Loop over all registered sections.</caption>
 	 * wp.customize.section.each( function( section ) { ... } )
 	 *
 	 * @example <caption>Getting `title_tagline` section instance.</caption>
 	 * @since 4.0.0
 	 *
 	 * @type {Function}
 	 * @param {...string} ids - One or more ids for panels to obtain.
 	 * @param {deferredPanelsCallback} [callback] - Function called when all supplied panels exist.
-	 * @returns {wp.customize.Panel|undefined|jQuery.promise} Panel instance or undefined (if function called with one id param), or promise resolving to requested panels.
+	 * @return {wp.customize.Panel|undefined|jQuery.promise} Panel instance or undefined (if function called with one id param),
+	 *                                                       or promise resolving to requested panels.
 	 *
 	 * @example <caption>Loop over all registered panels.</caption>
 	 * wp.customize.panel.each( function( panel ) { ... } )
 	 *
 	 * @example <caption>Getting nav_menus panel instance.</caption>
 	 * @since 4.9.0
 	 *
 	 * @type {Function}
 	 * @param {...string} codes - One or more codes for notifications to obtain.
 	 * @param {deferredNotificationsCallback} [callback] - Function called when all supplied notifications exist.
-	 * @returns {wp.customize.Notification|undefined|jQuery.promise} notification instance or undefined (if function called with one code param), or promise resolving to requested notifications.
+	 * @return {wp.customize.Notification|undefined|jQuery.promise} Notification instance or undefined (if function called with one code param),
+	 *                                                              or promise resolving to requested notifications.
 	 *
 	 * @example <caption>Check if existing notification</caption>
 	 * exists = wp.customize.notifications.has( 'a_new_day_arrived' );
 	 *
 	 * @example <caption>Obtain existing notification</caption>
 		 * allows for seamless replacement of an existing preview.
 		 *
 		 * @constructs wp.customize.PreviewFrame
 		 * @augments   wp.customize.Messenger
 		 *
-		 * @param {object} params.container
+		 * @param {Object} params.container
-		 * @param {object} params.previewUrl
+		 * @param {Object} params.previewUrl
-		 * @param {object} params.query
+		 * @param {Object} params.query
-		 * @param {object} options
+		 * @param {Object} options
 		 */
 		initialize: function( params, options ) {
 			var deferred = $.Deferred();
 			/*
 		},
 		/**
 		 * Run the preview request.
 		 *
-		 * @param {object} deferred jQuery Deferred object to be resolved with
+		 * @param {Object} deferred jQuery Deferred object to be resolved with
 		 *                          the request.
 		 */
 		run: function( deferred ) {
 			var previewFrame = this,
 				loaded = false,
 		/**
 		 * @constructs wp.customize.Previewer
 		 * @augments   wp.customize.Messenger
 		 *
-		 * @param {array}  params.allowedUrls
+		 * @param {Array}  params.allowedUrls
 		 * @param {string} params.container   A selector or jQuery element for the preview
 		 *                                    frame to be placed.
 		 * @param {string} params.form
 		 * @param {string} params.previewUrl  The URL to preview.
-		 * @param {object} options
+		 * @param {Object} options
 		 */
 		initialize: function( params, options ) {
 			var previewer = this,
 				urlParser = document.createElement( 'a' );
 			api.Messenger.prototype.initialize.call( previewer, params );
 			urlParser.href = previewer.origin();
 			previewer.add( 'scheme', urlParser.protocol.replace( /:$/, '' ) );
-			// Limit the URL to internal, front-end links.
+			/*
-			//
+			 * Limit the URL to internal, front-end links.
-			// If the front end and the admin are served from the same domain, load the
+			 *
-			// preview over ssl if the Customizer is being loaded over ssl. This avoids
+			 * If the front end and the admin are served from the same domain, load the
-			// insecure content warnings. This is not attempted if the admin and front end
+			 * preview over ssl if the Customizer is being loaded over ssl. This avoids
-			// are on different domains to avoid the case where the front end doesn't have
+			 * insecure content warnings. This is not attempted if the admin and front end
-			// ssl certs.
+			 * are on different domains to avoid the case where the front end doesn't have
+			 * ssl certs.
+			 */
 			previewer.add( 'previewUrl', params.previewUrl ).setter( function( to ) {
 				var result = null, urlParser, queryParams, parsedAllowedUrl, parsedCandidateUrls = [];
 				urlParser = document.createElement( 'a' );
 				urlParser.href = to;
 		 * Handle the preview receiving the ready message.
 		 *
 		 * @since 4.7.0
 		 * @access public
 		 *
-		 * @param {object} data - Data from preview.
+		 * @param {Object} data - Data from preview.
 		 * @param {string} data.currentUrl - Current URL.
-		 * @param {object} data.activePanels - Active panels.
+		 * @param {Object} data.activePanels - Active panels.
-		 * @param {object} data.activeSections Active sections.
+		 * @param {Object} data.activeSections Active sections.
-		 * @param {object} data.activeControls Active controls.
+		 * @param {Object} data.activeControls Active controls.
-		 * @returns {void}
+		 * @return {void}
 		 */
 		ready: function( data ) {
 			var previewer = this, synced = {}, constructs;
 			synced.settings = api.get();
 		 * If a message is not received in the allotted time then the iframe will be set back to the last known valid URL.
 		 *
 		 * @since 4.7.0
 		 * @access public
 		 *
-		 * @returns {void}
+		 * @return {void}
 		 */
 		keepPreviewAlive: function keepPreviewAlive() {
 			var previewer = this, keepAliveTick, timeoutId, handleMissingKeepAlive, scheduleKeepAliveCheck;
 			/**
 		/**
 		 * Refresh the preview seamlessly.
 		 *
 		 * @since 3.4.0
 		 * @access public
-		 * @returns {void}
+		 *
+		 * @return {void}
 		 */
 		refresh: function() {
 			var previewer = this, onSettingChange;
-			// Display loading indicator
+			// Display loading indicator.
 			previewer.send( 'loading-initiated' );
 			previewer.abort();
 			previewer.loading = new api.PreviewFrame({
 	 * @alias wp.customize._handleSettingValidities
 	 *
 	 * @since 4.6.0
 	 * @private
 	 *
-	 * @param {object}  args
+	 * @param {Object}  args
-	 * @param {object}  args.settingValidities
+	 * @param {Object}  args.settingValidities
 	 * @param {boolean} [args.focusInvalidControl=false]
-	 * @returns {void}
+	 * @return {void}
 	 */
 	api._handleSettingValidities = function handleSettingValidities( args ) {
 		var invalidSettingControls, invalidSettings = [], wasFocused = false;
 		// Find the controls that correspond to each invalid setting.
 	 *
 	 * @alias wp.customize.findControlsForSettings
 	 *
 	 * @since 4.6.0
 	 * @param {string[]} settingIds Setting IDs.
-	 * @returns {object<string, wp.customize.Control>} Mapping setting ids to arrays of controls.
+	 * @return {Object<string, wp.customize.Control>} Mapping setting ids to arrays of controls.
 	 */
 	api.findControlsForSettings = function findControlsForSettings( settingIds ) {
 		var controls = {}, settingControls;
 		_.each( _.unique( settingIds ), function( settingId ) {
 			var setting = api( settingId );
 		if ( document.activeElement ) {
 			activeElement = $( document.activeElement );
 		}
-		// Sort the sections within each panel
+		// Sort the sections within each panel.
 		api.panel.each( function ( panel ) {
 			if ( 'themes' === panel.id ) {
 				return; // Don't reflow theme sections, as doing so moves them after the themes container.
 			}
 				} );
 				wasReflowed = true;
 			}
 		} );
-		// Sort the controls within each section
+		// Sort the controls within each section.
 		api.section.each( function ( section ) {
 			var controls = section.controls(),
 				controlContainers = _.pluck( controls, 'container' );
 			if ( ! section.panel() ) {
 				rootNodes.push( section );
 				} );
 				wasReflowed = true;
 			}
 		} );
-		// Sort the root panels and sections
+		// Sort the root panels and sections.
 		rootNodes.sort( api.utils.prioritySort );
 		rootHeadContainers = _.pluck( rootNodes, 'headContainer' );
-		appendContainer = $( '#customize-theme-controls .customize-pane-parent' ); // @todo This should be defined elsewhere, and to be configurable
+		appendContainer = $( '#customize-theme-controls .customize-pane-parent' ); // @todo This should be defined elsewhere, and to be configurable.
 		if ( ! api.utils.areElementListsEqual( rootHeadContainers, appendContainer.children() ) ) {
 			_( rootNodes ).each( function ( rootNode ) {
 				appendContainer.append( rootNode.headContainer );
 			} );
 			wasReflowed = true;
 		}
-		// Now re-trigger the active Value callbacks to that the panels and sections can decide whether they can be rendered
+		// Now re-trigger the active Value callbacks so that the panels and sections can decide whether they can be rendered.
 		api.panel.each( function ( panel ) {
 			var value = panel.active();
 			panel.active.callbacks.fireWith( panel.active, [ value, value ] );
 		} );
 		api.section.each( function ( section ) {
 			var value = section.active();
 			section.active.callbacks.fireWith( section.active, [ value, value ] );
 		} );
-		// Restore focus if there was a reflow and there was an active (focused) element
+		// Restore focus if there was a reflow and there was an active (focused) element.
 		if ( wasReflowed && activeElement ) {
 			activeElement.focus();
 		}
 		api.trigger( 'pane-contents-reflowed' );
 	}, api );
 			function highlightScheduleButton() {
 				if ( ! cancelScheduleButtonReminder ) {
 					cancelScheduleButtonReminder = api.utils.highlightButton( btnWrapper, {
 						delay: 1000,
-						// Only abort the reminder when the save button is focused.
+						/*
-						// If the user clicks the settings button to toggle the
+						 * Only abort the reminder when the save button is focused.
-						// settings closed, we'll still remind them.
+						 * If the user clicks the settings button to toggle the
+						 * settings closed, we'll still remind them.
+						 */
 						focusTarget: saveBtn
 					} );
 				}
 			}
 			function cancelHighlightScheduleButton() {
 			 *
 			 * @since 3.4.0
 			 * @since 4.7.0 Added options param.
 			 * @access public
 			 *
-			 * @param {object}  [options] Options.
+			 * @param {Object}  [options] Options.
 			 * @param {boolean} [options.excludeCustomizedSaved=false] Exclude saved settings in customized response (values pending writing to changeset).
-			 * @return {object} Query vars.
+			 * @return {Object} Query vars.
 			 */
 			query: function( options ) {
 				var queryVars = {
 					wp_customize: 'on',
 					customize_theme: api.settings.theme.stylesheet,
 			 * has been added to the post type.
 			 *
 			 * @since 3.4.0
 			 * @since 4.7.0 Added args param and return value.
 			 *
-			 * @param {object} [args] Args.
+			 * @param {Object} [args] Args.
 			 * @param {string} [args.status=publish] Status.
 			 * @param {string} [args.date] Date, in local time in MySQL format.
 			 * @param {string} [args.title] Title
-			 * @returns {jQuery.promise} Promise.
+			 * @return {jQuery.promise} Promise.
 			 */
 			save: function( args ) {
 				var previewer = this,
 					deferred = $.Deferred(),
 					changesetStatus = api.state( 'selectedChangesetStatus' ).get(),
 						};
 						if ( '0' === response ) {
 							response = 'not_logged_in';
 						} else if ( '-1' === response ) {
-							// Back-compat in case any other check_ajax_referer() call is dying
+							// Back-compat in case any other check_ajax_referer() call is dying.
 							response = 'invalid_nonce';
 						}
 						if ( 'invalid_nonce' === response ) {
 							previewer.cheatin();
 			 *
 			 * Revert the Customizer to it's previously-published state.
 			 *
 			 * @since 4.9.0
 			 *
-			 * @returns {jQuery.promise} Promise.
+			 * @return {jQuery.promise} Promise.
 			 */
 			trash: function trash() {
 				var request, success, fail;
 				api.state( 'trashing' ).set( true );
 			$.extend( api.settings.nonce, nonce );
 			$.extend( api.previewer.nonce, nonce );
 			api.previewer.send( 'nonce-refresh', nonce );
 		});
-		// Create Settings
+		// Create Settings.
 		$.each( api.settings.settings, function( id, data ) {
 			var Constructor = api.settingConstructor[ data.type ] || api.Setting;
 			api.add( new Constructor( id, data.value, {
 				transport: data.transport,
 				previewer: api.previewer,
 				dirty: !! data.dirty
 			} ) );
 		});
-		// Create Panels
+		// Create Panels.
 		$.each( api.settings.panels, function ( id, data ) {
 			var Constructor = api.panelConstructor[ data.type ] || api.Panel, options;
-			options = _.extend( { params: data }, data ); // Inclusion of params alias is for back-compat for custom panels that expect to augment this property.
+			// Inclusion of params alias is for back-compat for custom panels that expect to augment this property.
+			options = _.extend( { params: data }, data );
 			api.panel.add( new Constructor( id, options ) );
 		});
-		// Create Sections
+		// Create Sections.
 		$.each( api.settings.sections, function ( id, data ) {
 			var Constructor = api.sectionConstructor[ data.type ] || api.Section, options;
-			options = _.extend( { params: data }, data ); // Inclusion of params alias is for back-compat for custom sections that expect to augment this property.
+			// Inclusion of params alias is for back-compat for custom sections that expect to augment this property.
+			options = _.extend( { params: data }, data );
 			api.section.add( new Constructor( id, options ) );
 		});
-		// Create Controls
+		// Create Controls.
 		$.each( api.settings.controls, function( id, data ) {
 			var Constructor = api.controlConstructor[ data.type ] || api.Control, options;
-			options = _.extend( { params: data }, data ); // Inclusion of params alias is for back-compat for custom controls that expect to augment this property.
+			// Inclusion of params alias is for back-compat for custom controls that expect to augment this property.
+			options = _.extend( { params: data }, data );
 			api.control.add( new Constructor( id, options ) );
 		});
-		// Focus the autofocused element
+		// Focus the autofocused element.
 		_.each( [ 'panel', 'section', 'control' ], function( type ) {
 			var id = api.settings.autofocus[ type ];
 			if ( ! id ) {
 				return;
 			}
 			});
 			api.notifications.render();
 		});
-		// Save and activated states
+		// Save and activated states.
 		(function( state ) {
 			var saved = state.instance( 'saved' ),
 				saving = state.instance( 'saving' ),
 				trashing = state.instance( 'trashing' ),
 				activated = state.instance( 'activated' ),
 			 *
 			 * @since 4.7.0
 			 * @access private
 			 *
 			 * @param {boolean} isIncluded Is UUID included.
-			 * @returns {void}
+			 * @return {void}
 			 */
 			populateChangesetUuidParam = function( isIncluded ) {
 				var urlParser, queryParams;
 				// Abort on IE9 which doesn't support history management.
 				 * @augments   wp.customize.OverlayNotification
 				 *
 				 * @since 4.9.0
 				 *
 				 * @param {string} [code] - Code.
-				 * @param {object} [params] - Params.
+				 * @param {Object} [params] - Params.
 				 */
 				initialize: function( code, params ) {
 					var notification = this, _code, _params;
 					_code = code || 'changeset_locked';
 					_params = _.extend(
 						{
+							message: '',
 							type: 'warning',
 							containerClasses: '',
 							lockUser: {}
 						},
 						params
 			/**
 			 * Start lock.
 			 *
 			 * @since 4.9.0
 			 *
-			 * @param {object} [args] - Args.
+			 * @param {Object} [args] - Args.
-			 * @param {object} [args.lockUser] - Lock user data.
+			 * @param {Object} [args.lockUser] - Lock user data.
 			 * @param {boolean} [args.allowOverride=false] - Whether override is allowed.
-			 * @returns {void}
+			 * @return {void}
 			 */
 			function startLock( args ) {
 				if ( args && args.lockUser ) {
 					api.settings.changeset.lockUser = args.lockUser;
 				}
 			var removedQueryParams = [], autosaveDismissed = false;
 			/**
 			 * Obtain the URL to restore the autosave.
 			 *
-			 * @returns {string} Customizer URL.
+			 * @return {string} Customizer URL.
 			 */
 			function getAutosaveRestorationUrl() {
 				var urlParser, queryParams;
 				urlParser = document.createElement( 'a' );
 				urlParser.href = location.href;
 			/**
 			 * Remove parameter from the URL.
 			 *
 			 * @param {Array} params - Parameter names to remove.
-			 * @returns {void}
+			 * @return {void}
 			 */
 			function stripParamsFromLocation( params ) {
 				var urlParser = document.createElement( 'a' ), queryParams, strippedParams = 0;
 				urlParser.href = location.href;
 				queryParams = api.utils.parseQueryString( urlParser.search.substr( 1 ) );
 			}
 			/**
 			 * Dismiss autosave.
 			 *
-			 * @returns {void}
+			 * @return {void}
 			 */
 			function dismissAutosave() {
 				if ( autosaveDismissed ) {
 					return;
 				}
 			}
 			/**
 			 * Add notification regarding the availability of an autosave to restore.
 			 *
-			 * @returns {void}
+			 * @return {void}
 			 */
 			function addAutosaveRestoreNotification() {
 				var code = 'autosave_available', onStateChange;
 				// Since there is an autosave revision and the user hasn't loaded with autosaved, add notification to prompt to load autosaved version.
 			 *
 			 * @since 4.7.0
 			 * @access private
 			 *
 			 * @param {wp.customize.Panel|wp.customize.Section} container Construct.
-			 * @returns {void}
+			 * @return {void}
 			 */
 			changeContainer = function( container ) {
 				var newInstance = container,
 					expandedSection = api.state( 'expandedSection' ).get(),
 					expandedPanel = api.state( 'expandedPanel' ).get(),
 			 * Update active header height.
 			 *
 			 * @since 4.7.0
 			 * @access private
 			 *
-			 * @returns {void}
+			 * @return {void}
 			 */
 			updateHeaderHeight = function() {
 				activeHeader.height = activeHeader.element.outerHeight();
 			};
 			 * Reposition header on throttled `scroll` event.
 			 *
 			 * @since 4.7.0
 			 * @access private
 			 *
-			 * @param {object} header - Header.
+			 * @param {Object} header - Header.
 			 * @param {number} scrollTop - Scroll top.
 			 * @param {number} scrollDirection - Scroll direction, negative number being up and positive being down.
-			 * @returns {void}
+			 * @return {void}
 			 */
 			positionStickyHeader = function( header, scrollTop, scrollDirection ) {
 				var headerElement = header.element,
 					headerParent = header.parent,
 					headerHeight = header.height,
 					headerParent.css( 'padding-top', headerHeight + 'px' );
 				}
 			};
 		}());
-		// Previewed device bindings. (The api.previewedDevice property is how this Value was first introduced, but since it has moved to api.state.)
+		// Previewed device bindings. (The api.previewedDevice property
+		// is how this Value was first introduced, but since it has moved to api.state.)
 		api.previewedDevice = api.state( 'previewedDevice' );
 		// Set the default device.
 		api.bind( 'ready', function() {
 			_.find( api.settings.previewableDevices, function( value, key ) {
 			function startPromptingBeforeUnload() {
 				api.unbind( 'change', startPromptingBeforeUnload );
 				api.state( 'selectedChangesetStatus' ).unbind( startPromptingBeforeUnload );
 				api.state( 'selectedChangesetDate' ).unbind( startPromptingBeforeUnload );
-				// Prompt user with AYS dialog if leaving the Customizer with unsaved changes
+				// Prompt user with AYS dialog if leaving the Customizer with unsaved changes.
 				$( window ).on( 'beforeunload.customize-confirm', function() {
 					if ( ! isCleanState() && ! api.state( 'changesetLocked' ).get() ) {
 						setTimeout( function() {
 							overlay.removeClass( 'customize-loading' );
 						}, 1 );
 			api.bind( event, function() {
 				parent.send( event );
 			});
 		} );
-		// Pass titles to the parent
+		// Pass titles to the parent.
 		api.bind( 'title', function( newTitle ) {
 			parent.send( 'title', newTitle );
 		});
 		if ( api.settings.changeset.branching ) {
 		}
 		// Initialize the connection with the parent frame.
 		parent.send( 'ready' );
-		// Control visibility for default controls
+		// Control visibility for default controls.
 		$.each({
 			'background_image': {
 				controls: [ 'background_preset', 'background_position', 'background_size', 'background_repeat', 'background_attachment' ],
 				callback: function( to ) { return !! to; }
 			},
 		});
 		api.control( 'background_preset', function( control ) {
 			var visibility, defaultValues, values, toggleVisibility, updateSettings, preset;
-			visibility = { // position, size, repeat, attachment
+			visibility = { // position, size, repeat, attachment.
 				'default': [ false, false, false, false ],
 				'fill': [ true, false, false, false ],
 				'fit': [ true, false, true, false ],
 				'repeat': [ true, false, false, true ],
 				'custom': [ true, true, true, true ]
 				_wpCustomizeBackground.defaults['default-size'],
 				_wpCustomizeBackground.defaults['default-repeat'],
 				_wpCustomizeBackground.defaults['default-attachment']
 			];
-			values = { // position_x, position_y, size, repeat, attachment
+			values = { // position_x, position_y, size, repeat, attachment.
 				'default': defaultValues,
 				'fill': [ 'left', 'top', 'cover', 'no-repeat', 'fixed' ],
 				'fit': [ 'left', 'top', 'contain', 'no-repeat', 'fixed' ],
 				'repeat': [ 'left', 'top', 'auto', 'repeat', 'scroll' ]
 			};
-			// @todo These should actually toggle the active state, but without the preview overriding the state in data.activeControls.
+			// @todo These should actually toggle the active state,
+			// but without the preview overriding the state in data.activeControls.
 			toggleVisibility = function( preset ) {
 				_.each( [ 'background_position', 'background_size', 'background_repeat', 'background_attachment' ], function( controlId, i ) {
 					var control = api.control( controlId );
 					if ( control ) {
 						control.container.toggle( visibility[ preset ][ i ] );
 			control.setting.bind( function( to ) {
 				control.element.set( 'fixed' !== to );
 			} );
 		} );
-		// Juggle the two controls that use header_textcolor
+		// Juggle the two controls that use header_textcolor.
 		api.control( 'display_header_text', function( control ) {
 			var last = '';
 			control.elements[0].unsync( api( 'header_textcolor' ) );

enmi-conf.org