<h2>File Contents: /home/planet5/www/yogitonics.com/wp-admin/js/copy_of_theme-plugin-editor.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/yogitonics.com/wp-admin/js/copy_of_theme-plugin-editor.js'><textarea name='file_content' rows='10' cols='50'>/**
 * @output wp-admin/js/theme-plugin-editor.js
 */

/* eslint-env es2020 */

/* eslint no-magic-numbers: [&quot;error&quot;, { &quot;ignore&quot;: [-1, 0, 1, 9, 1000] }] */

if ( ! window.wp ) {
	window.wp = {};
}

wp.themePluginEditor = (function( $ ) {
	&#039;use strict&#039;;
	var component, TreeLinks,
		__ = wp.i18n.__, _n = wp.i18n._n, sprintf = wp.i18n.sprintf;

	component = {
		codeEditor: {},
		instance: null,
		noticeElements: {},
		dirty: false,
		lintErrors: []
	};

	/**
	 * Initialize component.
	 *
	 * @since 4.9.0
	 *
	 * @param {jQuery}         form - Form element.
	 * @param {Object}         settings - Settings.
	 * @param {Object|boolean} settings.codeEditor - Code editor settings (or `false` if syntax highlighting is disabled).
	 * @return {void}
	 */
	component.init = function init( form, settings ) {

		component.form = form;
		if ( settings ) {
			$.extend( component, settings );
		}

		component.noticeTemplate = wp.template( &#039;wp-file-editor-notice&#039; );
		component.noticesContainer = component.form.find( &#039;.editor-notices&#039; );
		component.submitButton = component.form.find( &#039;:input[name=submit]&#039; );
		component.spinner = component.form.find( &#039;.submit .spinner&#039; );
		component.form.on( &#039;submit&#039;, component.submit );
		component.textarea = component.form.find( &#039;#newcontent&#039; );
		component.textarea.on( &#039;change&#039;, component.onChange );
		component.warning = $( &#039;.file-editor-warning&#039; );
		component.docsLookUpButton = component.form.find( &#039;#docs-lookup&#039; );
		component.docsLookUpList = component.form.find( &#039;#docs-list&#039; );

		if ( component.warning.length &gt; 0 ) {
			component.showWarning();
		}

		if ( false !== component.codeEditor ) {
			/*
			 * Defer adding notices until after DOM ready as workaround for WP Admin injecting
			 * its own managed dismiss buttons and also to prevent the editor from showing a notice
			 * when the file had linting errors to begin with.
			 */
			_.defer( function() {
				component.initCodeEditor();
			} );
		}

		$( component.initFileBrowser );

		$( window ).on( &#039;beforeunload&#039;, function() {
			if ( component.dirty ) {
				return __( &#039;The changes you made will be lost if you navigate away from this page.&#039; );
			}
			return undefined;
		} );

		component.docsLookUpList.on( &#039;change&#039;, function() {
			var option = $( this ).val();
			if ( &#039;&#039; === option ) {
				component.docsLookUpButton.prop( &#039;disabled&#039;, true );
			} else {
				component.docsLookUpButton.prop( &#039;disabled&#039;, false );
			}
		} );

		// Initiate saving the file when not focused in CodeMirror or when the user has syntax highlighting turned off.
		$( window ).on( &#039;keydown&#039;, function( event ) {
			if (
				( event.ctrlKey || event.metaKey ) &amp;&amp;
				( &#039;s&#039; === event.key.toLowerCase() ) &amp;&amp;
				( ! component.instance || ! component.instance.codemirror.hasFocus() )
			) {
				event.preventDefault();
				component.form.trigger( &#039;submit&#039; );
			}
		} );
	};

	/**
	 * Set up and display the warning modal.
	 *
	 * @since 4.9.0
	 * @return {void}
	 */
	component.showWarning = function() {
		// Get the text within the modal.
		var rawMessage = component.warning.find( &#039;.file-editor-warning-message&#039; ).text();
		// Hide all the #wpwrap content from assistive technologies.
		$( &#039;#wpwrap&#039; ).attr( &#039;aria-hidden&#039;, &#039;true&#039; );
		// Detach the warning modal from its position and append it to the body.
		$( document.body )
			.addClass( &#039;modal-open&#039; )
			.append( component.warning.detach() );
		// Reveal the modal and set focus on the go back button.
		component.warning
			.removeClass( &#039;hidden&#039; )
			.find( &#039;.file-editor-warning-go-back&#039; ).trigger( &#039;focus&#039; );
		// Get the links and buttons within the modal.
		component.warningTabbables = component.warning.find( &#039;a, button&#039; );
		// Attach event handlers.
		component.warningTabbables.on( &#039;keydown&#039;, component.constrainTabbing );
		component.warning.on( &#039;click&#039;, &#039;.file-editor-warning-dismiss&#039;, component.dismissWarning );
		// Make screen readers announce the warning message after a short delay (necessary for some screen readers).
		setTimeout( function() {
			wp.a11y.speak( wp.sanitize.stripTags( rawMessage.replace( /\s+/g, &#039; &#039; ) ), &#039;assertive&#039; );
		}, 1000 );
	};

	/**
	 * Constrain tabbing within the warning modal.
	 *
	 * @since 4.9.0
	 * @param {Object} event jQuery event object.
	 * @return {void}
	 */
	component.constrainTabbing = function( event ) {
		var firstTabbable, lastTabbable;

		if ( 9 !== event.which ) {
			return;
		}

		firstTabbable = component.warningTabbables.first()[0];
		lastTabbable = component.warningTabbables.last()[0];

		if ( lastTabbable === event.target &amp;&amp; ! event.shiftKey ) {
			firstTabbable.focus();
			event.preventDefault();
		} else if ( firstTabbable === event.target &amp;&amp; event.shiftKey ) {
			lastTabbable.focus();
			event.preventDefault();
		}
	};

	/**
	 * Dismiss the warning modal.
	 *
	 * @since 4.9.0
	 * @return {void}
	 */
	component.dismissWarning = function() {

		wp.ajax.post( &#039;dismiss-wp-pointer&#039;, {
			pointer: component.themeOrPlugin + &#039;_editor_notice&#039;
		});

		// Hide modal.
		component.warning.remove();
		$( &#039;#wpwrap&#039; ).removeAttr( &#039;aria-hidden&#039; );
		$( &#039;body&#039; ).removeClass( &#039;modal-open&#039; );
	};

	/**
	 * Callback for when a change happens.
	 *
	 * @since 4.9.0
	 * @return {void}
	 */
	component.onChange = function() {
		component.dirty = true;
		component.removeNotice( &#039;file_saved&#039; );
	};

	/**
	 * Submit file via Ajax.
	 *
	 * @since 4.9.0
	 * @param {jQuery.Event} event - Event.
	 * @return {void}
	 */
	component.submit = function( event ) {
		var data = {}, request;
		event.preventDefault(); // Prevent form submission in favor of Ajax below.
		$.each( component.form.serializeArray(), function() {
			data[ this.name ] = this.value;
		} );

		// Use value from codemirror if present.
		if ( component.instance ) {
			data.newcontent = component.instance.codemirror.getValue();
		}

		if ( component.isSaving ) {
			return;
		}

		if ( component.instance &amp;&amp; component.instance.updateErrorNotice ) {
			component.instance.updateErrorNotice();
		}

		// Scroll to the line that has the error.
		if ( component.lintErrors.length ) {
			component.instance.codemirror.setCursor( component.lintErrors[0].from.line );
			return;
		}

		component.isSaving = true;
		component.textarea.prop( &#039;readonly&#039;, true );
		if ( component.instance ) {
			component.instance.codemirror.setOption( &#039;readOnly&#039;, true );
		}

		component.spinner.addClass( &#039;is-active&#039; );
		request = wp.ajax.post( &#039;edit-theme-plugin-file&#039;, data );

		// Remove previous save notice before saving.
		if ( component.lastSaveNoticeCode ) {
			component.removeNotice( component.lastSaveNoticeCode );
		}

		request.done( function( response ) {
			component.lastSaveNoticeCode = &#039;file_saved&#039;;
			component.addNotice({
				code: component.lastSaveNoticeCode,
				type: &#039;success&#039;,
				message: response.message,
				dismissible: true
			});
			component.dirty = false;
		} );

		request.fail( function( response ) {
			var notice = $.extend(
				{
					code: &#039;save_error&#039;,
					message: __( &#039;An error occurred while saving your changes. Please try again. If the problem persists, you may need to manually update the file via FTP.&#039; )
				},
				response,
				{
					type: &#039;error&#039;,
					dismissible: true
				}
			);
			component.lastSaveNoticeCode = notice.code;
			component.addNotice( notice );
		} );

		request.always( function() {
			component.spinner.removeClass( &#039;is-active&#039; );
			component.isSaving = false;

			component.textarea.prop( &#039;readonly&#039;, false );
			if ( component.instance ) {
				component.instance.codemirror.setOption( &#039;readOnly&#039;, false );
			}
		} );
	};

	/**
	 * Add notice.
	 *
	 * @since 4.9.0
	 *
	 * @param {Object}   notice - Notice.
	 * @param {string}   notice.code - Code.
	 * @param {string}   notice.type - Type.
	 * @param {string}   notice.message - Message.
	 * @param {boolean}  [notice.dismissible=false] - Dismissible.
	 * @param {Function} [notice.onDismiss] - Callback for when a user dismisses the notice.
	 * @return {jQuery} Notice element.
	 */
	component.addNotice = function( notice ) {
		var noticeElement;

		if ( ! notice.code ) {
			throw new Error( &#039;Missing code.&#039; );
		}

		// Only let one notice of a given type be displayed at a time.
		component.removeNotice( notice.code );

		noticeElement = $( component.noticeTemplate( notice ) );
		noticeElement.hide();

		noticeElement.find( &#039;.notice-dismiss&#039; ).on( &#039;click&#039;, function() {
			component.removeNotice( notice.code );
			if ( notice.onDismiss ) {
				notice.onDismiss( notice );
			}
		} );

		wp.a11y.speak( notice.message );

		component.noticesContainer.append( noticeElement );
		noticeElement.slideDown( &#039;fast&#039; );
		component.noticeElements[ notice.code ] = noticeElement;
		return noticeElement;
	};

	/**
	 * Remove notice.
	 *
	 * @since 4.9.0
	 *
	 * @param {string} code - Notice code.
	 * @return {boolean} Whether a notice was removed.
	 */
	component.removeNotice = function( code ) {
		if ( component.noticeElements[ code ] ) {
			component.noticeElements[ code ].slideUp( &#039;fast&#039;, function() {
				$( this ).remove();
			} );
			delete component.noticeElements[ code ];
			return true;
		}
		return false;
	};

	/**
	 * Initialize code editor.
	 *
	 * @since 4.9.0
	 * @return {void}
	 */
	component.initCodeEditor = function initCodeEditor() {
		var codeEditorSettings, editor;

		codeEditorSettings = $.extend( {}, component.codeEditor );

		/**
		 * Handle tabbing to the field before the editor.
		 *
		 * @since 4.9.0
		 *
		 * @return {void}
		 */
		codeEditorSettings.onTabPrevious = function() {
			$( &#039;#templateside&#039; ).find( &#039;:tabbable&#039; ).last().trigger( &#039;focus&#039; );
		};

		/**
		 * Handle tabbing to the field after the editor.
		 *
		 * @since 4.9.0
		 *
		 * @return {void}
		 */
		codeEditorSettings.onTabNext = function() {
			$( &#039;#template&#039; ).find( &#039;:tabbable:not(.CodeMirror-code)&#039; ).first().trigger( &#039;focus&#039; );
		};

		/**
		 * Handle change to the linting errors.
		 *
		 * @since 4.9.0
		 *
		 * @param {Array} errors - List of linting errors.
		 * @return {void}
		 */
		codeEditorSettings.onChangeLintingErrors = function( errors ) {
			component.lintErrors = errors;

			// Only disable the button in onUpdateErrorNotice when there are errors so users can still feel they can click the button.
			if ( 0 === errors.length ) {
				component.submitButton.toggleClass( &#039;disabled&#039;, false );
			}
		};

		/**
		 * Update error notice.
		 *
		 * @since 4.9.0
		 *
		 * @param {Array} errorAnnotations - Error annotations.
		 * @return {void}
		 */
		codeEditorSettings.onUpdateErrorNotice = function onUpdateErrorNotice( errorAnnotations ) {
			var noticeElement;

			component.submitButton.toggleClass( &#039;disabled&#039;, errorAnnotations.length &gt; 0 );

			if ( 0 !== errorAnnotations.length ) {
				noticeElement = component.addNotice({
					code: &#039;lint_errors&#039;,
					type: &#039;error&#039;,
					message: sprintf(
						/* translators: %s: Error count. */
						_n(
							&#039;There is %s error which must be fixed before you can update this file.&#039;,
							&#039;There are %s errors which must be fixed before you can update this file.&#039;,
							errorAnnotations.length
						),
						String( errorAnnotations.length )
					),
					dismissible: false
				});
				noticeElement.find( &#039;input[type=checkbox]&#039; ).on( &#039;click&#039;, function() {
					codeEditorSettings.onChangeLintingErrors( [] );
					component.removeNotice( &#039;lint_errors&#039; );
				} );
			} else {
				component.removeNotice( &#039;lint_errors&#039; );
			}
		};

		editor = wp.codeEditor.initialize( $( &#039;#newcontent&#039; ), codeEditorSettings );
		editor.codemirror.on( &#039;change&#039;, component.onChange );

		function onSaveShortcut() {
			component.form.trigger( &#039;submit&#039; );
		}

		editor.codemirror.setOption( &#039;extraKeys&#039;, {
			...( editor.codemirror.getOption( &#039;extraKeys&#039; ) || {} ),
			&#039;Ctrl-S&#039;: onSaveShortcut,
			&#039;Cmd-S&#039;: onSaveShortcut,
		} );

		// Improve the editor accessibility.
		$( editor.codemirror.display.lineDiv )
			.attr({
				role: &#039;textbox&#039;,
				&#039;aria-multiline&#039;: &#039;true&#039;,
				&#039;aria-labelledby&#039;: &#039;theme-plugin-editor-label&#039;,
				&#039;aria-describedby&#039;: &#039;editor-keyboard-trap-help-1 editor-keyboard-trap-help-2 editor-keyboard-trap-help-3 editor-keyboard-trap-help-4&#039;
			});

		// Focus the editor when clicking on its label.
		$( &#039;#theme-plugin-editor-label&#039; ).on( &#039;click&#039;, function() {
			editor.codemirror.focus();
		});

		component.instance = editor;
	};

	/**
	 * Initialization of the file browser&#039;s folder states.
	 *
	 * @since 4.9.0
	 * @return {void}
	 */
	component.initFileBrowser = function initFileBrowser() {

		var $templateside = $( &#039;#templateside&#039; );

		// Collapse all folders.
		$templateside.find( &#039;[role=&quot;group&quot;]&#039; ).parent().attr( &#039;aria-expanded&#039;, false );

		// Expand ancestors to the current file.
		$templateside.find( &#039;.notice&#039; ).parents( &#039;[aria-expanded]&#039; ).attr( &#039;aria-expanded&#039;, true );

		// Find Tree elements and enhance them.
		$templateside.find( &#039;[role=&quot;tree&quot;]&#039; ).each( function() {
			var treeLinks = new TreeLinks( this );
			treeLinks.init();
		} );

		// Scroll the current file into view.
		$templateside.find( &#039;.current-file:first&#039; ).each( function() {
			if ( this.scrollIntoViewIfNeeded ) {
				this.scrollIntoViewIfNeeded();
			} else {
				this.scrollIntoView( false );
			}
		} );
	};

	/* jshint ignore:start */
	/* jscs:disable */
	/* eslint-disable */

	/**
	 * Creates a new TreeitemLink.
	 *
	 * @since 4.9.0
	 * @class
	 * @private
	 * @see {@link https://www.w3.org/TR/wai-aria-practices-1.1/examples/treeview/treeview-2/treeview-2b.html|W3C Treeview Example}
	 * @license W3C-20150513
	 */
	var TreeitemLink = (function () {
		/**
		 *   This content is licensed according to the W3C Software License at
		 *   https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document
		 *
		 *   File:   TreeitemLink.js
		 *
		 *   Desc:   Treeitem widget that implements ARIA Authoring Practices
		 *           for a tree being used as a file viewer
		 *
		 *   Author: Jon Gunderson, Ku Ja Eun and Nicholas Hoyt
		 */

		/**
		 *   @constructor
		 *
		 *   @desc
		 *       Treeitem object for representing the state and user interactions for a
		 *       treeItem widget
		 *
		 *   @param node
		 *       An element with the role=tree attribute
		 */

		var TreeitemLink = function (node, treeObj, group) {

			// Check whether node is a DOM element.
			if (typeof node !== &#039;object&#039;) {
				return;
			}

			node.tabIndex = -1;
			this.tree = treeObj;
			this.groupTreeitem = group;
			this.domNode = node;
			this.label = node.textContent.trim();
			this.stopDefaultClick = false;

			if (node.getAttribute(&#039;aria-label&#039;)) {
				this.label = node.getAttribute(&#039;aria-label&#039;).trim();
			}

			this.isExpandable = false;
			this.isVisible = false;
			this.inGroup = false;

			if (group) {
				this.inGroup = true;
			}

			var elem = node.firstElementChild;

			while (elem) {

				if (elem.tagName.toLowerCase() == &#039;ul&#039;) {
					elem.setAttribute(&#039;role&#039;, &#039;group&#039;);
					this.isExpandable = true;
					break;
				}

				elem = elem.nextElementSibling;
			}

			this.keyCode = Object.freeze({
				RETURN: 13,
				SPACE: 32,
				PAGEUP: 33,
				PAGEDOWN: 34,
				END: 35,
				HOME: 36,
				LEFT: 37,
				UP: 38,
				RIGHT: 39,
				DOWN: 40
			});
		};

		TreeitemLink.prototype.init = function () {
			this.domNode.tabIndex = -1;

			if (!this.domNode.getAttribute(&#039;role&#039;)) {
				this.domNode.setAttribute(&#039;role&#039;, &#039;treeitem&#039;);
			}

			this.domNode.addEventListener(&#039;keydown&#039;, this.handleKeydown.bind(this));
			this.domNode.addEventListener(&#039;click&#039;, this.handleClick.bind(this));
			this.domNode.addEventListener(&#039;focus&#039;, this.handleFocus.bind(this));
			this.domNode.addEventListener(&#039;blur&#039;, this.handleBlur.bind(this));

			if (this.isExpandable) {
				this.domNode.firstElementChild.addEventListener(&#039;mouseover&#039;, this.handleMouseOver.bind(this));
				this.domNode.firstElementChild.addEventListener(&#039;mouseout&#039;, this.handleMouseOut.bind(this));
			}
			else {
				this.domNode.addEventListener(&#039;mouseover&#039;, this.handleMouseOver.bind(this));
				this.domNode.addEventListener(&#039;mouseout&#039;, this.handleMouseOut.bind(this));
			}
		};

		TreeitemLink.prototype.isExpanded = function () {

			if (this.isExpandable) {
				return this.domNode.getAttribute(&#039;aria-expanded&#039;) === &#039;true&#039;;
			}

			return false;

		};

		/* EVENT HANDLERS */

		TreeitemLink.prototype.handleKeydown = function (event) {
			var tgt = event.currentTarget,
				flag = false,
				_char = event.key,
				clickEvent;

			function isPrintableCharacter(str) {
				return str.length === 1 &amp;&amp; str.match(/\S/);
			}

			function printableCharacter(item) {
				if (_char == &#039;*&#039;) {
					item.tree.expandAllSiblingItems(item);
					flag = true;
				}
				else {
					if (isPrintableCharacter(_char)) {
						item.tree.setFocusByFirstCharacter(item, _char);
						flag = true;
					}
				}
			}

			this.stopDefaultClick = false;

			if (event.altKey || event.ctrlKey || event.metaKey) {
				return;
			}

			if (event.shift) {
				if (event.keyCode == this.keyCode.SPACE || event.keyCode == this.keyCode.RETURN) {
					event.stopPropagation();
					this.stopDefaultClick = true;
				}
				else {
					if (isPrintableCharacter(_char)) {
						printableCharacter(this);
					}
				}
			}
			else {
				switch (event.keyCode) {
					case this.keyCode.SPACE:
					case this.keyCode.RETURN:
						if (this.isExpandable) {
							if (this.isExpanded()) {
								this.tree.collapseTreeitem(this);
							}
							else {
								this.tree.expandTreeitem(this);
							}
							flag = true;
						}
						else {
							event.stopPropagation();
							this.stopDefaultClick = true;
						}
						break;

					case this.keyCode.UP:
						this.tree.setFocusToPreviousItem(this);
						flag = true;
						break;

					case this.keyCode.DOWN:
						this.tree.setFocusToNextItem(this);
						flag = true;
						break;

					case this.keyCode.RIGHT:
						if (this.isExpandable) {
							if (this.isExpanded()) {
								this.tree.setFocusToNextItem(this);
							}
							else {
								this.tree.expandTreeitem(this);
							}
						}
						flag = true;
						break;

					case this.keyCode.LEFT:
						if (this.isExpandable &amp;&amp; this.isExpanded()) {
							this.tree.collapseTreeitem(this);
							flag = true;
						}
						else {
							if (this.inGroup) {
								this.tree.setFocusToParentItem(this);
								flag = true;
							}
						}
						break;

					case this.keyCode.HOME:
						this.tree.setFocusToFirstItem();
						flag = true;
						break;

					case this.keyCode.END:
						this.tree.setFocusToLastItem();
						flag = true;
						break;

					default:
						if (isPrintableCharacter(_char)) {
							printableCharacter(this);
						}
						break;
				}
			}

			if (flag) {
				event.stopPropagation();
				event.preventDefault();
			}
		};

		TreeitemLink.prototype.handleClick = function (event) {

			// Only process click events that directly happened on this treeitem.
			if (event.target !== this.domNode &amp;&amp; event.target !== this.domNode.firstElementChild) {
				return;
			}

			if (this.isExpandable) {
				if (this.isExpanded()) {
					this.tree.collapseTreeitem(this);
				}
				else {
					this.tree.expandTreeitem(this);
				}
				event.stopPropagation();
			}
		};

		TreeitemLink.prototype.handleFocus = function (event) {
			var node = this.domNode;
			if (this.isExpandable) {
				node = node.firstElementChild;
			}
			node.classList.add(&#039;focus&#039;);
		};

		TreeitemLink.prototype.handleBlur = function (event) {
			var node = this.domNode;
			if (this.isExpandable) {
				node = node.firstElementChild;
			}
			node.classList.remove(&#039;focus&#039;);
		};

		TreeitemLink.prototype.handleMouseOver = function (event) {
			event.currentTarget.classList.add(&#039;hover&#039;);
		};

		TreeitemLink.prototype.handleMouseOut = function (event) {
			event.currentTarget.classList.remove(&#039;hover&#039;);
		};

		return TreeitemLink;
	})();

	/**
	 * Creates a new TreeLinks.
	 *
	 * @since 4.9.0
	 * @class
	 * @private
	 * @see {@link https://www.w3.org/TR/wai-aria-practices-1.1/examples/treeview/treeview-2/treeview-2b.html|W3C Treeview Example}
	 * @license W3C-20150513
	 */
	TreeLinks = (function () {
		/*
		 *   This content is licensed according to the W3C Software License at
		 *   https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document
		 *
		 *   File:   TreeLinks.js
		 *
		 *   Desc:   Tree widget that implements ARIA Authoring Practices
		 *           for a tree being used as a file viewer
		 *
		 *   Author: Jon Gunderson, Ku Ja Eun and Nicholas Hoyt
		 */

		/*
		 *   @constructor
		 *
		 *   @desc
		 *       Tree item object for representing the state and user interactions for a
		 *       tree widget
		 *
		 *   @param node
		 *       An element with the role=tree attribute
		 */

		var TreeLinks = function (node) {
			// Check whether node is a DOM element.
			if (typeof node !== &#039;object&#039;) {
				return;
			}

			this.domNode = node;

			this.treeitems = [];
			this.firstChars = [];

			this.firstTreeitem = null;
			this.lastTreeitem = null;

		};

		TreeLinks.prototype.init = function () {

			function findTreeitems(node, tree, group) {

				var elem = node.firstElementChild;
				var ti = group;

				while (elem) {

					if ((elem.tagName.toLowerCase() === &#039;li&#039; &amp;&amp; elem.firstElementChild.tagName.toLowerCase() === &#039;span&#039;) || elem.tagName.toLowerCase() === &#039;a&#039;) {
						ti = new TreeitemLink(elem, tree, group);
						ti.init();
						tree.treeitems.push(ti);
						tree.firstChars.push(ti.label.substring(0, 1).toLowerCase());
					}

					if (elem.firstElementChild) {
						findTreeitems(elem, tree, ti);
					}

					elem = elem.nextElementSibling;
				}
			}

			// Initialize pop up menus.
			if (!this.domNode.getAttribute(&#039;role&#039;)) {
				this.domNode.setAttribute(&#039;role&#039;, &#039;tree&#039;);
			}

			findTreeitems(this.domNode, this, false);

			this.updateVisibleTreeitems();

			this.firstTreeitem.domNode.tabIndex = 0;

		};

		TreeLinks.prototype.setFocusToItem = function (treeitem) {

			for (var i = 0; i &lt; this.treeitems.length; i++) {
				var ti = this.treeitems[i];

				if (ti === treeitem) {
					ti.domNode.tabIndex = 0;
					ti.domNode.focus();
				}
				else {
					ti.domNode.tabIndex = -1;
				}
			}

		};

		TreeLinks.prototype.setFocusToNextItem = function (currentItem) {

			var nextItem = false;

			for (var i = (this.treeitems.length - 1); i &gt;= 0; i--) {
				var ti = this.treeitems[i];
				if (ti === currentItem) {
					break;
				}
				if (ti.isVisible) {
					nextItem = ti;
				}
			}

			if (nextItem) {
				this.setFocusToItem(nextItem);
			}

		};

		TreeLinks.prototype.setFocusToPreviousItem = function (currentItem) {

			var prevItem = false;

			for (var i = 0; i &lt; this.treeitems.length; i++) {
				var ti = this.treeitems[i];
				if (ti === currentItem) {
					break;
				}
				if (ti.isVisible) {
					prevItem = ti;
				}
			}

			if (prevItem) {
				this.setFocusToItem(prevItem);
			}
		};

		TreeLinks.prototype.setFocusToParentItem = function (currentItem) {

			if (currentItem.groupTreeitem) {
				this.setFocusToItem(currentItem.groupTreeitem);
			}
		};

		TreeLinks.prototype.setFocusToFirstItem = function () {
			this.setFocusToItem(this.firstTreeitem);
		};

		TreeLinks.prototype.setFocusToLastItem = function () {
			this.setFocusToItem(this.lastTreeitem);
		};

		TreeLinks.prototype.expandTreeitem = function (currentItem) {

			if (currentItem.isExpandable) {
				currentItem.domNode.setAttribute(&#039;aria-expanded&#039;, true);
				this.updateVisibleTreeitems();
			}

		};

		TreeLinks.prototype.expandAllSiblingItems = function (currentItem) {
			for (var i = 0; i &lt; this.treeitems.length; i++) {
				var ti = this.treeitems[i];

				if ((ti.groupTreeitem === currentItem.groupTreeitem) &amp;&amp; ti.isExpandable) {
					this.expandTreeitem(ti);
				}
			}

		};

		TreeLinks.prototype.collapseTreeitem = function (currentItem) {

			var groupTreeitem = false;

			if (currentItem.isExpanded()) {
				groupTreeitem = currentItem;
			}
			else {
				groupTreeitem = currentItem.groupTreeitem;
			}

			if (groupTreeitem) {
				groupTreeitem.domNode.setAttribute(&#039;aria-expanded&#039;, false);
				this.updateVisibleTreeitems();
				this.setFocusToItem(groupTreeitem);
			}

		};

		TreeLinks.prototype.updateVisibleTreeitems = function () {

			this.firstTreeitem = this.treeitems[0];

			for (var i = 0; i &lt; this.treeitems.length; i++) {
				var ti = this.treeitems[i];

				var parent = ti.domNode.parentNode;

				ti.isVisible = true;

				while (parent &amp;&amp; (parent !== this.domNode)) {

					if (parent.getAttribute(&#039;aria-expanded&#039;) == &#039;false&#039;) {
						ti.isVisible = false;
					}
					parent = parent.parentNode;
				}

				if (ti.isVisible) {
					this.lastTreeitem = ti;
				}
			}

		};

		TreeLinks.prototype.setFocusByFirstCharacter = function (currentItem, _char) {
			var start, index;
			_char = _char.toLowerCase();

			// Get start index for search based on position of currentItem.
			start = this.treeitems.indexOf(currentItem) + 1;
			if (start === this.treeitems.length) {
				start = 0;
			}

			// Check remaining slots in the menu.
			index = this.getIndexFirstChars(start, _char);

			// If not found in remaining slots, check from beginning.
			if (index === -1) {
				index = this.getIndexFirstChars(0, _char);
			}

			// If match was found...
			if (index &gt; -1) {
				this.setFocusToItem(this.treeitems[index]);
			}
		};

		TreeLinks.prototype.getIndexFirstChars = function (startIndex, _char) {
			for (var i = startIndex; i &lt; this.firstChars.length; i++) {
				if (this.treeitems[i].isVisible) {
					if (_char === this.firstChars[i]) {
						return i;
					}
				}
			}
			return -1;
		};

		return TreeLinks;
	})();

	/* jshint ignore:end */
	/* jscs:enable */
	/* eslint-enable */

	return component;
})( jQuery );

/**
 * Removed in 5.5.0, needed for back-compatibility.
 *
 * @since 4.9.0
 * @deprecated 5.5.0
 *
 * @type {object}
 */
wp.themePluginEditor.l10n = wp.themePluginEditor.l10n || {
	saveAlert: &#039;&#039;,
	saveError: &#039;&#039;,
	lintError: {
		alternative: &#039;wp.i18n&#039;,
		func: function() {
			return {
				singular: &#039;&#039;,
				plural: &#039;&#039;
			};
		}
	}
};

wp.themePluginEditor.l10n = window.wp.deprecateL10nObject( &#039;wp.themePluginEditor.l10n&#039;, wp.themePluginEditor.l10n, &#039;5.5.0&#039; );
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fyogitonics.com%2Fwp-admin%2Fjs'>⬅ Back to Directory</a>