text: /* eslint no-magic-numbers: ["error", { "ignore": [-1, 0, 1] }] */
  
  if ( ! window.wp ) {
  	window.wp = {};
  }
  
  wp.themePluginEditor = (function( $ ) {
  	'use strict';
  	var component, TreeLinks;
  
  	component = {
  		l10n: {
  			lintError: {
  				singular: '',
  				plural: ''
  			},
  			saveAlert: '',
  			saveError: ''
  		},
  		codeEditor: {},
  		instance: null,
  		noticeElements: {},
  		dirty: false,
  		lintErrors: []
  	};
  
  	/**
  	 * Initialize component.
  	 *
  	 * @since WP-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).
  	 * @returns {void}
  	 */
  	component.init = function init( form, settings ) {
  
  		component.form = form;
  		if ( settings ) {
  			$.extend( component, settings );
  		}
  
  		component.noticeTemplate = wp.template( 'wp-file-editor-notice' );
  		component.noticesContainer = component.form.find( '.editor-notices' );
  		component.submitButton = component.form.find( ':input[name=submit]' );
  		component.spinner = component.form.find( '.submit .spinner' );
  		component.form.on( 'submit', component.submit );
  		component.textarea = component.form.find( '#newcontent' );
  		component.textarea.on( 'change', component.onChange );
  		component.warning = $( '.file-editor-warning' );
  
  		if ( component.warning.length > 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( 'beforeunload', function() {
  			if ( component.dirty ) {
  				return component.l10n.saveAlert;
  			}
  			return undefined;
  		} );
  	};
  
  	/**
  	 * Set up and display the warning modal.
  	 *
  	 * @since WP-4.9.0
  	 * @returns {void}
  	 */
  	component.showWarning = function() {
  		// Get the text within the modal.
  		var rawMessage = component.warning.find( '.file-editor-warning-message' ).text();
  		// Hide all the #wpwrap content from assistive technologies.
  		$( '#wpwrap' ).attr( 'aria-hidden', 'true' );
  		// Detach the warning modal from its position and append it to the body.
  		$( document.body )
  			.addClass( 'modal-open' )
  			.append( component.warning.detach() );
  		// Reveal the modal and set focus on the go back button.
  		component.warning
  			.removeClass( 'hidden' )
  			.find( '.file-editor-warning-go-back' ).focus();
  		// Get the links and buttons within the modal.
  		component.warningTabbables = component.warning.find( 'a, button' );
  		// Attach event handlers.
  		component.warningTabbables.on( 'keydown', component.constrainTabbing );
  		component.warning.on( 'click', '.file-editor-warning-dismiss', 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, ' ' ) ), 'assertive' );
  		}, 1000 );
  	};
  
  	/**
  	 * Constrain tabbing within the warning modal.
  	 *
  	 * @since WP-4.9.0
  	 * @param {object} event jQuery event object.
  	 * @returns {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 && ! event.shiftKey ) {
  			firstTabbable.focus();
  			event.preventDefault();
  		} else if ( firstTabbable === event.target && event.shiftKey ) {
  			lastTabbable.focus();
  			event.preventDefault();
  		}
  	};
  
  	/**
  	 * Dismiss the warning modal.
  	 *
  	 * @since WP-4.9.0
  	 * @returns {void}
  	 */
  	component.dismissWarning = function() {
  
  		wp.ajax.post( 'dismiss-wp-pointer', {
  			pointer: component.themeOrPlugin + '_editor_notice'
  		});
  
  		// Hide modal.
  		component.warning.remove();
  		$( '#wpwrap' ).removeAttr( 'aria-hidden' );
  		$( 'body' ).removeClass( 'modal-open' );
  	};
  
  	/**
  	 * Callback for when a change happens.
  	 *
  	 * @since WP-4.9.0
  	 * @returns {void}
  	 */
  	component.onChange = function() {
  		component.dirty = true;
  		component.removeNotice( 'file_saved' );
  	};
  
  	/**
  	 * Submit file via Ajax.
  	 *
  	 * @since WP-4.9.0
  	 * @param {jQuery.Event} event - Event.
  	 * @returns {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;
  		}
  
  		// Scroll ot 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( 'readonly', true );
  		if ( component.instance ) {
  			component.instance.codemirror.setOption( 'readOnly', true );
  		}
  
  		component.spinner.addClass( 'is-active' );
  		request = wp.ajax.post( 'edit-theme-plugin-file', data );
  
  		// Remove previous save notice before saving.
  		if ( component.lastSaveNoticeCode ) {
  			component.removeNotice( component.lastSaveNoticeCode );
  		}
  
  		request.done( function( response ) {
  			component.lastSaveNoticeCode = 'file_saved';
  			component.addNotice({
  				code: component.lastSaveNoticeCode,
  				type: 'success',
  				message: response.message,
  				dismissible: true
  			});
  			component.dirty = false;
  		} );
  
  		request.fail( function( response ) {
  			var notice = $.extend(
  				{
  					code: 'save_error',
  					message: component.l10n.saveError
  				},
  				response,
  				{
  					type: 'error',
  					dismissible: true
  				}
  			);
  			component.lastSaveNoticeCode = notice.code;
  			component.addNotice( notice );
  		} );
  
  		request.always( function() {
  			component.spinner.removeClass( 'is-active' );
  			component.isSaving = false;
  
  			component.textarea.prop( 'readonly', false );
  			if ( component.instance ) {
  				component.instance.codemirror.setOption( 'readOnly', false );
  			}
  		} );
  	};
  
  	/**
  	 * Add notice.
  	 *
  	 * @since WP-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.
  	 * @returns {jQuery} Notice element.
  	 */
  	component.addNotice = function( notice ) {
  		var noticeElement;
  
  		if ( ! notice.code ) {
  			throw new Error( 'Missing code.' );
  		}
  
  		// 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( '.notice-dismiss' ).on( 'click', function() {
  			component.removeNotice( notice.code );
  			if ( notice.onDismiss ) {
  				notice.onDismiss( notice );
  			}
  		} );
  
  		wp.a11y.speak( notice.message );
  
  		component.noticesContainer.append( noticeElement );
  		noticeElement.slideDown( 'fast' );
  		component.noticeElements[ notice.code ] = noticeElement;
  		return noticeElement;
  	};
  
  	/**
  	 * Remove notice.
  	 *
  	 * @since WP-4.9.0
  	 *
  	 * @param {string} code - Notice code.
  	 * @returns {boolean} Whether a notice was removed.
  	 */
  	component.removeNotice = function( code ) {
  		if ( component.noticeElements[ code ] ) {
  			component.noticeElements[ code ].slideUp( 'fast', function() {
  				$( this ).remove();
  			} );
  			delete component.noticeElements[ code ];
  			return true;
  		}
  		return false;
  	};
  
  	/**
  	 * Initialize code editor.
  	 *
  	 * @since WP-4.9.0
  	 * @returns {void}
  	 */
  	component.initCodeEditor = function initCodeEditor() {
  		var codeEditorSettings, editor;
  
  		codeEditorSettings = $.extend( {}, component.codeEditor );
  
  		/**
  		 * Handle tabbing to the field before the editor.
  		 *
  		 * @since WP-4.9.0
  		 *
  		 * @returns {void}
  		 */
  		codeEditorSettings.onTabPrevious = function() {
  			$( '#templateside' ).find( ':tabbable' ).last().focus();
  		};
  
  		/**
  		 * Handle tabbing to the field after the editor.
  		 *
  		 * @since WP-4.9.0
  		 *
  		 * @returns {void}
  		 */
  		codeEditorSettings.onTabNext = function() {
  			$( '#template' ).find( ':tabbable:not(.CodeMirror-code)' ).first().focus();
  		};
  
  		/**
  		 * Handle change to the linting errors.
  		 *
  		 * @since WP-4.9.0
  		 *
  		 * @param {Array} errors - List of linting errors.
  		 * @returns {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( 'disabled', false );
  			}
  		};
  
  		/**
  		 * Update error notice.
  		 *
  		 * @since WP-4.9.0
  		 *
  		 * @param {Array} errorAnnotations - Error annotations.
  		 * @returns {void}
  		 */
  		codeEditorSettings.onUpdateErrorNotice = function onUpdateErrorNotice( errorAnnotations ) {
  			var message, noticeElement;
  
  			component.submitButton.toggleClass( 'disabled', errorAnnotations.length > 0 );
  
  			if ( 0 !== errorAnnotations.length ) {
  				if ( 1 === errorAnnotations.length ) {
  					message = component.l10n.lintError.singular.replace( '%d', '1' );
  				} else {
  					message = component.l10n.lintError.plural.replace( '%d', String( errorAnnotations.length ) );
  				}
  				noticeElement = component.addNotice({
  					code: 'lint_errors',
  					type: 'error',
  					message: message,
  					dismissible: false
  				});
  				noticeElement.find( 'input[type=checkbox]' ).on( 'click', function() {
  					codeEditorSettings.onChangeLintingErrors( [] );
  					component.removeNotice( 'lint_errors' );
  				} );
  			} else {
  				component.removeNotice( 'lint_errors' );
  			}
  		};
  
  		editor = wp.codeEditor.initialize( $( '#newcontent' ), codeEditorSettings );
  		editor.codemirror.on( 'change', component.onChange );
  
  		// Improve the editor accessibility.
  		$( editor.codemirror.display.lineDiv )
  			.attr({
  				role: 'textbox',
  				'aria-multiline': 'true',
  				'aria-labelledby': 'theme-plugin-editor-label',
  				'aria-describedby': 'editor-keyboard-trap-help-1 editor-keyboard-trap-help-2 editor-keyboard-trap-help-3 editor-keyboard-trap-help-4'
  			});
  
  		// Focus the editor when clicking on its label.
  		$( '#theme-plugin-editor-label' ).on( 'click', function() {
  			editor.codemirror.focus();
  		});
  
  		component.instance = editor;
  	};
  
  	/**
  	 * Initialization of the file browser's folder states.
  	 *
  	 * @since WP-4.9.0
  	 * @returns {void}
  	 */
  	component.initFileBrowser = function initFileBrowser() {
  
  		var $templateside = $( '#templateside' );
  
  		// Collapse all folders.
  		$templateside.find( '[role="group"]' ).parent().attr( 'aria-expanded', false );
  
  		// Expand ancestors to the current file.
  		$templateside.find( '.notice' ).parents( '[aria-expanded]' ).attr( 'aria-expanded', true );
  
  		// Find Tree elements and enhance them.
  		$templateside.find( '[role="tree"]' ).each( function() {
  			var treeLinks = new TreeLinks( this );
  			treeLinks.init();
  		} );
  
  		// Scroll the current file into view.
  		$templateside.find( '.current-file:first' ).each( function() {
  			if ( this.scrollIntoViewIfNeeded ) {
  				this.scrollIntoViewIfNeeded();
  			} else {
  				this.scrollIntoView( false );
  			}
  		} );
  	};
  
  	/* jshint ignore:start */
  	/* jscs:disable */
  	/* eslint-disable */
  
  	/**
  	 * Creates a new TreeitemLink.
  	 *
  	 * @since WP-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 !== 'object') {
  				return;
  			}
  
  			node.tabIndex = -1;
  			this.tree = treeObj;
  			this.groupTreeitem = group;
  			this.domNode = node;
  			this.label = node.textContent.trim();
  			this.stopDefaultClick = false;
  
  			if (node.getAttribute('aria-label')) {
  				this.label = node.getAttribute('aria-label').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() == 'ul') {
  					elem.setAttribute('role', 'group');
  					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('role')) {
  				this.domNode.setAttribute('role', 'treeitem');
  			}
  
  			this.domNode.addEventListener('keydown', this.handleKeydown.bind(this));
  			this.domNode.addEventListener('click', this.handleClick.bind(this));
  			this.domNode.addEventListener('focus', this.handleFocus.bind(this));
  			this.domNode.addEventListener('blur', this.handleBlur.bind(this));
  
  			if (this.isExpandable) {
  				this.domNode.firstElementChild.addEventListener('mouseover', this.handleMouseOver.bind(this));
  				this.domNode.firstElementChild.addEventListener('mouseout', this.handleMouseOut.bind(this));
  			}
  			else {
  				this.domNode.addEventListener('mouseover', this.handleMouseOver.bind(this));
  				this.domNode.addEventListener('mouseout', this.handleMouseOut.bind(this));
  			}
  		};
  
  		TreeitemLink.prototype.isExpanded = function () {
  
  			if (this.isExpandable) {
  				return this.domNode.getAttribute('aria-expanded') === 'true';
  			}
  
  			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 && str.match(/\S/);
  			}
  
  			function printableCharacter(item) {
  				if (_char == '*') {
  					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 && 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 && 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('focus');
  		};
  
  		TreeitemLink.prototype.handleBlur = function (event) {
  			var node = this.domNode;
  			if (this.isExpandable) {
  				node = node.firstElementChild;
  			}
  			node.classList.remove('focus');
  		};
  
  		TreeitemLink.prototype.handleMouseOver = function (event) {
  			event.currentTarget.classList.add('hover');
  		};
  
  		TreeitemLink.prototype.handleMouseOut = function (event) {
  			event.currentTarget.classList.remove('hover');
  		};
  
  		return TreeitemLink;
  	})();
  
  	/**
  	 * Creates a new TreeLinks.
  	 *
  	 * @since WP-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 !== 'object') {
  				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() === 'li' && elem.firstElementChild.tagName.toLowerCase() === 'span') || elem.tagName.toLowerCase() === 'a') {
  						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('role')) {
  				this.domNode.setAttribute('role', 'tree');
  			}
  
  			findTreeitems(this.domNode, this, false);
  
  			this.updateVisibleTreeitems();
  
  			this.firstTreeitem.domNode.tabIndex = 0;
  
  		};
  
  		TreeLinks.prototype.setFocusToItem = function (treeitem) {
  
  			for (var i = 0; i < 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 >= 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 < 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('aria-expanded', true);
  				this.updateVisibleTreeitems();
  			}
  
  		};
  
  		TreeLinks.prototype.expandAllSiblingItems = function (currentItem) {
  			for (var i = 0; i < this.treeitems.length; i++) {
  				var ti = this.treeitems[i];
  
  				if ((ti.groupTreeitem === currentItem.groupTreeitem) && 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('aria-expanded', false);
  				this.updateVisibleTreeitems();
  				this.setFocusToItem(groupTreeitem);
  			}
  
  		};
  
  		TreeLinks.prototype.updateVisibleTreeitems = function () {
  
  			this.firstTreeitem = this.treeitems[0];
  
  			for (var i = 0; i < this.treeitems.length; i++) {
  				var ti = this.treeitems[i];
  
  				var parent = ti.domNode.parentNode;
  
  				ti.isVisible = true;
  
  				while (parent && (parent !== this.domNode)) {
  
  					if (parent.getAttribute('aria-expanded') == 'false') {
  						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 > -1) {
  				this.setFocusToItem(this.treeitems[index]);
  			}
  		};
  
  		TreeLinks.prototype.getIndexFirstChars = function (startIndex, _char) {
  			for (var i = startIndex; i < 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 );
  