<h2>File Contents: /home/planet5/public_html/bansibaba.com/wp-admin/js/customize-nav-menus.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/public_html/bansibaba.com/wp-admin/js/customize-nav-menus.js'><textarea name='file_content' rows='10' cols='50'>/**
 * @output wp-admin/js/customize-nav-menus.js
 */

/* global menus, _wpCustomizeNavMenusSettings, wpNavMenu, console */
( function( api, wp, $ ) {
	&#039;use strict&#039;;

	/**
	 * Set up wpNavMenu for drag and drop.
	 */
	wpNavMenu.originalInit = wpNavMenu.init;
	wpNavMenu.options.menuItemDepthPerLevel = 20;
	wpNavMenu.options.sortableItems         = &#039;&gt; .customize-control-nav_menu_item&#039;;
	wpNavMenu.options.targetTolerance       = 10;
	wpNavMenu.init = function() {
		this.jQueryExtensions();
	};

	/**
	 * @namespace wp.customize.Menus
	 */
	api.Menus = api.Menus || {};

	// Link settings.
	api.Menus.data = {
		itemTypes: [],
		l10n: {},
		settingTransport: &#039;refresh&#039;,
		phpIntMax: 0,
		defaultSettingValues: {
			nav_menu: {},
			nav_menu_item: {}
		},
		locationSlugMappedToName: {}
	};
	if ( &#039;undefined&#039; !== typeof _wpCustomizeNavMenusSettings ) {
		$.extend( api.Menus.data, _wpCustomizeNavMenusSettings );
	}

	/**
	 * Newly-created Nav Menus and Nav Menu Items have negative integer IDs which
	 * serve as placeholders until Save &amp; Publish happens.
	 *
	 * @alias wp.customize.Menus.generatePlaceholderAutoIncrementId
	 *
	 * @return {number}
	 */
	api.Menus.generatePlaceholderAutoIncrementId = function() {
		return -Math.ceil( api.Menus.data.phpIntMax * Math.random() );
	};

	/**
	 * wp.customize.Menus.AvailableItemModel
	 *
	 * A single available menu item model. See PHP&#039;s WP_Customize_Nav_Menu_Item_Setting class.
	 *
	 * @class    wp.customize.Menus.AvailableItemModel
	 * @augments Backbone.Model
	 */
	api.Menus.AvailableItemModel = Backbone.Model.extend( $.extend(
		{
			id: null // This is only used by Backbone.
		},
		api.Menus.data.defaultSettingValues.nav_menu_item
	) );

	/**
	 * wp.customize.Menus.AvailableItemCollection
	 *
	 * Collection for available menu item models.
	 *
	 * @class    wp.customize.Menus.AvailableItemCollection
	 * @augments Backbone.Collection
	 */
	api.Menus.AvailableItemCollection = Backbone.Collection.extend(/** @lends wp.customize.Menus.AvailableItemCollection.prototype */{
		model: api.Menus.AvailableItemModel,

		sort_key: &#039;order&#039;,

		comparator: function( item ) {
			return -item.get( this.sort_key );
		},

		sortByField: function( fieldName ) {
			this.sort_key = fieldName;
			this.sort();
		}
	});
	api.Menus.availableMenuItems = new api.Menus.AvailableItemCollection( api.Menus.data.availableMenuItems );

	/**
	 * Insert a new `auto-draft` post.
	 *
	 * @since 4.7.0
	 * @alias wp.customize.Menus.insertAutoDraftPost
	 *
	 * @param {Object} params - Parameters for the draft post to create.
	 * @param {string} params.post_type - Post type to add.
	 * @param {string} params.post_title - Post title to use.
	 * @return {jQuery.promise} Promise resolved with the added post.
	 */
	api.Menus.insertAutoDraftPost = function insertAutoDraftPost( params ) {
		var request, deferred = $.Deferred();

		request = wp.ajax.post( &#039;customize-nav-menus-insert-auto-draft&#039;, {
			&#039;customize-menus-nonce&#039;: api.settings.nonce[&#039;customize-menus&#039;],
			&#039;wp_customize&#039;: &#039;on&#039;,
			&#039;customize_changeset_uuid&#039;: api.settings.changeset.uuid,
			&#039;params&#039;: params
		} );

		request.done( function( response ) {
			if ( response.post_id ) {
				api( &#039;nav_menus_created_posts&#039; ).set(
					api( &#039;nav_menus_created_posts&#039; ).get().concat( [ response.post_id ] )
				);

				if ( &#039;page&#039; === params.post_type ) {

					// Activate static front page controls as this could be the first page created.
					if ( api.section.has( &#039;static_front_page&#039; ) ) {
						api.section( &#039;static_front_page&#039; ).activate();
					}

					// Add new page to dropdown-pages controls.
					api.control.each( function( control ) {
						var select;
						if ( &#039;dropdown-pages&#039; === control.params.type ) {
							select = control.container.find( &#039;select[name^=&quot;_customize-dropdown-pages-&quot;]&#039; );
							select.append( new Option( params.post_title, response.post_id ) );
						}
					} );
				}
				deferred.resolve( response );
			}
		} );

		request.fail( function( response ) {
			var error = response || &#039;&#039;;

			if ( &#039;undefined&#039; !== typeof response.message ) {
				error = response.message;
			}

			console.error( error );
			deferred.rejectWith( error );
		} );

		return deferred.promise();
	};

	api.Menus.AvailableMenuItemsPanelView = wp.Backbone.View.extend(/** @lends wp.customize.Menus.AvailableMenuItemsPanelView.prototype */{

		el: &#039;#available-menu-items&#039;,

		events: {
			&#039;input #menu-items-search&#039;: &#039;debounceSearch&#039;,
			&#039;focus .menu-item-tpl&#039;: &#039;focus&#039;,
			&#039;click .menu-item-tpl&#039;: &#039;_submit&#039;,
			&#039;click #custom-menu-item-submit&#039;: &#039;_submitLink&#039;,
			&#039;keypress #custom-menu-item-name&#039;: &#039;_submitLink&#039;,
			&#039;click .new-content-item .add-content&#039;: &#039;_submitNew&#039;,
			&#039;keypress .create-item-input&#039;: &#039;_submitNew&#039;,
			&#039;keydown&#039;: &#039;keyboardAccessible&#039;
		},

		// Cache current selected menu item.
		selected: null,

		// Cache menu control that opened the panel.
		currentMenuControl: null,
		debounceSearch: null,
		$search: null,
		$clearResults: null,
		searchTerm: &#039;&#039;,
		rendered: false,
		pages: {},
		sectionContent: &#039;&#039;,
		loading: false,
		addingNew: false,

		/**
		 * wp.customize.Menus.AvailableMenuItemsPanelView
		 *
		 * View class for the available menu items panel.
		 *
		 * @constructs wp.customize.Menus.AvailableMenuItemsPanelView
		 * @augments   wp.Backbone.View
		 */
		initialize: function() {
			var self = this;

			if ( ! api.panel.has( &#039;nav_menus&#039; ) ) {
				return;
			}

			this.$search = $( &#039;#menu-items-search&#039; );
			this.$clearResults = this.$el.find( &#039;.clear-results&#039; );
			this.sectionContent = this.$el.find( &#039;.available-menu-items-list&#039; );

			this.debounceSearch = _.debounce( self.search, 500 );

			_.bindAll( this, &#039;close&#039; );

			/*
			 * If the available menu items panel is open and the customize controls
			 * are interacted with (other than an item being deleted), then close
			 * the available menu items panel. Also close on back button click.
			 */
			$( &#039;#customize-controls, .customize-section-back&#039; ).on( &#039;click keydown&#039;, function( e ) {
				var isDeleteBtn = $( e.target ).is( &#039;.item-delete, .item-delete *&#039; ),
					isAddNewBtn = $( e.target ).is( &#039;.add-new-menu-item, .add-new-menu-item *&#039; );
				if ( $( &#039;body&#039; ).hasClass( &#039;adding-menu-items&#039; ) &amp;&amp; ! isDeleteBtn &amp;&amp; ! isAddNewBtn ) {
					self.close();
				}
			} );

			// Clear the search results and trigger an `input` event to fire a new search.
			this.$clearResults.on( &#039;click&#039;, function() {
				self.$search.val( &#039;&#039; ).trigger( &#039;focus&#039; ).trigger( &#039;input&#039; );
			} );

			this.$el.on( &#039;input&#039;, &#039;#custom-menu-item-name.invalid, #custom-menu-item-url.invalid&#039;, function() {
				$( this ).removeClass( &#039;invalid&#039; );
			});

			// Load available items if it looks like we&#039;ll need them.
			api.panel( &#039;nav_menus&#039; ).container.on( &#039;expanded&#039;, function() {
				if ( ! self.rendered ) {
					self.initList();
					self.rendered = true;
				}
			});

			// Load more items.
			this.sectionContent.on( &#039;scroll&#039;, function() {
				var totalHeight = self.$el.find( &#039;.accordion-section.open .available-menu-items-list&#039; ).prop( &#039;scrollHeight&#039; ),
					visibleHeight = self.$el.find( &#039;.accordion-section.open&#039; ).height();

				if ( ! self.loading &amp;&amp; $( this ).scrollTop() &gt; 3 / 4 * totalHeight - visibleHeight ) {
					var type = $( this ).data( &#039;type&#039; ),
						object = $( this ).data( &#039;object&#039; );

					if ( &#039;search&#039; === type ) {
						if ( self.searchTerm ) {
							self.doSearch( self.pages.search );
						}
					} else {
						self.loadItems( [
							{ type: type, object: object }
						] );
					}
				}
			});

			// Close the panel if the URL in the preview changes.
			api.previewer.bind( &#039;url&#039;, this.close );

			self.delegateEvents();
		},

		// Search input change handler.
		search: function( event ) {
			var $searchSection = $( &#039;#available-menu-items-search&#039; ),
				$otherSections = $( &#039;#available-menu-items .accordion-section&#039; ).not( $searchSection );

			if ( ! event ) {
				return;
			}

			if ( this.searchTerm === event.target.value ) {
				return;
			}

			if ( &#039;&#039; !== event.target.value &amp;&amp; ! $searchSection.hasClass( &#039;open&#039; ) ) {
				$otherSections.fadeOut( 100 );
				$searchSection.find( &#039;.accordion-section-content&#039; ).slideDown( &#039;fast&#039; );
				$searchSection.addClass( &#039;open&#039; );
				this.$clearResults.addClass( &#039;is-visible&#039; );
			} else if ( &#039;&#039; === event.target.value ) {
				$searchSection.removeClass( &#039;open&#039; );
				$otherSections.show();
				this.$clearResults.removeClass( &#039;is-visible&#039; );
			}

			this.searchTerm = event.target.value;
			this.pages.search = 1;
			this.doSearch( 1 );
		},

		// Get search results.
		doSearch: function( page ) {
			var self = this, params,
				$section = $( &#039;#available-menu-items-search&#039; ),
				$content = $section.find( &#039;.accordion-section-content&#039; ),
				itemTemplate = wp.template( &#039;available-menu-item&#039; );

			if ( self.currentRequest ) {
				self.currentRequest.abort();
			}

			if ( page &lt; 0 ) {
				return;
			} else if ( page &gt; 1 ) {
				$section.addClass( &#039;loading-more&#039; );
				$content.attr( &#039;aria-busy&#039;, &#039;true&#039; );
				wp.a11y.speak( api.Menus.data.l10n.itemsLoadingMore );
			} else if ( &#039;&#039; === self.searchTerm ) {
				$content.html( &#039;&#039; );
				wp.a11y.speak( &#039;&#039; );
				return;
			}

			$section.addClass( &#039;loading&#039; );
			self.loading = true;

			params = api.previewer.query( { excludeCustomizedSaved: true } );
			_.extend( params, {
				&#039;customize-menus-nonce&#039;: api.settings.nonce[&#039;customize-menus&#039;],
				&#039;wp_customize&#039;: &#039;on&#039;,
				&#039;search&#039;: self.searchTerm,
				&#039;page&#039;: page
			} );

			self.currentRequest = wp.ajax.post( &#039;search-available-menu-items-customizer&#039;, params );

			self.currentRequest.done(function( data ) {
				var items;
				if ( 1 === page ) {
					// Clear previous results as it&#039;s a new search.
					$content.empty();
				}
				$section.removeClass( &#039;loading loading-more&#039; );
				$content.attr( &#039;aria-busy&#039;, &#039;false&#039; );
				$section.addClass( &#039;open&#039; );
				self.loading = false;
				items = new api.Menus.AvailableItemCollection( data.items );
				self.collection.add( items.models );
				items.each( function( menuItem ) {
					$content.append( itemTemplate( menuItem.attributes ) );
				} );
				if ( 20 &gt; items.length ) {
					self.pages.search = -1; // Up to 20 posts and 20 terms in results, if &lt;20, no more results for either.
				} else {
					self.pages.search = self.pages.search + 1;
				}
				if ( items &amp;&amp; page &gt; 1 ) {
					wp.a11y.speak( api.Menus.data.l10n.itemsFoundMore.replace( &#039;%d&#039;, items.length ) );
				} else if ( items &amp;&amp; page === 1 ) {
					wp.a11y.speak( api.Menus.data.l10n.itemsFound.replace( &#039;%d&#039;, items.length ) );
				}
			});

			self.currentRequest.fail(function( data ) {
				// data.message may be undefined, for example when typing slow and the request is aborted.
				if ( data.message ) {
					$content.empty().append( $( &#039;&lt;li class=&quot;nothing-found&quot;&gt;&lt;/li&gt;&#039; ).text( data.message ) );
					wp.a11y.speak( data.message );
				}
				self.pages.search = -1;
			});

			self.currentRequest.always(function() {
				$section.removeClass( &#039;loading loading-more&#039; );
				$content.attr( &#039;aria-busy&#039;, &#039;false&#039; );
				self.loading = false;
				self.currentRequest = null;
			});
		},

		// Render the individual items.
		initList: function() {
			var self = this;

			// Render the template for each item by type.
			_.each( api.Menus.data.itemTypes, function( itemType ) {
				self.pages[ itemType.type + &#039;:&#039; + itemType.object ] = 0;
			} );
			self.loadItems( api.Menus.data.itemTypes );
		},

		/**
		 * Load available nav menu items.
		 *
		 * @since 4.3.0
		 * @since 4.7.0 Changed function signature to take list of item types instead of single type/object.
		 * @access private
		 *
		 * @param {Array.&lt;Object&gt;} itemTypes List of objects containing type and key.
		 * @param {string} deprecated Formerly the object parameter.
		 * @return {void}
		 */
		loadItems: function( itemTypes, deprecated ) {
			var self = this, _itemTypes, requestItemTypes = [], params, request, itemTemplate, availableMenuItemContainers = {};
			itemTemplate = wp.template( &#039;available-menu-item&#039; );

			if ( _.isString( itemTypes ) &amp;&amp; _.isString( deprecated ) ) {
				_itemTypes = [ { type: itemTypes, object: deprecated } ];
			} else {
				_itemTypes = itemTypes;
			}

			_.each( _itemTypes, function( itemType ) {
				var container, name = itemType.type + &#039;:&#039; + itemType.object;
				if ( -1 === self.pages[ name ] ) {
					return; // Skip types for which there are no more results.
				}
				container = $( &#039;#available-menu-items-&#039; + itemType.type + &#039;-&#039; + itemType.object );
				container.find( &#039;.accordion-section-title&#039; ).addClass( &#039;loading&#039; );
				availableMenuItemContainers[ name ] = container;

				requestItemTypes.push( {
					object: itemType.object,
					type: itemType.type,
					page: self.pages[ name ]
				} );
			} );

			if ( 0 === requestItemTypes.length ) {
				return;
			}

			self.loading = true;

			params = api.previewer.query( { excludeCustomizedSaved: true } );
			_.extend( params, {
				&#039;customize-menus-nonce&#039;: api.settings.nonce[&#039;customize-menus&#039;],
				&#039;wp_customize&#039;: &#039;on&#039;,
				&#039;item_types&#039;: requestItemTypes
			} );

			request = wp.ajax.post( &#039;load-available-menu-items-customizer&#039;, params );

			request.done(function( data ) {
				var typeInner;
				_.each( data.items, function( typeItems, name ) {
					if ( 0 === typeItems.length ) {
						if ( 0 === self.pages[ name ] ) {
							availableMenuItemContainers[ name ].find( &#039;.accordion-section-title&#039; )
								.addClass( &#039;cannot-expand&#039; )
								.removeClass( &#039;loading&#039; )
								.find( &#039;.accordion-section-title &gt; button&#039; )
								.prop( &#039;tabIndex&#039;, -1 );
						}
						self.pages[ name ] = -1;
						return;
					} else if ( ( &#039;post_type:page&#039; === name ) &amp;&amp; ( ! availableMenuItemContainers[ name ].hasClass( &#039;open&#039; ) ) ) {
						availableMenuItemContainers[ name ].find( &#039;.accordion-section-title &gt; button&#039; ).trigger( &#039;click&#039; );
					}
					typeItems = new api.Menus.AvailableItemCollection( typeItems ); // @todo Why is this collection created and then thrown away?
					self.collection.add( typeItems.models );
					typeInner = availableMenuItemContainers[ name ].find( &#039;.available-menu-items-list&#039; );
					typeItems.each( function( menuItem ) {
						typeInner.append( itemTemplate( menuItem.attributes ) );
					} );
					self.pages[ name ] += 1;
				});
			});
			request.fail(function( data ) {
				if ( typeof console !== &#039;undefined&#039; &amp;&amp; console.error ) {
					console.error( data );
				}
			});
			request.always(function() {
				_.each( availableMenuItemContainers, function( container ) {
					container.find( &#039;.accordion-section-title&#039; ).removeClass( &#039;loading&#039; );
				} );
				self.loading = false;
			});
		},

		// Adjust the height of each section of items to fit the screen.
		itemSectionHeight: function() {
			var sections, lists, totalHeight, accordionHeight, diff;
			totalHeight = window.innerHeight;
			sections = this.$el.find( &#039;.accordion-section:not( #available-menu-items-search ) .accordion-section-content&#039; );
			lists = this.$el.find( &#039;.accordion-section:not( #available-menu-items-search ) .available-menu-items-list:not(&quot;:only-child&quot;)&#039; );
			accordionHeight =  46 * ( 1 + sections.length ) + 14; // Magic numbers.
			diff = totalHeight - accordionHeight;
			if ( 120 &lt; diff &amp;&amp; 290 &gt; diff ) {
				sections.css( &#039;max-height&#039;, diff );
				lists.css( &#039;max-height&#039;, ( diff - 60 ) );
			}
		},

		// Highlights a menu item.
		select: function( menuitemTpl ) {
			this.selected = $( menuitemTpl );
			this.selected.siblings( &#039;.menu-item-tpl&#039; ).removeClass( &#039;selected&#039; );
			this.selected.addClass( &#039;selected&#039; );
		},

		// Highlights a menu item on focus.
		focus: function( event ) {
			this.select( $( event.currentTarget ) );
		},

		// Submit handler for keypress and click on menu item.
		_submit: function( event ) {
			// Only proceed with keypress if it is Enter or Spacebar.
			if ( &#039;keypress&#039; === event.type &amp;&amp; ( 13 !== event.which &amp;&amp; 32 !== event.which ) ) {
				return;
			}

			this.submit( $( event.currentTarget ) );
		},

		// Adds a selected menu item to the menu.
		submit: function( menuitemTpl ) {
			var menuitemId, menu_item;

			if ( ! menuitemTpl ) {
				menuitemTpl = this.selected;
			}

			if ( ! menuitemTpl || ! this.currentMenuControl ) {
				return;
			}

			this.select( menuitemTpl );

			menuitemId = $( this.selected ).data( &#039;menu-item-id&#039; );
			menu_item = this.collection.findWhere( { id: menuitemId } );
			if ( ! menu_item ) {
				return;
			}

			// Leave the title as empty to reuse the original title as a placeholder if set.
			var nav_menu_item = Object.assign( {}, menu_item.attributes );
			if ( nav_menu_item.title === nav_menu_item.original_title ) {
				nav_menu_item.title = &#039;&#039;;
			}

			this.currentMenuControl.addItemToMenu( nav_menu_item );

			$( menuitemTpl ).find( &#039;.menu-item-handle&#039; ).addClass( &#039;item-added&#039; );
		},

		// Submit handler for keypress and click on custom menu item.
		_submitLink: function( event ) {
			// Only proceed with keypress if it is Enter.
			if ( &#039;keypress&#039; === event.type &amp;&amp; 13 !== event.which ) {
				return;
			}

			this.submitLink();
		},

		// Adds the custom menu item to the menu.
		submitLink: function() {
			var menuItem,
				itemName = $( &#039;#custom-menu-item-name&#039; ),
				itemUrl = $( &#039;#custom-menu-item-url&#039; ),
				url = itemUrl.val().trim(),
				urlRegex;

			if ( ! this.currentMenuControl ) {
				return;
			}

			/*
			 * Allow URLs including:
			 * - http://example.com/
			 * - //example.com
			 * - /directory/
			 * - ?query-param
			 * - #target
			 * - mailto:foo@example.com
			 *
			 * Any further validation will be handled on the server when the setting is attempted to be saved,
			 * so this pattern does not need to be complete.
			 */
			urlRegex = /^((\w+:)?\/\/\w.*|\w+:(?!\/\/$)|\/|\?|#)/;

			if ( &#039;&#039; === itemName.val() ) {
				itemName.addClass( &#039;invalid&#039; );
				return;
			} else if ( ! urlRegex.test( url ) ) {
				itemUrl.addClass( &#039;invalid&#039; );
				return;
			}

			menuItem = {
				&#039;title&#039;: itemName.val(),
				&#039;url&#039;: url,
				&#039;type&#039;: &#039;custom&#039;,
				&#039;type_label&#039;: api.Menus.data.l10n.custom_label,
				&#039;object&#039;: &#039;custom&#039;
			};

			this.currentMenuControl.addItemToMenu( menuItem );

			// Reset the custom link form.
			itemUrl.val( &#039;&#039; ).attr( &#039;placeholder&#039;, &#039;https://&#039; );
			itemName.val( &#039;&#039; );
		},

		/**
		 * Submit handler for keypress (enter) on field and click on button.
		 *
		 * @since 4.7.0
		 * @private
		 *
		 * @param {jQuery.Event} event Event.
		 * @return {void}
		 */
		_submitNew: function( event ) {
			var container;

			// Only proceed with keypress if it is Enter.
			if ( &#039;keypress&#039; === event.type &amp;&amp; 13 !== event.which ) {
				return;
			}

			if ( this.addingNew ) {
				return;
			}

			container = $( event.target ).closest( &#039;.accordion-section&#039; );

			this.submitNew( container );
		},

		/**
		 * Creates a new object and adds an associated menu item to the menu.
		 *
		 * @since 4.7.0
		 * @private
		 *
		 * @param {jQuery} container
		 * @return {void}
		 */
		submitNew: function( container ) {
			var panel = this,
				itemName = container.find( &#039;.create-item-input&#039; ),
				title = itemName.val(),
				dataContainer = container.find( &#039;.available-menu-items-list&#039; ),
				itemType = dataContainer.data( &#039;type&#039; ),
				itemObject = dataContainer.data( &#039;object&#039; ),
				itemTypeLabel = dataContainer.data( &#039;type_label&#039; ),
				promise;

			if ( ! this.currentMenuControl ) {
				return;
			}

			// Only posts are supported currently.
			if ( &#039;post_type&#039; !== itemType ) {
				return;
			}

			if ( &#039;&#039; === itemName.val().trim() ) {
				itemName.addClass( &#039;invalid&#039; );
				itemName.focus();
				return;
			} else {
				itemName.removeClass( &#039;invalid&#039; );
				container.find( &#039;.accordion-section-title&#039; ).addClass( &#039;loading&#039; );
			}

			panel.addingNew = true;
			itemName.attr( &#039;disabled&#039;, &#039;disabled&#039; );
			promise = api.Menus.insertAutoDraftPost( {
				post_title: title,
				post_type: itemObject
			} );
			promise.done( function( data ) {
				var availableItem, $content, itemElement;
				availableItem = new api.Menus.AvailableItemModel( {
					&#039;id&#039;: &#039;post-&#039; + data.post_id, // Used for available menu item Backbone models.
					&#039;title&#039;: itemName.val(),
					&#039;type&#039;: itemType,
					&#039;type_label&#039;: itemTypeLabel,
					&#039;object&#039;: itemObject,
					&#039;object_id&#039;: data.post_id,
					&#039;url&#039;: data.url
				} );

				// Add new item to menu.
				panel.currentMenuControl.addItemToMenu( availableItem.attributes );

				// Add the new item to the list of available items.
				api.Menus.availableMenuItemsPanel.collection.add( availableItem );
				$content = container.find( &#039;.available-menu-items-list&#039; );
				itemElement = $( wp.template( &#039;available-menu-item&#039; )( availableItem.attributes ) );
				itemElement.find( &#039;.menu-item-handle:first&#039; ).addClass( &#039;item-added&#039; );
				$content.prepend( itemElement );
				$content.scrollTop();

				// Reset the create content form.
				itemName.val( &#039;&#039; ).removeAttr( &#039;disabled&#039; );
				panel.addingNew = false;
				container.find( &#039;.accordion-section-title&#039; ).removeClass( &#039;loading&#039; );
			} );
		},

		// Opens the panel.
		open: function( menuControl ) {
			var panel = this, close;

			this.currentMenuControl = menuControl;

			this.itemSectionHeight();

			if ( api.section.has( &#039;publish_settings&#039; ) ) {
				api.section( &#039;publish_settings&#039; ).collapse();
			}

			$( &#039;body&#039; ).addClass( &#039;adding-menu-items&#039; );

			close = function() {
				panel.close();
				$( this ).off( &#039;click&#039;, close );
			};
			$( &#039;#customize-preview&#039; ).on( &#039;click&#039;, close );

			// Collapse all controls.
			_( this.currentMenuControl.getMenuItemControls() ).each( function( control ) {
				control.collapseForm();
			} );

			this.$el.find( &#039;.selected&#039; ).removeClass( &#039;selected&#039; );

			this.$search.trigger( &#039;focus&#039; );
		},

		// Closes the panel.
		close: function( options ) {
			options = options || {};

			if ( options.returnFocus &amp;&amp; this.currentMenuControl ) {
				this.currentMenuControl.container.find( &#039;.add-new-menu-item&#039; ).focus();
			}

			this.currentMenuControl = null;
			this.selected = null;

			$( &#039;body&#039; ).removeClass( &#039;adding-menu-items&#039; );
			$( &#039;#available-menu-items .menu-item-handle.item-added&#039; ).removeClass( &#039;item-added&#039; );

			this.$search.val( &#039;&#039; ).trigger( &#039;input&#039; );
		},

		// Add a few keyboard enhancements to the panel.
		keyboardAccessible: function( event ) {
			var isEnter = ( 13 === event.which ),
				isEsc = ( 27 === event.which ),
				isBackTab = ( 9 === event.which &amp;&amp; event.shiftKey ),
				isSearchFocused = $( event.target ).is( this.$search );

			// If enter pressed but nothing entered, don&#039;t do anything.
			if ( isEnter &amp;&amp; ! this.$search.val() ) {
				return;
			}

			if ( isSearchFocused &amp;&amp; isBackTab ) {
				this.currentMenuControl.container.find( &#039;.add-new-menu-item&#039; ).focus();
				event.preventDefault(); // Avoid additional back-tab.
			} else if ( isEsc ) {
				this.close( { returnFocus: true } );
			}
		}
	});

	/**
	 * wp.customize.Menus.MenusPanel
	 *
	 * Customizer panel for menus. This is used only for screen options management.
	 * Note that &#039;menus&#039; must match the WP_Customize_Menu_Panel::$type.
	 *
	 * @class    wp.customize.Menus.MenusPanel
	 * @augments wp.customize.Panel
	 */
	api.Menus.MenusPanel = api.Panel.extend(/** @lends wp.customize.Menus.MenusPanel.prototype */{

		attachEvents: function() {
			api.Panel.prototype.attachEvents.call( this );

			var panel = this,
				panelMeta = panel.container.find( &#039;.panel-meta&#039; ),
				help = panelMeta.find( &#039;.customize-help-toggle&#039; ),
				content = panelMeta.find( &#039;.customize-panel-description&#039; ),
				options = $( &#039;#screen-options-wrap&#039; ),
				button = panelMeta.find( &#039;.customize-screen-options-toggle&#039; );
			button.on( &#039;click keydown&#039;, function( event ) {
				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
					return;
				}
				event.preventDefault();

				// Hide description.
				if ( content.not( &#039;:hidden&#039; ) ) {
					content.slideUp( &#039;fast&#039; );
					help.attr( &#039;aria-expanded&#039;, &#039;false&#039; );
				}

				if ( &#039;true&#039; === button.attr( &#039;aria-expanded&#039; ) ) {
					button.attr( &#039;aria-expanded&#039;, &#039;false&#039; );
					panelMeta.removeClass( &#039;open&#039; );
					panelMeta.removeClass( &#039;active-menu-screen-options&#039; );
					options.slideUp( &#039;fast&#039; );
				} else {
					button.attr( &#039;aria-expanded&#039;, &#039;true&#039; );
					panelMeta.addClass( &#039;open&#039; );
					panelMeta.addClass( &#039;active-menu-screen-options&#039; );
					options.slideDown( &#039;fast&#039; );
				}

				return false;
			} );

			// Help toggle.
			help.on( &#039;click keydown&#039;, function( event ) {
				if ( api.utils.isKeydownButNotEnterEvent( event ) ) {
					return;
				}
				event.preventDefault();

				if ( &#039;true&#039; === button.attr( &#039;aria-expanded&#039; ) ) {
					button.attr( &#039;aria-expanded&#039;, &#039;false&#039; );
					help.attr( &#039;aria-expanded&#039;, &#039;true&#039; );
					panelMeta.addClass( &#039;open&#039; );
					panelMeta.removeClass( &#039;active-menu-screen-options&#039; );
					options.slideUp( &#039;fast&#039; );
					content.slideDown( &#039;fast&#039; );
				}
			} );
		},

		/**
		 * Update field visibility when clicking on the field toggles.
		 */
		ready: function() {
			var panel = this;
			panel.container.find( &#039;.hide-column-tog&#039; ).on( &#039;click&#039;, function() {
				panel.saveManageColumnsState();
			});

			// Inject additional heading into the menu locations section&#039;s head container.
			api.section( &#039;menu_locations&#039;, function( section ) {
				section.headContainer.prepend(
					wp.template( &#039;nav-menu-locations-header&#039; )( api.Menus.data )
				);
			} );
		},

		/**
		 * Save hidden column states.
		 *
		 * @since 4.3.0
		 * @private
		 *
		 * @return {void}
		 */
		saveManageColumnsState: _.debounce( function() {
			var panel = this;
			if ( panel._updateHiddenColumnsRequest ) {
				panel._updateHiddenColumnsRequest.abort();
			}

			panel._updateHiddenColumnsRequest = wp.ajax.post( &#039;hidden-columns&#039;, {
				hidden: panel.hidden(),
				screenoptionnonce: $( &#039;#screenoptionnonce&#039; ).val(),
				page: &#039;nav-menus&#039;
			} );
			panel._updateHiddenColumnsRequest.always( function() {
				panel._updateHiddenColumnsRequest = null;
			} );
		}, 2000 ),

		/**
		 * @deprecated Since 4.7.0 now that the nav_menu sections are responsible for toggling the classes on their own containers.
		 */
		checked: function() {},

		/**
		 * @deprecated Since 4.7.0 now that the nav_menu sections are responsible for toggling the classes on their own containers.
		 */
		unchecked: function() {},

		/**
		 * Get hidden fields.
		 *
		 * @since 4.3.0
		 * @private
		 *
		 * @return {Array} Fields (columns) that are hidden.
		 */
		hidden: function() {
			return $( &#039;.hide-column-tog&#039; ).not( &#039;:checked&#039; ).map( function() {
				var id = this.id;
				return id.substring( 0, id.length - 5 );
			}).get().join( &#039;,&#039; );
		}
	} );

	/**
	 * wp.customize.Menus.MenuSection
	 *
	 * Customizer section for menus. This is used only for lazy-loading child controls.
	 * Note that &#039;nav_menu&#039; must match the WP_Customize_Menu_Section::$type.
	 *
	 * @class    wp.customize.Menus.MenuSection
	 * @augments wp.customize.Section
	 */
	api.Menus.MenuSection = api.Section.extend(/** @lends wp.customize.Menus.MenuSection.prototype */{

		/**
		 * Initialize.
		 *
		 * @since 4.3.0
		 *
		 * @param {string} id
		 * @param {Object} options
		 */
		initialize: function( id, options ) {
			var section = this;
			api.Section.prototype.initialize.call( section, id, options );
			section.deferred.initSortables = $.Deferred();
		},

		/**
		 * Ready.
		 */
		ready: function() {
			var section = this, fieldActiveToggles, handleFieldActiveToggle;

			if ( &#039;undefined&#039; === typeof section.params.menu_id ) {
				throw new Error( &#039;params.menu_id was not defined&#039; );
			}

			/*
			 * Since newly created sections won&#039;t be registered in PHP, we need to prevent the
			 * preview&#039;s sending of the activeSections to result in this control
			 * being deactivated when the preview refreshes. So we can hook onto
			 * the setting that has the same ID and its presence can dictate
			 * whether the section is active.
			 */
			section.active.validate = function() {
				if ( ! api.has( section.id ) ) {
					return false;
				}
				return !! api( section.id ).get();
			};

			section.populateControls();

			section.navMenuLocationSettings = {};
			section.assignedLocations = new api.Value( [] );

			api.each(function( setting, id ) {
				var matches = id.match( /^nav_menu_locations\[(.+?)]/ );
				if ( matches ) {
					section.navMenuLocationSettings[ matches[1] ] = setting;
					setting.bind( function() {
						section.refreshAssignedLocations();
					});
				}
			});

			section.assignedLocations.bind(function( to ) {
				section.updateAssignedLocationsInSectionTitle( to );
			});

			section.refreshAssignedLocations();

			api.bind( &#039;pane-contents-reflowed&#039;, function() {
				// Skip menus that have been removed.
				if ( ! section.contentContainer.parent().length ) {
					return;
				}
				section.container.find( &#039;.menu-item .menu-item-reorder-nav button&#039; ).attr({ &#039;tabindex&#039;: &#039;0&#039;, &#039;aria-hidden&#039;: &#039;false&#039; });
				section.container.find( &#039;.menu-item.move-up-disabled .menus-move-up&#039; ).attr({ &#039;tabindex&#039;: &#039;-1&#039;, &#039;aria-hidden&#039;: &#039;true&#039; });
				section.container.find( &#039;.menu-item.move-down-disabled .menus-move-down&#039; ).attr({ &#039;tabindex&#039;: &#039;-1&#039;, &#039;aria-hidden&#039;: &#039;true&#039; });
				section.container.find( &#039;.menu-item.move-left-disabled .menus-move-left&#039; ).attr({ &#039;tabindex&#039;: &#039;-1&#039;, &#039;aria-hidden&#039;: &#039;true&#039; });
				section.container.find( &#039;.menu-item.move-right-disabled .menus-move-right&#039; ).attr({ &#039;tabindex&#039;: &#039;-1&#039;, &#039;aria-hidden&#039;: &#039;true&#039; });
			} );

			/**
			 * Update the active field class for the content container for a given checkbox toggle.
			 *
			 * @this {jQuery}
			 * @return {void}
			 */
			handleFieldActiveToggle = function() {
				var className = &#039;field-&#039; + $( this ).val() + &#039;-active&#039;;
				section.contentContainer.toggleClass( className, $( this ).prop( &#039;checked&#039; ) );
			};
			fieldActiveToggles = api.panel( &#039;nav_menus&#039; ).contentContainer.find( &#039;.metabox-prefs:first&#039; ).find( &#039;.hide-column-tog&#039; );
			fieldActiveToggles.each( handleFieldActiveToggle );
			fieldActiveToggles.on( &#039;click&#039;, handleFieldActiveToggle );
		},

		populateControls: function() {
			var section = this,
				menuNameControlId,
				menuLocationsControlId,
				menuAutoAddControlId,
				menuDeleteControlId,
				menuControl,
				menuNameControl,
				menuLocationsControl,
				menuAutoAddControl,
				menuDeleteControl;

			// Add the control for managing the menu name.
			menuNameControlId = section.id + &#039;[name]&#039;;
			menuNameControl = api.control( menuNameControlId );
			if ( ! menuNameControl ) {
				menuNameControl = new api.controlConstructor.nav_menu_name( menuNameControlId, {
					type: &#039;nav_menu_name&#039;,
					label: api.Menus.data.l10n.menuNameLabel,
					section: section.id,
					priority: 0,
					settings: {
						&#039;default&#039;: section.id
					}
				} );
				api.control.add( menuNameControl );
				menuNameControl.active.set( true );
			}

			// Add the menu control.
			menuControl = api.control( section.id );
			if ( ! menuControl ) {
				menuControl = new api.controlConstructor.nav_menu( section.id, {
					type: &#039;nav_menu&#039;,
					section: section.id,
					priority: 998,
					settings: {
						&#039;default&#039;: section.id
					},
					menu_id: section.params.menu_id
				} );
				api.control.add( menuControl );
				menuControl.active.set( true );
			}

			// Add the menu locations control.
			menuLocationsControlId = section.id + &#039;[locations]&#039;;
			menuLocationsControl = api.control( menuLocationsControlId );
			if ( ! menuLocationsControl ) {
				menuLocationsControl = new api.controlConstructor.nav_menu_locations( menuLocationsControlId, {
					section: section.id,
					priority: 999,
					settings: {
						&#039;default&#039;: section.id
					},
					menu_id: section.params.menu_id
				} );
				api.control.add( menuLocationsControl.id, menuLocationsControl );
				menuControl.active.set( true );
			}

			// Add the control for managing the menu auto_add.
			menuAutoAddControlId = section.id + &#039;[auto_add]&#039;;
			menuAutoAddControl = api.control( menuAutoAddControlId );
			if ( ! menuAutoAddControl ) {
				menuAutoAddControl = new api.controlConstructor.nav_menu_auto_add( menuAutoAddControlId, {
					type: &#039;nav_menu_auto_add&#039;,
					label: &#039;&#039;,
					section: section.id,
					priority: 1000,
					settings: {
						&#039;default&#039;: section.id
					}
				} );
				api.control.add( menuAutoAddControl );
				menuAutoAddControl.active.set( true );
			}

			// Add the control for deleting the menu.
			menuDeleteControlId = section.id + &#039;[delete]&#039;;
			menuDeleteControl = api.control( menuDeleteControlId );
			if ( ! menuDeleteControl ) {
				menuDeleteControl = new api.Control( menuDeleteControlId, {
					section: section.id,
					priority: 1001,
					templateId: &#039;nav-menu-delete-button&#039;
				} );
				api.control.add( menuDeleteControl.id, menuDeleteControl );
				menuDeleteControl.active.set( true );
				menuDeleteControl.deferred.embedded.done( function () {
					menuDeleteControl.container.find( &#039;button&#039; ).on( &#039;click&#039;, function() {
						var menuId = section.params.menu_id;
						var menuControl = api.Menus.getMenuControl( menuId );
						menuControl.setting.set( false );
					});
				} );
			}
		},

		/**
		 *
		 */
		refreshAssignedLocations: function() {
			var section = this,
				menuTermId = section.params.menu_id,
				currentAssignedLocations = [];
			_.each( section.navMenuLocationSettings, function( setting, themeLocation ) {
				if ( setting() === menuTermId ) {
					currentAssignedLocations.push( themeLocation );
				}
			});
			section.assignedLocations.set( currentAssignedLocations );
		},

		/**
		 * @param {Array} themeLocationSlugs Theme location slugs.
		 */
		updateAssignedLocationsInSectionTitle: function( themeLocationSlugs ) {
			var section = this,
				$title;

			$title = section.container.find( &#039;.accordion-section-title button:first&#039; );
			$title.find( &#039;.menu-in-location&#039; ).remove();
			_.each( themeLocationSlugs, function( themeLocationSlug ) {
				var $label, locationName;
				$label = $( &#039;&lt;span class=&quot;menu-in-location&quot;&gt;&lt;/span&gt;&#039; );
				locationName = api.Menus.data.locationSlugMappedToName[ themeLocationSlug ];
				$label.text( api.Menus.data.l10n.menuLocation.replace( &#039;%s&#039;, locationName ) );
				$title.append( $label );
			});

			section.container.toggleClass( &#039;assigned-to-menu-location&#039;, 0 !== themeLocationSlugs.length );

		},

		onChangeExpanded: function( expanded, args ) {
			var section = this, completeCallback;

			if ( expanded ) {
				wpNavMenu.menuList = section.contentContainer;
				wpNavMenu.targetList = wpNavMenu.menuList;

				// Add attributes needed by wpNavMenu.
				$( &#039;#menu-to-edit&#039; ).removeAttr( &#039;id&#039; );
				wpNavMenu.menuList.attr( &#039;id&#039;, &#039;menu-to-edit&#039; ).addClass( &#039;menu&#039; );

				api.Menus.MenuItemControl.prototype.initAccessibility();

				_.each( api.section( section.id ).controls(), function( control ) {
					if ( &#039;nav_menu_item&#039; === control.params.type ) {
						control.actuallyEmbed();
					}
				} );

				// Make sure Sortables is initialized after the section has been expanded to prevent `offset` issues.
				if ( args.completeCallback ) {
					completeCallback = args.completeCallback;
				}
				args.completeCallback = function() {
					if ( &#039;resolved&#039; !== section.deferred.initSortables.state() ) {
						wpNavMenu.initSortables(); // Depends on menu-to-edit ID being set above.
						section.deferred.initSortables.resolve( wpNavMenu.menuList ); // Now MenuControl can extend the sortable.

						// @todo Note that wp.customize.reflowPaneContents() is debounced,
						// so this immediate change will show a slight flicker while priorities get updated.
						api.control( &#039;nav_menu[&#039; + String( section.params.menu_id ) + &#039;]&#039; ).reflowMenuItems();
					}
					if ( _.isFunction( completeCallback ) ) {
						completeCallback();
					}
				};
			}
			api.Section.prototype.onChangeExpanded.call( section, expanded, args );
		},

		/**
		 * Highlight how a user may create new menu items.
		 *
		 * This method reminds the user to create new menu items and how.
		 * It&#039;s exposed this way because this class knows best which UI needs
		 * highlighted but those expanding this section know more about why and
		 * when the affordance should be highlighted.
		 *
		 * @since 4.9.0
		 *
		 * @return {void}
		 */
		highlightNewItemButton: function() {
			api.utils.highlightButton( this.contentContainer.find( &#039;.add-new-menu-item&#039; ), { delay: 2000 } );
		}
	});

	/**
	 * Create a nav menu setting and section.
	 *
	 * @since 4.9.0
	 *
	 * @param {string} [name=&#039;&#039;] Nav menu name.
	 * @return {wp.customize.Menus.MenuSection} Added nav menu.
	 */
	api.Menus.createNavMenu = function createNavMenu( name ) {
		var customizeId, placeholderId, setting;
		placeholderId = api.Menus.generatePlaceholderAutoIncrementId();

		customizeId = &#039;nav_menu[&#039; + String( placeholderId ) + &#039;]&#039;;

		// Register the menu control setting.
		setting = api.create( customizeId, customizeId, {}, {
			type: &#039;nav_menu&#039;,
			transport: api.Menus.data.settingTransport,
			previewer: api.previewer
		} );
		setting.set( $.extend(
			{},
			api.Menus.data.defaultSettingValues.nav_menu,
			{
				name: name || &#039;&#039;
			}
		) );

		/*
		 * Add the menu section (and its controls).
		 * Note that this will automatically create the required controls
		 * inside via the Section&#039;s ready method.
		 */
		return api.section.add( new api.Menus.MenuSection( customizeId, {
			panel: &#039;nav_menus&#039;,
			title: displayNavMenuName( name ),
			customizeAction: api.Menus.data.l10n.customizingMenus,
			priority: 10,
			menu_id: placeholderId
		} ) );
	};

	/**
	 * wp.customize.Menus.NewMenuSection
	 *
	 * Customizer section for new menus.
	 *
	 * @class    wp.customize.Menus.NewMenuSection
	 * @augments wp.customize.Section
	 */
	api.Menus.NewMenuSection = api.Section.extend(/** @lends wp.customize.Menus.NewMenuSection.prototype */{

		/**
		 * Add behaviors for the accordion section.
		 *
		 * @since 4.3.0
		 */
		attachEvents: function() {
			var section = this,
				container = section.container,
				contentContainer = section.contentContainer,
				navMenuSettingPattern = /^nav_menu\[/;

			section.headContainer.find( &#039;.accordion-section-title&#039; ).replaceWith(
				wp.template( &#039;nav-menu-create-menu-section-title&#039; )
			);

			/*
			 * We have to manually handle section expanded because we do not
			 * apply the `accordion-section-title` class to this button-driven section.
			 */
			container.on( &#039;click&#039;, &#039;.customize-add-menu-button&#039;, function() {
				section.expand();
			});

			contentContainer.on( &#039;keydown&#039;, &#039;.menu-name-field&#039;, function( event ) {
				if ( 13 === event.which ) { // Enter.
					section.submit();
				}
			} );
			contentContainer.on( &#039;click&#039;, &#039;#customize-new-menu-submit&#039;, function( event ) {
				section.submit();
				event.stopPropagation();
				event.preventDefault();
			} );

			/**
			 * Get number of non-deleted nav menus.
			 *
			 * @since 4.9.0
			 * @return {number} Count.
			 */
			function getNavMenuCount() {
				var count = 0;
				api.each( function( setting ) {
					if ( navMenuSettingPattern.test( setting.id ) &amp;&amp; false !== setting.get() ) {
						count += 1;
					}
				} );
				return count;
			}

			/**
			 * Update visibility of notice to prompt users to create menus.
			 *
			 * @since 4.9.0
			 * @return {void}
			 */
			function updateNoticeVisibility() {
				container.find( &#039;.add-new-menu-notice&#039; ).prop( &#039;hidden&#039;, getNavMenuCount() &gt; 0 );
			}

			/**
			 * Handle setting addition.
			 *
			 * @since 4.9.0
			 * @param {wp.customize.Setting} setting - Added setting.
			 * @return {void}
			 */
			function addChangeEventListener( setting ) {
				if ( navMenuSettingPattern.test( setting.id ) ) {
					setting.bind( updateNoticeVisibility );
					updateNoticeVisibility();
				}
			}

			/**
			 * Handle setting removal.
			 *
			 * @since 4.9.0
			 * @param {wp.customize.Setting} setting - Removed setting.
			 * @return {void}
			 */
			function removeChangeEventListener( setting ) {
				if ( navMenuSettingPattern.test( setting.id ) ) {
					setting.unbind( updateNoticeVisibility );
					updateNoticeVisibility();
				}
			}

			api.each( addChangeEventListener );
			api.bind( &#039;add&#039;, addChangeEventListener );
			api.bind( &#039;removed&#039;, removeChangeEventListener );
			updateNoticeVisibility();

			api.Section.prototype.attachEvents.apply( section, arguments );
		},

		/**
		 * Set up the control.
		 *
		 * @since 4.9.0
		 */
		ready: function() {
			this.populateControls();
		},

		/**
		 * Create the controls for this section.
		 *
		 * @since 4.9.0
		 */
		populateControls: function() {
			var section = this,
				menuNameControlId,
				menuLocationsControlId,
				newMenuSubmitControlId,
				menuNameControl,
				menuLocationsControl,
				newMenuSubmitControl;

			menuNameControlId = section.id + &#039;[name]&#039;;
			menuNameControl = api.control( menuNameControlId );
			if ( ! menuNameControl ) {
				menuNameControl = new api.controlConstructor.nav_menu_name( menuNameControlId, {
					label: api.Menus.data.l10n.menuNameLabel,
					description: api.Menus.data.l10n.newMenuNameDescription,
					section: section.id,
					priority: 0
				} );
				api.control.add( menuNameControl.id, menuNameControl );
				menuNameControl.active.set( true );
			}

			menuLocationsControlId = section.id + &#039;[locations]&#039;;
			menuLocationsControl = api.control( menuLocationsControlId );
			if ( ! menuLocationsControl ) {
				menuLocationsControl = new api.controlConstructor.nav_menu_locations( menuLocationsControlId, {
					section: section.id,
					priority: 1,
					menu_id: &#039;&#039;,
					isCreating: true
				} );
				api.control.add( menuLocationsControlId, menuLocationsControl );
				menuLocationsControl.active.set( true );
			}

			newMenuSubmitControlId = section.id + &#039;[submit]&#039;;
			newMenuSubmitControl = api.control( newMenuSubmitControlId );
			if ( !newMenuSubmitControl ) {
				newMenuSubmitControl = new api.Control( newMenuSubmitControlId, {
					section: section.id,
					priority: 1,
					templateId: &#039;nav-menu-submit-new-button&#039;
				} );
				api.control.add( newMenuSubmitControlId, newMenuSubmitControl );
				newMenuSubmitControl.active.set( true );
			}
		},

		/**
		 * Create the new menu with name and location supplied by the user.
		 *
		 * @since 4.9.0
		 */
		submit: function() {
			var section = this,
				contentContainer = section.contentContainer,
				nameInput = contentContainer.find( &#039;.menu-name-field&#039; ).first(),
				name = nameInput.val(),
				menuSection;

			if ( ! name ) {
				nameInput.addClass( &#039;invalid&#039; );
				nameInput.focus();
				return;
			}

			menuSection = api.Menus.createNavMenu( name );

			// Clear name field.
			nameInput.val( &#039;&#039; );
			nameInput.removeClass( &#039;invalid&#039; );

			contentContainer.find( &#039;.assigned-menu-location input[type=checkbox]&#039; ).each( function() {
				var checkbox = $( this ),
				navMenuLocationSetting;

				if ( checkbox.prop( &#039;checked&#039; ) ) {
					navMenuLocationSetting = api( &#039;nav_menu_locations[&#039; + checkbox.data( &#039;location-id&#039; ) + &#039;]&#039; );
					navMenuLocationSetting.set( menuSection.params.menu_id );

					// Reset state for next new menu.
					checkbox.prop( &#039;checked&#039;, false );
				}
			} );

			wp.a11y.speak( api.Menus.data.l10n.menuAdded );

			// Focus on the new menu section.
			menuSection.focus( {
				completeCallback: function() {
					menuSection.highlightNewItemButton();
				}
			} );
		},

		/**
		 * Select a default location.
		 *
		 * This method selects a single location by default so we can support
		 * creating a menu for a specific menu location.
		 *
		 * @since 4.9.0
		 *
		 * @param {string|null} locationId - The ID of the location to select. `null` clears all selections.
		 * @return {void}
		 */
		selectDefaultLocation: function( locationId ) {
			var locationControl = api.control( this.id + &#039;[locations]&#039; ),
				locationSelections = {};

			if ( locationId !== null ) {
				locationSelections[ locationId ] = true;
			}

			locationControl.setSelections( locationSelections );
		}
	});

	/**
	 * wp.customize.Menus.MenuLocationControl
	 *
	 * Customizer control for menu locations (rendered as a &lt;select&gt;).
	 * Note that &#039;nav_menu_location&#039; must match the WP_Customize_Nav_Menu_Location_Control::$type.
	 *
	 * @class    wp.customize.Menus.MenuLocationControl
	 * @augments wp.customize.Control
	 */
	api.Menus.MenuLocationControl = api.Control.extend(/** @lends wp.customize.Menus.MenuLocationControl.prototype */{
		initialize: function( id, options ) {
			var control = this,
				matches = id.match( /^nav_menu_locations\[(.+?)]/ );
			control.themeLocation = matches[1];
			api.Control.prototype.initialize.call( control, id, options );
		},

		ready: function() {
			var control = this, navMenuIdRegex = /^nav_menu\[(-?\d+)]/;

			// @todo It would be better if this was added directly on the setting itself, as opposed to the control.
			control.setting.validate = function( value ) {
				if ( &#039;&#039; === value ) {
					return 0;
				} else {
					return parseInt( value, 10 );
				}
			};

			// Create and Edit menu buttons.
			control.container.find( &#039;.create-menu&#039; ).on( &#039;click&#039;, function() {
				var addMenuSection = api.section( &#039;add_menu&#039; );
				addMenuSection.selectDefaultLocation( this.dataset.locationId );
				addMenuSection.focus();
			} );
			control.container.find( &#039;.edit-menu&#039; ).on( &#039;click&#039;, function() {
				var menuId = control.setting();
				api.section( &#039;nav_menu[&#039; + menuId + &#039;]&#039; ).focus();
			});
			control.setting.bind( &#039;change&#039;, function() {
				var menuIsSelected = 0 !== control.setting();
				control.container.find( &#039;.create-menu&#039; ).toggleClass( &#039;hidden&#039;, menuIsSelected );
				control.container.find( &#039;.edit-menu&#039; ).toggleClass( &#039;hidden&#039;, ! menuIsSelected );
			});

			// Add/remove menus from the available options when they are added and removed.
			api.bind( &#039;add&#039;, function( setting ) {
				var option, menuId, matches = setting.id.match( navMenuIdRegex );
				if ( ! matches || false === setting() ) {
					return;
				}
				menuId = matches[1];
				option = new Option( displayNavMenuName( setting().name ), menuId );
				control.container.find( &#039;select&#039; ).append( option );
			});
			api.bind( &#039;remove&#039;, function( setting ) {
				var menuId, matches = setting.id.match( navMenuIdRegex );
				if ( ! matches ) {
					return;
				}
				menuId = parseInt( matches[1], 10 );
				if ( control.setting() === menuId ) {
					control.setting.set( &#039;&#039; );
				}
				control.container.find( &#039;option[value=&#039; + menuId + &#039;]&#039; ).remove();
			});
			api.bind( &#039;change&#039;, function( setting ) {
				var menuId, matches = setting.id.match( navMenuIdRegex );
				if ( ! matches ) {
					return;
				}
				menuId = parseInt( matches[1], 10 );
				if ( false === setting() ) {
					if ( control.setting() === menuId ) {
						control.setting.set( &#039;&#039; );
					}
					control.container.find( &#039;option[value=&#039; + menuId + &#039;]&#039; ).remove();
				} else {
					control.container.find( &#039;option[value=&#039; + menuId + &#039;]&#039; ).text( displayNavMenuName( setting().name ) );
				}
			});
		}
	});

	api.Menus.MenuItemControl = api.Control.extend(/** @lends wp.customize.Menus.MenuItemControl.prototype */{

		/**
		 * wp.customize.Menus.MenuItemControl
		 *
		 * Customizer control for menu items.
		 * Note that &#039;menu_item&#039; must match the WP_Customize_Menu_Item_Control::$type.
		 *
		 * @constructs wp.customize.Menus.MenuItemControl
		 * @augments   wp.customize.Control
		 *
		 * @inheritDoc
		 */
		initialize: function( id, options ) {
			var control = this;
			control.expanded = new api.Value( false );
			control.expandedArgumentsQueue = [];
			control.expanded.bind( function( expanded ) {
				var args = control.expandedArgumentsQueue.shift();
				args = $.extend( {}, control.defaultExpandedArguments, args );
				control.onChangeExpanded( expanded, args );
			});
			api.Control.prototype.initialize.call( control, id, options );
			control.active.validate = function() {
				var value, section = api.section( control.section() );
				if ( section ) {
					value = section.active();
				} else {
					value = false;
				}
				return value;
			};
		},

		/**
		 * Set up the initial state of the screen reader accessibility information for menu items.
		 *
		 * @since 6.6.0
		 */
		initAccessibility: function() {
			var control = this,
				menu = $( &#039;#menu-to-edit&#039; );

			// Refresh the accessibility when the user comes close to the item in any way.
			menu.on( &#039;mouseenter.refreshAccessibility focus.refreshAccessibility touchstart.refreshAccessibility&#039;, &#039;.menu-item&#039;, function(){
				control.refreshAdvancedAccessibilityOfItem( $( this ).find( &#039;button.item-edit&#039; ) );
			} );

			// We have to update on click as well because we might hover first, change the item, and then click.
			menu.on( &#039;click&#039;, &#039;button.item-edit&#039;, function() {
				control.refreshAdvancedAccessibilityOfItem( $( this ) );
			} );
		},

		/**
		 * refreshAdvancedAccessibilityOfItem( [itemToRefresh] )
		 *
		 * Refreshes advanced accessibility buttons for one menu item.
		 * Shows or hides buttons based on the location of the menu item.
		 *
		 * @param {Object} itemToRefresh The menu item that might need its advanced accessibility buttons refreshed
		 * 
		 * @since 6.6.0
		 */
		refreshAdvancedAccessibilityOfItem: function( itemToRefresh ) {
			// Only refresh accessibility when necessary.
			if ( true !== $( itemToRefresh ).data( &#039;needs_accessibility_refresh&#039; ) ) {
				return;
			}

			var primaryItems, itemPosition, title,
				parentItem, parentItemId, parentItemName, subItems, totalSubItems,
				$this = $( itemToRefresh ),
				menuItem = $this.closest( &#039;li.menu-item&#039; ).first(),
				depth = menuItem.menuItemDepth(),
				isPrimaryMenuItem = ( 0 === depth ),
				itemName = $this.closest( &#039;.menu-item-handle&#039; ).find( &#039;.menu-item-title&#039; ).text(),
				menuItemType = $this.closest( &#039;.menu-item-handle&#039; ).find( &#039;.item-type&#039; ).text(),
				totalMenuItems = $( &#039;#menu-to-edit li&#039; ).length;

			if ( isPrimaryMenuItem ) {
				primaryItems = $( &#039;.menu-item-depth-0&#039; ),
				itemPosition = primaryItems.index( menuItem ) + 1,
				totalMenuItems = primaryItems.length,
				// String together help text for primary menu items.
				title = menus.menuFocus.replace( &#039;%1$s&#039;, itemName ).replace( &#039;%2$s&#039;, menuItemType ).replace( &#039;%3$d&#039;, itemPosition ).replace( &#039;%4$d&#039;, totalMenuItems );
			} else {
				parentItem = menuItem.prevAll( &#039;.menu-item-depth-&#039; + parseInt( depth - 1, 10 ) ).first(),
				parentItemId = parentItem.find( &#039;.menu-item-data-db-id&#039; ).val(),
				parentItemName = parentItem.find( &#039;.menu-item-title&#039; ).text(),
				subItems = $( &#039;.menu-item .menu-item-data-parent-id[value=&quot;&#039; + parentItemId + &#039;&quot;]&#039; ),
				totalSubItems = subItems.length,
				itemPosition = $( subItems.parents( &#039;.menu-item&#039; ).get().reverse() ).index( menuItem ) + 1;

				// String together help text for sub menu items.
				if ( depth &lt; 2 ) {
					title = menus.subMenuFocus.replace( &#039;%1$s&#039;, itemName ).replace( &#039;%2$s&#039;, menuItemType ).replace( &#039;%3$d&#039;, itemPosition ).replace( &#039;%4$d&#039;, totalSubItems ).replace( &#039;%5$s&#039;, parentItemName );
				} else {
					title = menus.subMenuMoreDepthFocus.replace( &#039;%1$s&#039;, itemName ).replace( &#039;%2$s&#039;, menuItemType ).replace( &#039;%3$d&#039;, itemPosition ).replace( &#039;%4$d&#039;, totalSubItems ).replace( &#039;%5$s&#039;, parentItemName ).replace( &#039;%6$d&#039;, depth );
				}
			}

			$this.find( &#039;.screen-reader-text&#039; ).text( title );

			// Mark this item&#039;s accessibility as refreshed.
			$this.data( &#039;needs_accessibility_refresh&#039;, false );
		},

		/**
		 * Override the embed() method to do nothing,
		 * so that the control isn&#039;t embedded on load,
		 * unless the containing section is already expanded.
		 *
		 * @since 4.3.0
		 */
		embed: function() {
			var control = this,
				sectionId = control.section(),
				section;
			if ( ! sectionId ) {
				return;
			}
			section = api.section( sectionId );
			if ( ( section &amp;&amp; section.expanded() ) || api.settings.autofocus.control === control.id ) {
				control.actuallyEmbed();
			}
		},

		/**
		 * This function is called in Section.onChangeExpanded() so the control
		 * will only get embedded when the Section is first expanded.
		 *
		 * @since 4.3.0
		 */
		actuallyEmbed: function() {
			var control = this;
			if ( &#039;resolved&#039; === control.deferred.embedded.state() ) {
				return;
			}
			control.renderContent();
			control.deferred.embedded.resolve(); // This triggers control.ready().
			
			// Mark all menu items as unprocessed.
			$( &#039;button.item-edit&#039; ).data( &#039;needs_accessibility_refresh&#039;, true );
		},

		/**
		 * Set up the control.
		 */
		ready: function() {
			if ( &#039;undefined&#039; === typeof this.params.menu_item_id ) {
				throw new Error( &#039;params.menu_item_id was not defined&#039; );
			}

			this._setupControlToggle();
			this._setupReorderUI();
			this._setupUpdateUI();
			this._setupRemoveUI();
			this._setupLinksUI();
			this._setupTitleUI();
		},

		/**
		 * Show/hide the settings when clicking on the menu item handle.
		 */
		_setupControlToggle: function() {
			var control = this;

			this.container.find( &#039;.menu-item-handle&#039; ).on( &#039;click&#039;, function( e ) {
				e.preventDefault();
				e.stopPropagation();
				var menuControl = control.getMenuControl(),
					isDeleteBtn = $( e.target ).is( &#039;.item-delete, .item-delete *&#039; ),
					isAddNewBtn = $( e.target ).is( &#039;.add-new-menu-item, .add-new-menu-item *&#039; );

				if ( $( &#039;body&#039; ).hasClass( &#039;adding-menu-items&#039; ) &amp;&amp; ! isDeleteBtn &amp;&amp; ! isAddNewBtn ) {
					api.Menus.availableMenuItemsPanel.close();
				}

				if ( menuControl.isReordering || menuControl.isSorting ) {
					return;
				}
				control.toggleForm();
			} );
		},

		/**
		 * Set up the menu-item-reorder-nav
		 */
		_setupReorderUI: function() {
			var control = this, template, $reorderNav;

			template = wp.template( &#039;menu-item-reorder-nav&#039; );

			// Add the menu item reordering elements to the menu item control.
			control.container.find( &#039;.item-controls&#039; ).after( template );

			// Handle clicks for up/down/left-right on the reorder nav.
			$reorderNav = control.container.find( &#039;.menu-item-reorder-nav&#039; );
			$reorderNav.find( &#039;.menus-move-up, .menus-move-down, .menus-move-left, .menus-move-right&#039; ).on( &#039;click&#039;, function() {
				var moveBtn = $( this );
				control.params.depth = control.getDepth();

				moveBtn.focus();

				var isMoveUp = moveBtn.is( &#039;.menus-move-up&#039; ),
					isMoveDown = moveBtn.is( &#039;.menus-move-down&#039; ),
					isMoveLeft = moveBtn.is( &#039;.menus-move-left&#039; ),
					isMoveRight = moveBtn.is( &#039;.menus-move-right&#039; );

				if ( isMoveUp ) {
					control.moveUp();
				} else if ( isMoveDown ) {
					control.moveDown();
				} else if ( isMoveLeft ) {
					control.moveLeft();
				} else if ( isMoveRight ) {
					control.moveRight();
					control.params.depth += 1;
				}
				
				moveBtn.focus(); // Re-focus after the container was moved.

				// Mark all menu items as unprocessed.
				$( &#039;button.item-edit&#039; ).data( &#039;needs_accessibility_refresh&#039;, true );
			} );
		},

		/**
		 * Set up event handlers for menu item updating.
		 */
		_setupUpdateUI: function() {
			var control = this,
				settingValue = control.setting(),
				updateNotifications;

			control.elements = {};
			control.elements.url = new api.Element( control.container.find( &#039;.edit-menu-item-url&#039; ) );
			control.elements.title = new api.Element( control.container.find( &#039;.edit-menu-item-title&#039; ) );
			control.elements.attr_title = new api.Element( control.container.find( &#039;.edit-menu-item-attr-title&#039; ) );
			control.elements.target = new api.Element( control.container.find( &#039;.edit-menu-item-target&#039; ) );
			control.elements.classes = new api.Element( control.container.find( &#039;.edit-menu-item-classes&#039; ) );
			control.elements.xfn = new api.Element( control.container.find( &#039;.edit-menu-item-xfn&#039; ) );
			control.elements.description = new api.Element( control.container.find( &#039;.edit-menu-item-description&#039; ) );
			// @todo Allow other elements, added by plugins, to be automatically picked up here;
			// allow additional values to be added to setting array.

			_.each( control.elements, function( element, property ) {
				element.bind(function( value ) {
					if ( element.element.is( &#039;input[type=checkbox]&#039; ) ) {
						value = ( value ) ? element.element.val() : &#039;&#039;;
					}

					var settingValue = control.setting();
					if ( settingValue &amp;&amp; settingValue[ property ] !== value ) {
						settingValue = _.clone( settingValue );
						settingValue[ property ] = value;
						control.setting.set( settingValue );
					}
				});
				if ( settingValue ) {
					if ( ( property === &#039;classes&#039; || property === &#039;xfn&#039; ) &amp;&amp; _.isArray( settingValue[ property ] ) ) {
						element.set( settingValue[ property ].join( &#039; &#039; ) );
					} else {
						element.set( settingValue[ property ] );
					}
				}
			});

			control.setting.bind(function( to, from ) {
				var itemId = control.params.menu_item_id,
					followingSiblingItemControls = [],
					childrenItemControls = [],
					menuControl;

				if ( false === to ) {
					menuControl = api.control( &#039;nav_menu[&#039; + String( from.nav_menu_term_id ) + &#039;]&#039; );
					control.container.remove();

					_.each( menuControl.getMenuItemControls(), function( otherControl ) {
						if ( from.menu_item_parent === otherControl.setting().menu_item_parent &amp;&amp; otherControl.setting().position &gt; from.position ) {
							followingSiblingItemControls.push( otherControl );
						} else if ( otherControl.setting().menu_item_parent === itemId ) {
							childrenItemControls.push( otherControl );
						}
					});

					// Shift all following siblings by the number of children this item has.
					_.each( followingSiblingItemControls, function( followingSiblingItemControl ) {
						var value = _.clone( followingSiblingItemControl.setting() );
						value.position += childrenItemControls.length;
						followingSiblingItemControl.setting.set( value );
					});

					// Now move the children up to be the new subsequent siblings.
					_.each( childrenItemControls, function( childrenItemControl, i ) {
						var value = _.clone( childrenItemControl.setting() );
						value.position = from.position + i;
						value.menu_item_parent = from.menu_item_parent;
						childrenItemControl.setting.set( value );
					});

					menuControl.debouncedReflowMenuItems();
				} else {
					// Update the elements&#039; values to match the new setting properties.
					_.each( to, function( value, key ) {
						if ( control.elements[ key] ) {
							control.elements[ key ].set( to[ key ] );
						}
					} );
					control.container.find( &#039;.menu-item-data-parent-id&#039; ).val( to.menu_item_parent );

					// Handle UI updates when the position or depth (parent) change.
					if ( to.position !== from.position || to.menu_item_parent !== from.menu_item_parent ) {
						control.getMenuControl().debouncedReflowMenuItems();
					}
				}
			});

			// Style the URL field as invalid when there is an invalid_url notification.
			updateNotifications = function() {
				control.elements.url.element.toggleClass( &#039;invalid&#039;, control.setting.notifications.has( &#039;invalid_url&#039; ) );
			};
			control.setting.notifications.bind( &#039;add&#039;, updateNotifications );
			control.setting.notifications.bind( &#039;removed&#039;, updateNotifications );
		},

		/**
		 * Set up event handlers for menu item deletion.
		 */
		_setupRemoveUI: function() {
			var control = this, $removeBtn;

			// Configure delete button.
			$removeBtn = control.container.find( &#039;.item-delete&#039; );

			$removeBtn.on( &#039;click&#039;, function() {
				// Find an adjacent element to add focus to when this menu item goes away.
				var addingItems = true, $adjacentFocusTarget, $next, $prev,
					instanceCounter = 0, // Instance count of the menu item deleted.
					deleteItemOriginalItemId = control.params.original_item_id,
					addedItems = control.getMenuControl().$sectionContent.find( &#039;.menu-item&#039; ),
					availableMenuItem;

				if ( ! $( &#039;body&#039; ).hasClass( &#039;adding-menu-items&#039; ) ) {
					addingItems = false;
				}

				$next = control.container.nextAll( &#039;.customize-control-nav_menu_item:visible&#039; ).first();
				$prev = control.container.prevAll( &#039;.customize-control-nav_menu_item:visible&#039; ).first();

				if ( $next.length ) {
					$adjacentFocusTarget = $next.find( false === addingItems ? &#039;.item-edit&#039; : &#039;.item-delete&#039; ).first();
				} else if ( $prev.length ) {
					$adjacentFocusTarget = $prev.find( false === addingItems ? &#039;.item-edit&#039; : &#039;.item-delete&#039; ).first();
				} else {
					$adjacentFocusTarget = control.container.nextAll( &#039;.customize-control-nav_menu&#039; ).find( &#039;.add-new-menu-item&#039; ).first();
				}

				/*
				 * If the menu item deleted is the only of its instance left,
				 * remove the check icon of this menu item in the right panel.
				 */
				_.each( addedItems, function( addedItem ) {
					var menuItemId, menuItemControl, matches;

					// This is because menu item that&#039;s deleted is just hidden.
					if ( ! $( addedItem ).is( &#039;:visible&#039; ) ) {
						return;
					}

					matches = addedItem.getAttribute( &#039;id&#039; ).match( /^customize-control-nav_menu_item-(-?\d+)$/, &#039;&#039; );
					if ( ! matches ) {
						return;
					}

					menuItemId      = parseInt( matches[1], 10 );
					menuItemControl = api.control( &#039;nav_menu_item[&#039; + String( menuItemId ) + &#039;]&#039; );

					// Check for duplicate menu items.
					if ( menuItemControl &amp;&amp; deleteItemOriginalItemId == menuItemControl.params.original_item_id ) {
						instanceCounter++;
					}
				} );

				if ( instanceCounter &lt;= 1 ) {
					// Revert the check icon to add icon.
					availableMenuItem = $( &#039;#menu-item-tpl-&#039; + control.params.original_item_id );
					availableMenuItem.removeClass( &#039;selected&#039; );
					availableMenuItem.find( &#039;.menu-item-handle&#039; ).removeClass( &#039;item-added&#039; );
				}

				control.container.slideUp( function() {
					control.setting.set( false );
					wp.a11y.speak( api.Menus.data.l10n.itemDeleted );
					$adjacentFocusTarget.focus(); // Keyboard accessibility.
				} );

				control.setting.set( false );
			} );
		},

		_setupLinksUI: function() {
			var $origBtn;

			// Configure original link.
			$origBtn = this.container.find( &#039;a.original-link&#039; );

			$origBtn.on( &#039;click&#039;, function( e ) {
				e.preventDefault();
				api.previewer.previewUrl( e.target.toString() );
			} );
		},

		/**
		 * Update item handle title when changed.
		 */
		_setupTitleUI: function() {
			var control = this, titleEl;

			// Ensure that whitespace is trimmed on blur so placeholder can be shown.
			control.container.find( &#039;.edit-menu-item-title&#039; ).on( &#039;blur&#039;, function() {
				$( this ).val( $( this ).val().trim() );
			} );

			titleEl = control.container.find( &#039;.menu-item-title&#039; );
			control.setting.bind( function( item ) {
				var trimmedTitle, titleText;
				if ( ! item ) {
					return;
				}
				item.title = item.title || &#039;&#039;;
				trimmedTitle = item.title.trim();

				titleText = trimmedTitle || item.original_title || api.Menus.data.l10n.untitled;

				if ( item._invalid ) {
					titleText = api.Menus.data.l10n.invalidTitleTpl.replace( &#039;%s&#039;, titleText );
				}

				// Don&#039;t update to an empty title.
				if ( trimmedTitle || item.original_title ) {
					titleEl
						.text( titleText )
						.removeClass( &#039;no-title&#039; );
				} else {
					titleEl
						.text( titleText )
						.addClass( &#039;no-title&#039; );
				}
			} );
		},

		/**
		 *
		 * @return {number}
		 */
		getDepth: function() {
			var control = this, setting = control.setting(), depth = 0;
			if ( ! setting ) {
				return 0;
			}
			while ( setting &amp;&amp; setting.menu_item_parent ) {
				depth += 1;
				control = api.control( &#039;nav_menu_item[&#039; + setting.menu_item_parent + &#039;]&#039; );
				if ( ! control ) {
					break;
				}
				setting = control.setting();
			}
			return depth;
		},

		/**
		 * Amend the control&#039;s params with the data necessary for the JS template just in time.
		 */
		renderContent: function() {
			var control = this,
				settingValue = control.setting(),
				containerClasses;

			control.params.title = settingValue.title || &#039;&#039;;
			control.params.depth = control.getDepth();
			control.container.data( &#039;item-depth&#039;, control.params.depth );
			containerClasses = [
				&#039;menu-item&#039;,
				&#039;menu-item-depth-&#039; + String( control.params.depth ),
				&#039;menu-item-&#039; + settingValue.object,
				&#039;menu-item-edit-inactive&#039;
			];

			if ( settingValue._invalid ) {
				containerClasses.push( &#039;menu-item-invalid&#039; );
				control.params.title = api.Menus.data.l10n.invalidTitleTpl.replace( &#039;%s&#039;, control.params.title );
			} else if ( &#039;draft&#039; === settingValue.status ) {
				containerClasses.push( &#039;pending&#039; );
				control.params.title = api.Menus.data.pendingTitleTpl.replace( &#039;%s&#039;, control.params.title );
			}

			control.params.el_classes = containerClasses.join( &#039; &#039; );
			control.params.item_type_label = settingValue.type_label;
			control.params.item_type = settingValue.type;
			control.params.url = settingValue.url;
			control.params.target = settingValue.target;
			control.params.attr_title = settingValue.attr_title;
			control.params.classes = _.isArray( settingValue.classes ) ? settingValue.classes.join( &#039; &#039; ) : settingValue.classes;
			control.params.xfn = settingValue.xfn;
			control.params.description = settingValue.description;
			control.params.parent = settingValue.menu_item_parent;
			control.params.original_title = settingValue.original_title || &#039;&#039;;

			control.container.addClass( control.params.el_classes );

			api.Control.prototype.renderContent.call( control );
		},

		/***********************************************************************
		 * Begin public API methods
		 **********************************************************************/

		/**
		 * @return {wp.customize.controlConstructor.nav_menu|null}
		 */
		getMenuControl: function() {
			var control = this, settingValue = control.setting();
			if ( settingValue &amp;&amp; settingValue.nav_menu_term_id ) {
				return api.control( &#039;nav_menu[&#039; + settingValue.nav_menu_term_id + &#039;]&#039; );
			} else {
				return null;
			}
		},

		/**
		 * Expand the accordion section containing a control
		 */
		expandControlSection: function() {
			var $section = this.container.closest( &#039;.accordion-section&#039; );
			if ( ! $section.hasClass( &#039;open&#039; ) ) {
				$section.find( &#039;.accordion-section-title:first&#039; ).trigger( &#039;click&#039; );
			}
		},

		/**
		 * @since 4.6.0
		 *
		 * @param {Boolean} expanded
		 * @param {Object} [params]
		 * @return {Boolean} False if state already applied.
		 */
		_toggleExpanded: api.Section.prototype._toggleExpanded,

		/**
		 * @since 4.6.0
		 *
		 * @param {Object} [params]
		 * @return {Boolean} False if already expanded.
		 */
		expand: api.Section.prototype.expand,

		/**
		 * Expand the menu item form control.
		 *
		 * @since 4.5.0 Added params.completeCallback.
		 *
		 * @param {Object}   [params] - Optional params.
		 * @param {Function} [params.completeCallback] - Function to call when the form toggle has finished animating.
		 */
		expandForm: function( params ) {
			this.expand( params );
		},

		/**
		 * @since 4.6.0
		 *
		 * @param {Object} [params]
		 * @return {Boolean} False if already collapsed.
		 */
		collapse: api.Section.prototype.collapse,

		/**
		 * Collapse the menu item form control.
		 *
		 * @since 4.5.0 Added params.completeCallback.
		 *
		 * @param {Object}   [params] - Optional params.
		 * @param {Function} [params.completeCallback] - Function to call when the form toggle has finished animating.
		 */
		collapseForm: function( params ) {
			this.collapse( params );
		},

		/**
		 * Expand or collapse the menu item control.
		 *
		 * @deprecated this is poor naming, and it is better to directly set control.expanded( showOrHide )
		 * @since 4.5.0 Added params.completeCallback.
		 *
		 * @param {boolean}  [showOrHide] - If not supplied, will be inverse of current visibility
		 * @param {Object}   [params] - Optional params.
		 * @param {Function} [params.completeCallback] - Function to call when the form toggle has finished animating.
		 */
		toggleForm: function( showOrHide, params ) {
			if ( typeof showOrHide === &#039;undefined&#039; ) {
				showOrHide = ! this.expanded();
			}
			if ( showOrHide ) {
				this.expand( params );
			} else {
				this.collapse( params );
			}
		},

		/**
		 * Expand or collapse the menu item control.
		 *
		 * @since 4.6.0
		 * @param {boolean}  [showOrHide] - If not supplied, will be inverse of current visibility
		 * @param {Object}   [params] - Optional params.
		 * @param {Function} [params.completeCallback] - Function to call when the form toggle has finished animating.
		 */
		onChangeExpanded: function( showOrHide, params ) {
			var self = this, $menuitem, $inside, complete;

			$menuitem = this.container;
			$inside = $menuitem.find( &#039;.menu-item-settings:first&#039; );
			if ( &#039;undefined&#039; === typeof showOrHide ) {
				showOrHide = ! $inside.is( &#039;:visible&#039; );
			}

			// Already expanded or collapsed.
			if ( $inside.is( &#039;:visible&#039; ) === showOrHide ) {
				if ( params &amp;&amp; params.completeCallback ) {
					params.completeCallback();
				}
				return;
			}

			if ( showOrHide ) {
				// Close all other menu item controls before expanding this one.
				api.control.each( function( otherControl ) {
					if ( self.params.type === otherControl.params.type &amp;&amp; self !== otherControl ) {
						otherControl.collapseForm();
					}
				} );

				complete = function() {
					$menuitem
						.removeClass( &#039;menu-item-edit-inactive&#039; )
						.addClass( &#039;menu-item-edit-active&#039; );
					self.container.trigger( &#039;expanded&#039; );

					if ( params &amp;&amp; params.completeCallback ) {
						params.completeCallback();
					}
				};

				$menuitem.find( &#039;.item-edit&#039; ).attr( &#039;aria-expanded&#039;, &#039;true&#039; );
				$inside.slideDown( &#039;fast&#039;, complete );

				self.container.trigger( &#039;expand&#039; );
			} else {
				complete = function() {
					$menuitem
						.addClass( &#039;menu-item-edit-inactive&#039; )
						.removeClass( &#039;menu-item-edit-active&#039; );
					self.container.trigger( &#039;collapsed&#039; );

					if ( params &amp;&amp; params.completeCallback ) {
						params.completeCallback();
					}
				};

				self.container.trigger( &#039;collapse&#039; );

				$menuitem.find( &#039;.item-edit&#039; ).attr( &#039;aria-expanded&#039;, &#039;false&#039; );
				$inside.slideUp( &#039;fast&#039;, complete );
			}
		},

		/**
		 * Expand the containing menu section, expand the form, and focus on
		 * the first input in the control.
		 *
		 * @since 4.5.0 Added params.completeCallback.
		 *
		 * @param {Object}   [params] - Params object.
		 * @param {Function} [params.completeCallback] - Optional callback function when focus has completed.
		 */
		focus: function( params ) {
			params = params || {};
			var control = this, originalCompleteCallback = params.completeCallback, focusControl;

			focusControl = function() {
				control.expandControlSection();

				params.completeCallback = function() {
					var focusable;

					// Note that we can&#039;t use :focusable due to a jQuery UI issue. See: https://github.com/jquery/jquery-ui/pull/1583
					focusable = control.container.find( &#039;.menu-item-settings&#039; ).find( &#039;input, select, textarea, button, object, a[href], [tabindex]&#039; ).filter( &#039;:visible&#039; );
					focusable.first().focus();

					if ( originalCompleteCallback ) {
						originalCompleteCallback();
					}
				};

				control.expandForm( params );
			};

			if ( api.section.has( control.section() ) ) {
				api.section( control.section() ).expand( {
					completeCallback: focusControl
				} );
			} else {
				focusControl();
			}
		},

		/**
		 * Move menu item up one in the menu.
		 */
		moveUp: function() {
			this._changePosition( -1 );
			wp.a11y.speak( api.Menus.data.l10n.movedUp );
		},

		/**
		 * Move menu item up one in the menu.
		 */
		moveDown: function() {
			this._changePosition( 1 );
			wp.a11y.speak( api.Menus.data.l10n.movedDown );
		},
		/**
		 * Move menu item and all children up one level of depth.
		 */
		moveLeft: function() {
			this._changeDepth( -1 );
			wp.a11y.speak( api.Menus.data.l10n.movedLeft );
		},

		/**
		 * Move menu item and children one level deeper, as a submenu of the previous item.
		 */
		moveRight: function() {
			this._changeDepth( 1 );
			wp.a11y.speak( api.Menus.data.l10n.movedRight );
		},

		/**
		 * Note that this will trigger a UI update, causing child items to
		 * move as well and cardinal order class names to be updated.
		 *
		 * @private
		 *
		 * @param {number} offset 1|-1
		 */
		_changePosition: function( offset ) {
			var control = this,
				adjacentSetting,
				settingValue = _.clone( control.setting() ),
				siblingSettings = [],
				realPosition;

			if ( 1 !== offset &amp;&amp; -1 !== offset ) {
				throw new Error( &#039;Offset changes by 1 are only supported.&#039; );
			}

			// Skip moving deleted items.
			if ( ! control.setting() ) {
				return;
			}

			// Locate the other items under the same parent (siblings).
			_( control.getMenuControl().getMenuItemControls() ).each(function( otherControl ) {
				if ( otherControl.setting().menu_item_parent === settingValue.menu_item_parent ) {
					siblingSettings.push( otherControl.setting );
				}
			});
			siblingSettings.sort(function( a, b ) {
				return a().position - b().position;
			});

			realPosition = _.indexOf( siblingSettings, control.setting );
			if ( -1 === realPosition ) {
				throw new Error( &#039;Expected setting to be among siblings.&#039; );
			}

			// Skip doing anything if the item is already at the edge in the desired direction.
			if ( ( realPosition === 0 &amp;&amp; offset &lt; 0 ) || ( realPosition === siblingSettings.length - 1 &amp;&amp; offset &gt; 0 ) ) {
				// @todo Should we allow a menu item to be moved up to break it out of a parent? Adopt with previous or following parent?
				return;
			}

			// Update any adjacent menu item setting to take on this item&#039;s position.
			adjacentSetting = siblingSettings[ realPosition + offset ];
			if ( adjacentSetting ) {
				adjacentSetting.set( $.extend(
					_.clone( adjacentSetting() ),
					{
						position: settingValue.position
					}
				) );
			}

			settingValue.position += offset;
			control.setting.set( settingValue );
		},

		/**
		 * Note that this will trigger a UI update, causing child items to
		 * move as well and cardinal order class names to be updated.
		 *
		 * @private
		 *
		 * @param {number} offset 1|-1
		 */
		_changeDepth: function( offset ) {
			if ( 1 !== offset &amp;&amp; -1 !== offset ) {
				throw new Error( &#039;Offset changes by 1 are only supported.&#039; );
			}
			var control = this,
				settingValue = _.clone( control.setting() ),
				siblingControls = [],
				realPosition,
				siblingControl,
				parentControl;

			// Locate the other items under the same parent (siblings).
			_( control.getMenuControl().getMenuItemControls() ).each(function( otherControl ) {
				if ( otherControl.setting().menu_item_parent === settingValue.menu_item_parent ) {
					siblingControls.push( otherControl );
				}
			});
			siblingControls.sort(function( a, b ) {
				return a.setting().position - b.setting().position;
			});

			realPosition = _.indexOf( siblingControls, control );
			if ( -1 === realPosition ) {
				throw new Error( &#039;Expected control to be among siblings.&#039; );
			}

			if ( -1 === offset ) {
				// Skip moving left an item that is already at the top level.
				if ( ! settingValue.menu_item_parent ) {
					return;
				}

				parentControl = api.control( &#039;nav_menu_item[&#039; + settingValue.menu_item_parent + &#039;]&#039; );

				// Make this control the parent of all the following siblings.
				_( siblingControls ).chain().slice( realPosition ).each(function( siblingControl, i ) {
					siblingControl.setting.set(
						$.extend(
							{},
							siblingControl.setting(),
							{
								menu_item_parent: control.params.menu_item_id,
								position: i
							}
						)
					);
				});

				// Increase the positions of the parent item&#039;s subsequent children to make room for this one.
				_( control.getMenuControl().getMenuItemControls() ).each(function( otherControl ) {
					var otherControlSettingValue, isControlToBeShifted;
					isControlToBeShifted = (
						otherControl.setting().menu_item_parent === parentControl.setting().menu_item_parent &amp;&amp;
						otherControl.setting().position &gt; parentControl.setting().position
					);
					if ( isControlToBeShifted ) {
						otherControlSettingValue = _.clone( otherControl.setting() );
						otherControl.setting.set(
							$.extend(
								otherControlSettingValue,
								{ position: otherControlSettingValue.position + 1 }
							)
						);
					}
				});

				// Make this control the following sibling of its parent item.
				settingValue.position = parentControl.setting().position + 1;
				settingValue.menu_item_parent = parentControl.setting().menu_item_parent;
				control.setting.set( settingValue );

			} else if ( 1 === offset ) {
				// Skip moving right an item that doesn&#039;t have a previous sibling.
				if ( realPosition === 0 ) {
					return;
				}

				// Make the control the last child of the previous sibling.
				siblingControl = siblingControls[ realPosition - 1 ];
				settingValue.menu_item_parent = siblingControl.params.menu_item_id;
				settingValue.position = 0;
				_( control.getMenuControl().getMenuItemControls() ).each(function( otherControl ) {
					if ( otherControl.setting().menu_item_parent === settingValue.menu_item_parent ) {
						settingValue.position = Math.max( settingValue.position, otherControl.setting().position );
					}
				});
				settingValue.position += 1;
				control.setting.set( settingValue );
			}
		}
	} );

	/**
	 * wp.customize.Menus.MenuNameControl
	 *
	 * Customizer control for a nav menu&#039;s name.
	 *
	 * @class    wp.customize.Menus.MenuNameControl
	 * @augments wp.customize.Control
	 */
	api.Menus.MenuNameControl = api.Control.extend(/** @lends wp.customize.Menus.MenuNameControl.prototype */{

		ready: function() {
			var control = this;

			if ( control.setting ) {
				var settingValue = control.setting();

				control.nameElement = new api.Element( control.container.find( &#039;.menu-name-field&#039; ) );

				control.nameElement.bind(function( value ) {
					var settingValue = control.setting();
					if ( settingValue &amp;&amp; settingValue.name !== value ) {
						settingValue = _.clone( settingValue );
						settingValue.name = value;
						control.setting.set( settingValue );
					}
				});
				if ( settingValue ) {
					control.nameElement.set( settingValue.name );
				}

				control.setting.bind(function( object ) {
					if ( object ) {
						control.nameElement.set( object.name );
					}
				});
			}
		}
	});

	/**
	 * wp.customize.Menus.MenuLocationsControl
	 *
	 * Customizer control for a nav menu&#039;s locations.
	 *
	 * @since 4.9.0
	 * @class    wp.customize.Menus.MenuLocationsControl
	 * @augments wp.customize.Control
	 */
	api.Menus.MenuLocationsControl = api.Control.extend(/** @lends wp.customize.Menus.MenuLocationsControl.prototype */{

		/**
		 * Set up the control.
		 *
		 * @since 4.9.0
		 */
		ready: function () {
			var control = this;

			control.container.find( &#039;.assigned-menu-location&#039; ).each(function() {
				var container = $( this ),
					checkbox = container.find( &#039;input[type=checkbox]&#039; ),
					element = new api.Element( checkbox ),
					navMenuLocationSetting = api( &#039;nav_menu_locations[&#039; + checkbox.data( &#039;location-id&#039; ) + &#039;]&#039; ),
					isNewMenu = control.params.menu_id === &#039;&#039;,
					updateCheckbox = isNewMenu ? _.noop : function( checked ) {
						element.set( checked );
					},
					updateSetting = isNewMenu ? _.noop : function( checked ) {
						navMenuLocationSetting.set( checked ? control.params.menu_id : 0 );
					},
					updateSelectedMenuLabel = function( selectedMenuId ) {
						var menuSetting = api( &#039;nav_menu[&#039; + String( selectedMenuId ) + &#039;]&#039; );
						if ( ! selectedMenuId || ! menuSetting || ! menuSetting() ) {
							container.find( &#039;.theme-location-set&#039; ).hide();
						} else {
							container.find( &#039;.theme-location-set&#039; ).show().find( &#039;span&#039; ).text( displayNavMenuName( menuSetting().name ) );
						}
					};

				updateCheckbox( navMenuLocationSetting.get() === control.params.menu_id );

				checkbox.on( &#039;change&#039;, function() {
					// Note: We can&#039;t use element.bind( function( checked ){ ... } ) here because it will trigger a change as well.
					updateSetting( this.checked );
				} );

				navMenuLocationSetting.bind( function( selectedMenuId ) {
					updateCheckbox( selectedMenuId === control.params.menu_id );
					updateSelectedMenuLabel( selectedMenuId );
				} );
				updateSelectedMenuLabel( navMenuLocationSetting.get() );
			});
		},

		/**
		 * Set the selected locations.
		 *
		 * This method sets the selected locations and allows us to do things like
		 * set the default location for a new menu.
		 *
		 * @since 4.9.0
		 *
		 * @param {Object.&lt;string,boolean&gt;} selections - A map of location selections.
		 * @return {void}
		 */
		setSelections: function( selections ) {
			this.container.find( &#039;.menu-location&#039; ).each( function( i, checkboxNode ) {
				var locationId = checkboxNode.dataset.locationId;
				checkboxNode.checked = locationId in selections ? selections[ locationId ] : false;
			} );
		}
	});

	/**
	 * wp.customize.Menus.MenuAutoAddControl
	 *
	 * Customizer control for a nav menu&#039;s auto add.
	 *
	 * @class    wp.customize.Menus.MenuAutoAddControl
	 * @augments wp.customize.Control
	 */
	api.Menus.MenuAutoAddControl = api.Control.extend(/** @lends wp.customize.Menus.MenuAutoAddControl.prototype */{

		ready: function() {
			var control = this,
				settingValue = control.setting();

			/*
			 * Since the control is not registered in PHP, we need to prevent the
			 * preview&#039;s sending of the activeControls to result in this control
			 * being deactivated.
			 */
			control.active.validate = function() {
				var value, section = api.section( control.section() );
				if ( section ) {
					value = section.active();
				} else {
					value = false;
				}
				return value;
			};

			control.autoAddElement = new api.Element( control.container.find( &#039;input[type=checkbox].auto_add&#039; ) );

			control.autoAddElement.bind(function( value ) {
				var settingValue = control.setting();
				if ( settingValue &amp;&amp; settingValue.name !== value ) {
					settingValue = _.clone( settingValue );
					settingValue.auto_add = value;
					control.setting.set( settingValue );
				}
			});
			if ( settingValue ) {
				control.autoAddElement.set( settingValue.auto_add );
			}

			control.setting.bind(function( object ) {
				if ( object ) {
					control.autoAddElement.set( object.auto_add );
				}
			});
		}

	});

	/**
	 * wp.customize.Menus.MenuControl
	 *
	 * Customizer control for menus.
	 * Note that &#039;nav_menu&#039; must match the WP_Menu_Customize_Control::$type
	 *
	 * @class    wp.customize.Menus.MenuControl
	 * @augments wp.customize.Control
	 */
	api.Menus.MenuControl = api.Control.extend(/** @lends wp.customize.Menus.MenuControl.prototype */{
		/**
		 * Set up the control.
		 */
		ready: function() {
			var control = this,
				section = api.section( control.section() ),
				menuId = control.params.menu_id,
				menu = control.setting(),
				name,
				widgetTemplate,
				select;

			if ( &#039;undefined&#039; === typeof this.params.menu_id ) {
				throw new Error( &#039;params.menu_id was not defined&#039; );
			}

			/*
			 * Since the control is not registered in PHP, we need to prevent the
			 * preview&#039;s sending of the activeControls to result in this control
			 * being deactivated.
			 */
			control.active.validate = function() {
				var value;
				if ( section ) {
					value = section.active();
				} else {
					value = false;
				}
				return value;
			};

			control.$controlSection = section.headContainer;
			control.$sectionContent = control.container.closest( &#039;.accordion-section-content&#039; );

			this._setupModel();

			api.section( control.section(), function( section ) {
				section.deferred.initSortables.done(function( menuList ) {
					control._setupSortable( menuList );
				});
			} );

			this._setupAddition();
			this._setupTitle();

			// Add menu to Navigation Menu widgets.
			if ( menu ) {
				name = displayNavMenuName( menu.name );

				// Add the menu to the existing controls.
				api.control.each( function( widgetControl ) {
					if ( ! widgetControl.extended( api.controlConstructor.widget_form ) || &#039;nav_menu&#039; !== widgetControl.params.widget_id_base ) {
						return;
					}
					widgetControl.container.find( &#039;.nav-menu-widget-form-controls:first&#039; ).show();
					widgetControl.container.find( &#039;.nav-menu-widget-no-menus-message:first&#039; ).hide();

					select = widgetControl.container.find( &#039;select&#039; );
					if ( 0 === select.find( &#039;option[value=&#039; + String( menuId ) + &#039;]&#039; ).length ) {
						select.append( new Option( name, menuId ) );
					}
				} );

				// Add the menu to the widget template.
				widgetTemplate = $( &#039;#available-widgets-list .widget-tpl:has( input.id_base[ value=nav_menu ] )&#039; );
				widgetTemplate.find( &#039;.nav-menu-widget-form-controls:first&#039; ).show();
				widgetTemplate.find( &#039;.nav-menu-widget-no-menus-message:first&#039; ).hide();
				select = widgetTemplate.find( &#039;.widget-inside select:first&#039; );
				if ( 0 === select.find( &#039;option[value=&#039; + String( menuId ) + &#039;]&#039; ).length ) {
					select.append( new Option( name, menuId ) );
				}
			}

			/*
			 * Wait for menu items to be added.
			 * Ideally, we&#039;d bind to an event indicating construction is complete,
			 * but deferring appears to be the best option today.
			 */
			_.defer( function () {
				control.updateInvitationVisibility();
			} );
		},

		/**
		 * Update ordering of menu item controls when the setting is updated.
		 */
		_setupModel: function() {
			var control = this,
				menuId = control.params.menu_id;

			control.setting.bind( function( to ) {
				var name;
				if ( false === to ) {
					control._handleDeletion();
				} else {
					// Update names in the Navigation Menu widgets.
					name = displayNavMenuName( to.name );
					api.control.each( function( widgetControl ) {
						if ( ! widgetControl.extended( api.controlConstructor.widget_form ) || &#039;nav_menu&#039; !== widgetControl.params.widget_id_base ) {
							return;
						}
						var select = widgetControl.container.find( &#039;select&#039; );
						select.find( &#039;option[value=&#039; + String( menuId ) + &#039;]&#039; ).text( name );
					});
				}
			} );
		},

		/**
		 * Allow items in each menu to be re-ordered, and for the order to be previewed.
		 *
		 * Notice that the UI aspects here are handled by wpNavMenu.initSortables()
		 * which is called in MenuSection.onChangeExpanded()
		 *
		 * @param {Object} menuList - The element that has sortable().
		 */
		_setupSortable: function( menuList ) {
			var control = this;

			if ( ! menuList.is( control.$sectionContent ) ) {
				throw new Error( &#039;Unexpected menuList.&#039; );
			}

			menuList.on( &#039;sortstart&#039;, function() {
				control.isSorting = true;
			});

			menuList.on( &#039;sortstop&#039;, function() {
				setTimeout( function() { // Next tick.
					var menuItemContainerIds = control.$sectionContent.sortable( &#039;toArray&#039; ),
						menuItemControls = [],
						position = 0,
						priority = 10;

					control.isSorting = false;

					// Reset horizontal scroll position when done dragging.
					control.$sectionContent.scrollLeft( 0 );

					_.each( menuItemContainerIds, function( menuItemContainerId ) {
						var menuItemId, menuItemControl, matches;
						matches = menuItemContainerId.match( /^customize-control-nav_menu_item-(-?\d+)$/, &#039;&#039; );
						if ( ! matches ) {
							return;
						}
						menuItemId = parseInt( matches[1], 10 );
						menuItemControl = api.control( &#039;nav_menu_item[&#039; + String( menuItemId ) + &#039;]&#039; );
						if ( menuItemControl ) {
							menuItemControls.push( menuItemControl );
						}
					} );

					_.each( menuItemControls, function( menuItemControl ) {
						if ( false === menuItemControl.setting() ) {
							// Skip deleted items.
							return;
						}
						var setting = _.clone( menuItemControl.setting() );
						position += 1;
						priority += 1;
						setting.position = position;
						menuItemControl.priority( priority );

						// Note that wpNavMenu will be setting this .menu-item-data-parent-id input&#039;s value.
						setting.menu_item_parent = parseInt( menuItemControl.container.find( &#039;.menu-item-data-parent-id&#039; ).val(), 10 );
						if ( ! setting.menu_item_parent ) {
							setting.menu_item_parent = 0;
						}

						menuItemControl.setting.set( setting );
					});

					// Mark all menu items as unprocessed.
					$( &#039;button.item-edit&#039; ).data( &#039;needs_accessibility_refresh&#039;, true );
				});

			});
			control.isReordering = false;

			/**
			 * Keyboard-accessible reordering.
			 */
			this.container.find( &#039;.reorder-toggle&#039; ).on( &#039;click&#039;, function() {
				control.toggleReordering( ! control.isReordering );
			} );
		},

		/**
		 * Set up UI for adding a new menu item.
		 */
		_setupAddition: function() {
			var self = this;

			this.container.find( &#039;.add-new-menu-item&#039; ).on( &#039;click&#039;, function( event ) {
				if ( self.$sectionContent.hasClass( &#039;reordering&#039; ) ) {
					return;
				}

				if ( ! $( &#039;body&#039; ).hasClass( &#039;adding-menu-items&#039; ) ) {
					$( this ).attr( &#039;aria-expanded&#039;, &#039;true&#039; );
					api.Menus.availableMenuItemsPanel.open( self );
				} else {
					$( this ).attr( &#039;aria-expanded&#039;, &#039;false&#039; );
					api.Menus.availableMenuItemsPanel.close();
					event.stopPropagation();
				}
			} );
		},

		_handleDeletion: function() {
			var control = this,
				section,
				menuId = control.params.menu_id,
				removeSection,
				widgetTemplate,
				navMenuCount = 0;
			section = api.section( control.section() );
			removeSection = function() {
				section.container.remove();
				api.section.remove( section.id );
			};

			if ( section &amp;&amp; section.expanded() ) {
				section.collapse({
					completeCallback: function() {
						removeSection();
						wp.a11y.speak( api.Menus.data.l10n.menuDeleted );
						api.panel( &#039;nav_menus&#039; ).focus();
					}
				});
			} else {
				removeSection();
			}

			api.each(function( setting ) {
				if ( /^nav_menu\[/.test( setting.id ) &amp;&amp; false !== setting() ) {
					navMenuCount += 1;
				}
			});

			// Remove the menu from any Navigation Menu widgets.
			api.control.each(function( widgetControl ) {
				if ( ! widgetControl.extended( api.controlConstructor.widget_form ) || &#039;nav_menu&#039; !== widgetControl.params.widget_id_base ) {
					return;
				}
				var select = widgetControl.container.find( &#039;select&#039; );
				if ( select.val() === String( menuId ) ) {
					select.prop( &#039;selectedIndex&#039;, 0 ).trigger( &#039;change&#039; );
				}

				widgetControl.container.find( &#039;.nav-menu-widget-form-controls:first&#039; ).toggle( 0 !== navMenuCount );
				widgetControl.container.find( &#039;.nav-menu-widget-no-menus-message:first&#039; ).toggle( 0 === navMenuCount );
				widgetControl.container.find( &#039;option[value=&#039; + String( menuId ) + &#039;]&#039; ).remove();
			});

			// Remove the menu to the nav menu widget template.
			widgetTemplate = $( &#039;#available-widgets-list .widget-tpl:has( input.id_base[ value=nav_menu ] )&#039; );
			widgetTemplate.find( &#039;.nav-menu-widget-form-controls:first&#039; ).toggle( 0 !== navMenuCount );
			widgetTemplate.find( &#039;.nav-menu-widget-no-menus-message:first&#039; ).toggle( 0 === navMenuCount );
			widgetTemplate.find( &#039;option[value=&#039; + String( menuId ) + &#039;]&#039; ).remove();
		},

		/**
		 * Update Section Title as menu name is changed.
		 */
		_setupTitle: function() {
			var control = this;

			control.setting.bind( function( menu ) {
				if ( ! menu ) {
					return;
				}

				var section = api.section( control.section() ),
					menuId = control.params.menu_id,
					controlTitle = section.headContainer.find( &#039;.accordion-section-title&#039; ),
					sectionTitle = section.contentContainer.find( &#039;.customize-section-title h3&#039; ),
					location = section.headContainer.find( &#039;.menu-in-location&#039; ),
					action = sectionTitle.find( &#039;.customize-action&#039; ),
					name = displayNavMenuName( menu.name );

				// Update the control title.
				controlTitle.text( name );
				if ( location.length ) {
					location.appendTo( controlTitle );
				}

				// Update the section title.
				sectionTitle.text( name );
				if ( action.length ) {
					action.prependTo( sectionTitle );
				}

				// Update the nav menu name in location selects.
				api.control.each( function( control ) {
					if ( /^nav_menu_locations\[/.test( control.id ) ) {
						control.container.find( &#039;option[value=&#039; + menuId + &#039;]&#039; ).text( name );
					}
				} );

				// Update the nav menu name in all location checkboxes.
				section.contentContainer.find( &#039;.customize-control-checkbox input&#039; ).each( function() {
					if ( $( this ).prop( &#039;checked&#039; ) ) {
						$( &#039;.current-menu-location-name-&#039; + $( this ).data( &#039;location-id&#039; ) ).text( name );
					}
				} );
			} );
		},

		/***********************************************************************
		 * Begin public API methods
		 **********************************************************************/

		/**
		 * Enable/disable the reordering UI
		 *
		 * @param {boolean} showOrHide to enable/disable reordering
		 */
		toggleReordering: function( showOrHide ) {
			var addNewItemBtn = this.container.find( &#039;.add-new-menu-item&#039; ),
				reorderBtn = this.container.find( &#039;.reorder-toggle&#039; ),
				itemsTitle = this.$sectionContent.find( &#039;.item-title&#039; );

			showOrHide = Boolean( showOrHide );

			if ( showOrHide === this.$sectionContent.hasClass( &#039;reordering&#039; ) ) {
				return;
			}

			this.isReordering = showOrHide;
			this.$sectionContent.toggleClass( &#039;reordering&#039;, showOrHide );
			this.$sectionContent.sortable( this.isReordering ? &#039;disable&#039; : &#039;enable&#039; );
			if ( this.isReordering ) {
				addNewItemBtn.attr({ &#039;tabindex&#039;: &#039;-1&#039;, &#039;aria-hidden&#039;: &#039;true&#039; });
				reorderBtn.attr( &#039;aria-label&#039;, api.Menus.data.l10n.reorderLabelOff );
				wp.a11y.speak( api.Menus.data.l10n.reorderModeOn );
				itemsTitle.attr( &#039;aria-hidden&#039;, &#039;false&#039; );
			} else {
				addNewItemBtn.removeAttr( &#039;tabindex aria-hidden&#039; );
				reorderBtn.attr( &#039;aria-label&#039;, api.Menus.data.l10n.reorderLabelOn );
				wp.a11y.speak( api.Menus.data.l10n.reorderModeOff );
				itemsTitle.attr( &#039;aria-hidden&#039;, &#039;true&#039; );
			}

			if ( showOrHide ) {
				_( this.getMenuItemControls() ).each( function( formControl ) {
					formControl.collapseForm();
				} );
			}
		},

		/**
		 * @return {wp.customize.controlConstructor.nav_menu_item[]}
		 */
		getMenuItemControls: function() {
			var menuControl = this,
				menuItemControls = [],
				menuTermId = menuControl.params.menu_id;

			api.control.each(function( control ) {
				if ( &#039;nav_menu_item&#039; === control.params.type &amp;&amp; control.setting() &amp;&amp; menuTermId === control.setting().nav_menu_term_id ) {
					menuItemControls.push( control );
				}
			});

			return menuItemControls;
		},

		/**
		 * Make sure that each menu item control has the proper depth.
		 */
		reflowMenuItems: function() {
			var menuControl = this,
				menuItemControls = menuControl.getMenuItemControls(),
				reflowRecursively;

			reflowRecursively = function( context ) {
				var currentMenuItemControls = [],
					thisParent = context.currentParent;
				_.each( context.menuItemControls, function( menuItemControl ) {
					if ( thisParent === menuItemControl.setting().menu_item_parent ) {
						currentMenuItemControls.push( menuItemControl );
						// @todo We could remove this item from menuItemControls now, for efficiency.
					}
				});
				currentMenuItemControls.sort( function( a, b ) {
					return a.setting().position - b.setting().position;
				});

				_.each( currentMenuItemControls, function( menuItemControl ) {
					// Update position.
					context.currentAbsolutePosition += 1;
					menuItemControl.priority.set( context.currentAbsolutePosition ); // This will change the sort order.

					// Update depth.
					if ( ! menuItemControl.container.hasClass( &#039;menu-item-depth-&#039; + String( context.currentDepth ) ) ) {
						_.each( menuItemControl.container.prop( &#039;className&#039; ).match( /menu-item-depth-\d+/g ), function( className ) {
							menuItemControl.container.removeClass( className );
						});
						menuItemControl.container.addClass( &#039;menu-item-depth-&#039; + String( context.currentDepth ) );
					}
					menuItemControl.container.data( &#039;item-depth&#039;, context.currentDepth );

					// Process any children items.
					context.currentDepth += 1;
					context.currentParent = menuItemControl.params.menu_item_id;
					reflowRecursively( context );
					context.currentDepth -= 1;
					context.currentParent = thisParent;
				});

				// Update class names for reordering controls.
				if ( currentMenuItemControls.length ) {
					_( currentMenuItemControls ).each(function( menuItemControl ) {
						menuItemControl.container.removeClass( &#039;move-up-disabled move-down-disabled move-left-disabled move-right-disabled&#039; );
						if ( 0 === context.currentDepth ) {
							menuItemControl.container.addClass( &#039;move-left-disabled&#039; );
						} else if ( 10 === context.currentDepth ) {
							menuItemControl.container.addClass( &#039;move-right-disabled&#039; );
						}
					});

					currentMenuItemControls[0].container
						.addClass( &#039;move-up-disabled&#039; )
						.addClass( &#039;move-right-disabled&#039; )
						.toggleClass( &#039;move-down-disabled&#039;, 1 === currentMenuItemControls.length );
					currentMenuItemControls[ currentMenuItemControls.length - 1 ].container
						.addClass( &#039;move-down-disabled&#039; )
						.toggleClass( &#039;move-up-disabled&#039;, 1 === currentMenuItemControls.length );
				}
			};

			reflowRecursively( {
				menuItemControls: menuItemControls,
				currentParent: 0,
				currentDepth: 0,
				currentAbsolutePosition: 0
			} );

			menuControl.updateInvitationVisibility( menuItemControls );
			menuControl.container.find( &#039;.reorder-toggle&#039; ).toggle( menuItemControls.length &gt; 1 );
		},

		/**
		 * Note that this function gets debounced so that when a lot of setting
		 * changes are made at once, for instance when moving a menu item that
		 * has child items, this function will only be called once all of the
		 * settings have been updated.
		 */
		debouncedReflowMenuItems: _.debounce( function() {
			this.reflowMenuItems.apply( this, arguments );
		}, 0 ),

		/**
		 * Add a new item to this menu.
		 *
		 * @param {Object} item - Value for the nav_menu_item setting to be created.
		 * @return {wp.customize.Menus.controlConstructor.nav_menu_item} The newly-created nav_menu_item control instance.
		 */
		addItemToMenu: function( item ) {
			var menuControl = this, customizeId, settingArgs, setting, menuItemControl, placeholderId, position = 0, priority = 10,
				originalItemId = item.id || &#039;&#039;;

			_.each( menuControl.getMenuItemControls(), function( control ) {
				if ( false === control.setting() ) {
					return;
				}
				priority = Math.max( priority, control.priority() );
				if ( 0 === control.setting().menu_item_parent ) {
					position = Math.max( position, control.setting().position );
				}
			});
			position += 1;
			priority += 1;

			item = $.extend(
				{},
				api.Menus.data.defaultSettingValues.nav_menu_item,
				item,
				{
					nav_menu_term_id: menuControl.params.menu_id,
					position: position
				}
			);
			delete item.id; // Only used by Backbone.

			placeholderId = api.Menus.generatePlaceholderAutoIncrementId();
			customizeId = &#039;nav_menu_item[&#039; + String( placeholderId ) + &#039;]&#039;;
			settingArgs = {
				type: &#039;nav_menu_item&#039;,
				transport: api.Menus.data.settingTransport,
				previewer: api.previewer
			};
			setting = api.create( customizeId, customizeId, {}, settingArgs );
			setting.set( item ); // Change from initial empty object to actual item to mark as dirty.

			// Add the menu item control.
			menuItemControl = new api.controlConstructor.nav_menu_item( customizeId, {
				type: &#039;nav_menu_item&#039;,
				section: menuControl.id,
				priority: priority,
				settings: {
					&#039;default&#039;: customizeId
				},
				menu_item_id: placeholderId,
				original_item_id: originalItemId
			} );

			api.control.add( menuItemControl );
			setting.preview();
			menuControl.debouncedReflowMenuItems();

			wp.a11y.speak( api.Menus.data.l10n.itemAdded );

			return menuItemControl;
		},

		/**
		 * Show an invitation to add new menu items when there are no menu items.
		 *
		 * @since 4.9.0
		 *
		 * @param {wp.customize.controlConstructor.nav_menu_item[]} optionalMenuItemControls
		 */
		updateInvitationVisibility: function ( optionalMenuItemControls ) {
			var menuItemControls = optionalMenuItemControls || this.getMenuItemControls();

			this.container.find( &#039;.new-menu-item-invitation&#039; ).toggle( menuItemControls.length === 0 );
		}
	} );

	/**
	 * Extends wp.customize.controlConstructor with control constructor for
	 * menu_location, menu_item, nav_menu, and new_menu.
	 */
	$.extend( api.controlConstructor, {
		nav_menu_location: api.Menus.MenuLocationControl,
		nav_menu_item: api.Menus.MenuItemControl,
		nav_menu: api.Menus.MenuControl,
		nav_menu_name: api.Menus.MenuNameControl,
		nav_menu_locations: api.Menus.MenuLocationsControl,
		nav_menu_auto_add: api.Menus.MenuAutoAddControl
	});

	/**
	 * Extends wp.customize.panelConstructor with section constructor for menus.
	 */
	$.extend( api.panelConstructor, {
		nav_menus: api.Menus.MenusPanel
	});

	/**
	 * Extends wp.customize.sectionConstructor with section constructor for menu.
	 */
	$.extend( api.sectionConstructor, {
		nav_menu: api.Menus.MenuSection,
		new_menu: api.Menus.NewMenuSection
	});

	/**
	 * Init Customizer for menus.
	 */
	api.bind( &#039;ready&#039;, function() {

		// Set up the menu items panel.
		api.Menus.availableMenuItemsPanel = new api.Menus.AvailableMenuItemsPanelView({
			collection: api.Menus.availableMenuItems
		});

		api.bind( &#039;saved&#039;, function( data ) {
			if ( data.nav_menu_updates || data.nav_menu_item_updates ) {
				api.Menus.applySavedData( data );
			}
		} );

		/*
		 * Reset the list of posts created in the customizer once published.
		 * The setting is updated quietly (bypassing events being triggered)
		 * so that the customized state doesn&#039;t become immediately dirty.
		 */
		api.state( &#039;changesetStatus&#039; ).bind( function( status ) {
			if ( &#039;publish&#039; === status ) {
				api( &#039;nav_menus_created_posts&#039; )._value = [];
			}
		} );

		// Open and focus menu control.
		api.previewer.bind( &#039;focus-nav-menu-item-control&#039;, api.Menus.focusMenuItemControl );
	} );

	/**
	 * When customize_save comes back with a success, make sure any inserted
	 * nav menus and items are properly re-added with their newly-assigned IDs.
	 *
	 * @alias wp.customize.Menus.applySavedData
	 *
	 * @param {Object} data
	 * @param {Array} data.nav_menu_updates
	 * @param {Array} data.nav_menu_item_updates
	 */
	api.Menus.applySavedData = function( data ) {

		var insertedMenuIdMapping = {}, insertedMenuItemIdMapping = {};

		_( data.nav_menu_updates ).each(function( update ) {
			var oldCustomizeId, newCustomizeId, customizeId, oldSetting, newSetting, setting, settingValue, oldSection, newSection, wasSaved, widgetTemplate, navMenuCount, shouldExpandNewSection;
			if ( &#039;inserted&#039; === update.status ) {
				if ( ! update.previous_term_id ) {
					throw new Error( &#039;Expected previous_term_id&#039; );
				}
				if ( ! update.term_id ) {
					throw new Error( &#039;Expected term_id&#039; );
				}
				oldCustomizeId = &#039;nav_menu[&#039; + String( update.previous_term_id ) + &#039;]&#039;;
				if ( ! api.has( oldCustomizeId ) ) {
					throw new Error( &#039;Expected setting to exist: &#039; + oldCustomizeId );
				}
				oldSetting = api( oldCustomizeId );
				if ( ! api.section.has( oldCustomizeId ) ) {
					throw new Error( &#039;Expected control to exist: &#039; + oldCustomizeId );
				}
				oldSection = api.section( oldCustomizeId );

				settingValue = oldSetting.get();
				if ( ! settingValue ) {
					throw new Error( &#039;Did not expect setting to be empty (deleted).&#039; );
				}
				settingValue = $.extend( _.clone( settingValue ), update.saved_value );

				insertedMenuIdMapping[ update.previous_term_id ] = update.term_id;
				newCustomizeId = &#039;nav_menu[&#039; + String( update.term_id ) + &#039;]&#039;;
				newSetting = api.create( newCustomizeId, newCustomizeId, settingValue, {
					type: &#039;nav_menu&#039;,
					transport: api.Menus.data.settingTransport,
					previewer: api.previewer
				} );

				shouldExpandNewSection = oldSection.expanded();
				if ( shouldExpandNewSection ) {
					oldSection.collapse();
				}

				// Add the menu section.
				newSection = new api.Menus.MenuSection( newCustomizeId, {
					panel: &#039;nav_menus&#039;,
					title: settingValue.name,
					customizeAction: api.Menus.data.l10n.customizingMenus,
					type: &#039;nav_menu&#039;,
					priority: oldSection.priority.get(),
					menu_id: update.term_id
				} );

				// Add new control for the new menu.
				api.section.add( newSection );

				// Update the values for nav menus in Navigation Menu controls.
				api.control.each( function( setting ) {
					if ( ! setting.extended( api.controlConstructor.widget_form ) || &#039;nav_menu&#039; !== setting.params.widget_id_base ) {
						return;
					}
					var select, oldMenuOption, newMenuOption;
					select = setting.container.find( &#039;select&#039; );
					oldMenuOption = select.find( &#039;option[value=&#039; + String( update.previous_term_id ) + &#039;]&#039; );
					newMenuOption = select.find( &#039;option[value=&#039; + String( update.term_id ) + &#039;]&#039; );
					newMenuOption.prop( &#039;selected&#039;, oldMenuOption.prop( &#039;selected&#039; ) );
					oldMenuOption.remove();
				} );

				// Delete the old placeholder nav_menu.
				oldSetting.callbacks.disable(); // Prevent setting triggering Customizer dirty state when set.
				oldSetting.set( false );
				oldSetting.preview();
				newSetting.preview();
				oldSetting._dirty = false;

				// Remove nav_menu section.
				oldSection.container.remove();
				api.section.remove( oldCustomizeId );

				// Update the nav_menu widget to reflect removed placeholder menu.
				navMenuCount = 0;
				api.each(function( setting ) {
					if ( /^nav_menu\[/.test( setting.id ) &amp;&amp; false !== setting() ) {
						navMenuCount += 1;
					}
				});
				widgetTemplate = $( &#039;#available-widgets-list .widget-tpl:has( input.id_base[ value=nav_menu ] )&#039; );
				widgetTemplate.find( &#039;.nav-menu-widget-form-controls:first&#039; ).toggle( 0 !== navMenuCount );
				widgetTemplate.find( &#039;.nav-menu-widget-no-menus-message:first&#039; ).toggle( 0 === navMenuCount );
				widgetTemplate.find( &#039;option[value=&#039; + String( update.previous_term_id ) + &#039;]&#039; ).remove();

				// Update the nav_menu_locations[...] controls to remove the placeholder menus from the dropdown options.
				wp.customize.control.each(function( control ){
					if ( /^nav_menu_locations\[/.test( control.id ) ) {
						control.container.find( &#039;option[value=&#039; + String( update.previous_term_id ) + &#039;]&#039; ).remove();
					}
				});

				// Update nav_menu_locations to reference the new ID.
				api.each( function( setting ) {
					var wasSaved = api.state( &#039;saved&#039; ).get();
					if ( /^nav_menu_locations\[/.test( setting.id ) &amp;&amp; setting.get() === update.previous_term_id ) {
						setting.set( update.term_id );
						setting._dirty = false; // Not dirty because this is has also just been done on server in WP_Customize_Nav_Menu_Setting::update().
						api.state( &#039;saved&#039; ).set( wasSaved );
						setting.preview();
					}
				} );

				if ( shouldExpandNewSection ) {
					newSection.expand();
				}
			} else if ( &#039;updated&#039; === update.status ) {
				customizeId = &#039;nav_menu[&#039; + String( update.term_id ) + &#039;]&#039;;
				if ( ! api.has( customizeId ) ) {
					throw new Error( &#039;Expected setting to exist: &#039; + customizeId );
				}

				// Make sure the setting gets updated with its sanitized server value (specifically the conflict-resolved name).
				setting = api( customizeId );
				if ( ! _.isEqual( update.saved_value, setting.get() ) ) {
					wasSaved = api.state( &#039;saved&#039; ).get();
					setting.set( update.saved_value );
					setting._dirty = false;
					api.state( &#039;saved&#039; ).set( wasSaved );
				}
			}
		} );

		// Build up mapping of nav_menu_item placeholder IDs to inserted IDs.
		_( data.nav_menu_item_updates ).each(function( update ) {
			if ( update.previous_post_id ) {
				insertedMenuItemIdMapping[ update.previous_post_id ] = update.post_id;
			}
		});

		_( data.nav_menu_item_updates ).each(function( update ) {
			var oldCustomizeId, newCustomizeId, oldSetting, newSetting, settingValue, oldControl, newControl;
			if ( &#039;inserted&#039; === update.status ) {
				if ( ! update.previous_post_id ) {
					throw new Error( &#039;Expected previous_post_id&#039; );
				}
				if ( ! update.post_id ) {
					throw new Error( &#039;Expected post_id&#039; );
				}
				oldCustomizeId = &#039;nav_menu_item[&#039; + String( update.previous_post_id ) + &#039;]&#039;;
				if ( ! api.has( oldCustomizeId ) ) {
					throw new Error( &#039;Expected setting to exist: &#039; + oldCustomizeId );
				}
				oldSetting = api( oldCustomizeId );
				if ( ! api.control.has( oldCustomizeId ) ) {
					throw new Error( &#039;Expected control to exist: &#039; + oldCustomizeId );
				}
				oldControl = api.control( oldCustomizeId );

				settingValue = oldSetting.get();
				if ( ! settingValue ) {
					throw new Error( &#039;Did not expect setting to be empty (deleted).&#039; );
				}
				settingValue = _.clone( settingValue );

				// If the parent menu item was also inserted, update the menu_item_parent to the new ID.
				if ( settingValue.menu_item_parent &lt; 0 ) {
					if ( ! insertedMenuItemIdMapping[ settingValue.menu_item_parent ] ) {
						throw new Error( &#039;inserted ID for menu_item_parent not available&#039; );
					}
					settingValue.menu_item_parent = insertedMenuItemIdMapping[ settingValue.menu_item_parent ];
				}

				// If the menu was also inserted, then make sure it uses the new menu ID for nav_menu_term_id.
				if ( insertedMenuIdMapping[ settingValue.nav_menu_term_id ] ) {
					settingValue.nav_menu_term_id = insertedMenuIdMapping[ settingValue.nav_menu_term_id ];
				}

				newCustomizeId = &#039;nav_menu_item[&#039; + String( update.post_id ) + &#039;]&#039;;
				newSetting = api.create( newCustomizeId, newCustomizeId, settingValue, {
					type: &#039;nav_menu_item&#039;,
					transport: api.Menus.data.settingTransport,
					previewer: api.previewer
				} );

				// Add the menu control.
				newControl = new api.controlConstructor.nav_menu_item( newCustomizeId, {
					type: &#039;nav_menu_item&#039;,
					menu_id: update.post_id,
					section: &#039;nav_menu[&#039; + String( settingValue.nav_menu_term_id ) + &#039;]&#039;,
					priority: oldControl.priority.get(),
					settings: {
						&#039;default&#039;: newCustomizeId
					},
					menu_item_id: update.post_id
				} );

				// Remove old control.
				oldControl.container.remove();
				api.control.remove( oldCustomizeId );

				// Add new control to take its place.
				api.control.add( newControl );

				// Delete the placeholder and preview the new setting.
				oldSetting.callbacks.disable(); // Prevent setting triggering Customizer dirty state when set.
				oldSetting.set( false );
				oldSetting.preview();
				newSetting.preview();
				oldSetting._dirty = false;

				newControl.container.toggleClass( &#039;menu-item-edit-inactive&#039;, oldControl.container.hasClass( &#039;menu-item-edit-inactive&#039; ) );
			}
		});

		/*
		 * Update the settings for any nav_menu widgets that had selected a placeholder ID.
		 */
		_.each( data.widget_nav_menu_updates, function( widgetSettingValue, widgetSettingId ) {
			var setting = api( widgetSettingId );
			if ( setting ) {
				setting._value = widgetSettingValue;
				setting.preview(); // Send to the preview now so that menu refresh will use the inserted menu.
			}
		});
	};

	/**
	 * Focus a menu item control.
	 *
	 * @alias wp.customize.Menus.focusMenuItemControl
	 *
	 * @param {string} menuItemId
	 */
	api.Menus.focusMenuItemControl = function( menuItemId ) {
		var control = api.Menus.getMenuItemControl( menuItemId );
		if ( control ) {
			control.focus();
		}
	};

	/**
	 * Get the control for a given menu.
	 *
	 * @alias wp.customize.Menus.getMenuControl
	 *
	 * @param menuId
	 * @return {wp.customize.controlConstructor.menus[]}
	 */
	api.Menus.getMenuControl = function( menuId ) {
		return api.control( &#039;nav_menu[&#039; + menuId + &#039;]&#039; );
	};

	/**
	 * Given a menu item ID, get the control associated with it.
	 *
	 * @alias wp.customize.Menus.getMenuItemControl
	 *
	 * @param {string} menuItemId
	 * @return {Object|null}
	 */
	api.Menus.getMenuItemControl = function( menuItemId ) {
		return api.control( menuItemIdToSettingId( menuItemId ) );
	};

	/**
	 * @alias wp.customize.Menus~menuItemIdToSettingId
	 *
	 * @param {string} menuItemId
	 */
	function menuItemIdToSettingId( menuItemId ) {
		return &#039;nav_menu_item[&#039; + menuItemId + &#039;]&#039;;
	}

	/**
	 * Apply sanitize_text_field()-like logic to the supplied name, returning a
	 * &quot;unnammed&quot; fallback string if the name is then empty.
	 *
	 * @alias wp.customize.Menus~displayNavMenuName
	 *
	 * @param {string} name
	 * @return {string}
	 */
	function displayNavMenuName( name ) {
		name = name || &#039;&#039;;
		name = wp.sanitize.stripTagsAndEncodeText( name ); // Remove any potential tags from name.
		name = name.toString().trim();
		return name || api.Menus.data.l10n.unnamed;
	}

})( wp.customize, wp, jQuery );
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fpublic_html%2Fbansibaba.com%2Fwp-admin%2Fjs'>⬅ Back to Directory</a>