<form method="POST">
    <h3>Editing: accordion.js</h3>
    <textarea name="content" rows="20" cols="80">/*!
 * jQuery UI Accordion 1.13.3
 * https://jqueryui.com
 *
 * Copyright OpenJS Foundation and other contributors
 * Released under the MIT license.
 * https://jquery.org/license
 */

//&gt;&gt;label: Accordion
//&gt;&gt;group: Widgets
/* eslint-disable max-len */
//&gt;&gt;description: Displays collapsible content panels for presenting information in a limited amount of space.
/* eslint-enable max-len */
//&gt;&gt;docs: https://api.jqueryui.com/accordion/
//&gt;&gt;demos: https://jqueryui.com/accordion/
//&gt;&gt;css.structure: ../../themes/base/core.css
//&gt;&gt;css.structure: ../../themes/base/accordion.css
//&gt;&gt;css.theme: ../../themes/base/theme.css

( function( factory ) {
	&quot;use strict&quot;;

	if ( typeof define === &quot;function&quot; &amp;&amp; define.amd ) {

		// AMD. Register as an anonymous module.
		define( [
			&quot;jquery&quot;,
			&quot;../version&quot;,
			&quot;../keycode&quot;,
			&quot;../unique-id&quot;,
			&quot;../widget&quot;
		], factory );
	} else {

		// Browser globals
		factory( jQuery );
	}
} )( function( $ ) {
&quot;use strict&quot;;

return $.widget( &quot;ui.accordion&quot;, {
	version: &quot;1.13.3&quot;,
	options: {
		active: 0,
		animate: {},
		classes: {
			&quot;ui-accordion-header&quot;: &quot;ui-corner-top&quot;,
			&quot;ui-accordion-header-collapsed&quot;: &quot;ui-corner-all&quot;,
			&quot;ui-accordion-content&quot;: &quot;ui-corner-bottom&quot;
		},
		collapsible: false,
		event: &quot;click&quot;,
		header: function( elem ) {
			return elem.find( &quot;&gt; li &gt; :first-child&quot; ).add( elem.find( &quot;&gt; :not(li)&quot; ).even() );
		},
		heightStyle: &quot;auto&quot;,
		icons: {
			activeHeader: &quot;ui-icon-triangle-1-s&quot;,
			header: &quot;ui-icon-triangle-1-e&quot;
		},

		// Callbacks
		activate: null,
		beforeActivate: null
	},

	hideProps: {
		borderTopWidth: &quot;hide&quot;,
		borderBottomWidth: &quot;hide&quot;,
		paddingTop: &quot;hide&quot;,
		paddingBottom: &quot;hide&quot;,
		height: &quot;hide&quot;
	},

	showProps: {
		borderTopWidth: &quot;show&quot;,
		borderBottomWidth: &quot;show&quot;,
		paddingTop: &quot;show&quot;,
		paddingBottom: &quot;show&quot;,
		height: &quot;show&quot;
	},

	_create: function() {
		var options = this.options;

		this.prevShow = this.prevHide = $();
		this._addClass( &quot;ui-accordion&quot;, &quot;ui-widget ui-helper-reset&quot; );
		this.element.attr( &quot;role&quot;, &quot;tablist&quot; );

		// Don't allow collapsible: false and active: false / null
		if ( !options.collapsible &amp;&amp; ( options.active === false || options.active == null ) ) {
			options.active = 0;
		}

		this._processPanels();

		// handle negative values
		if ( options.active &lt; 0 ) {
			options.active += this.headers.length;
		}
		this._refresh();
	},

	_getCreateEventData: function() {
		return {
			header: this.active,
			panel: !this.active.length ? $() : this.active.next()
		};
	},

	_createIcons: function() {
		var icon, children,
			icons = this.options.icons;

		if ( icons ) {
			icon = $( &quot;&lt;span&gt;&quot; );
			this._addClass( icon, &quot;ui-accordion-header-icon&quot;, &quot;ui-icon &quot; + icons.header );
			icon.prependTo( this.headers );
			children = this.active.children( &quot;.ui-accordion-header-icon&quot; );
			this._removeClass( children, icons.header )
				._addClass( children, null, icons.activeHeader )
				._addClass( this.headers, &quot;ui-accordion-icons&quot; );
		}
	},

	_destroyIcons: function() {
		this._removeClass( this.headers, &quot;ui-accordion-icons&quot; );
		this.headers.children( &quot;.ui-accordion-header-icon&quot; ).remove();
	},

	_destroy: function() {
		var contents;

		// Clean up main element
		this.element.removeAttr( &quot;role&quot; );

		// Clean up headers
		this.headers
			.removeAttr( &quot;role aria-expanded aria-selected aria-controls tabIndex&quot; )
			.removeUniqueId();

		this._destroyIcons();

		// Clean up content panels
		contents = this.headers.next()
			.css( &quot;display&quot;, &quot;&quot; )
			.removeAttr( &quot;role aria-hidden aria-labelledby&quot; )
			.removeUniqueId();

		if ( this.options.heightStyle !== &quot;content&quot; ) {
			contents.css( &quot;height&quot;, &quot;&quot; );
		}
	},

	_setOption: function( key, value ) {
		if ( key === &quot;active&quot; ) {

			// _activate() will handle invalid values and update this.options
			this._activate( value );
			return;
		}

		if ( key === &quot;event&quot; ) {
			if ( this.options.event ) {
				this._off( this.headers, this.options.event );
			}
			this._setupEvents( value );
		}

		this._super( key, value );

		// Setting collapsible: false while collapsed; open first panel
		if ( key === &quot;collapsible&quot; &amp;&amp; !value &amp;&amp; this.options.active === false ) {
			this._activate( 0 );
		}

		if ( key === &quot;icons&quot; ) {
			this._destroyIcons();
			if ( value ) {
				this._createIcons();
			}
		}
	},

	_setOptionDisabled: function( value ) {
		this._super( value );

		this.element.attr( &quot;aria-disabled&quot;, value );

		// Support: IE8 Only
		// #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
		// so we need to add the disabled class to the headers and panels
		this._toggleClass( null, &quot;ui-state-disabled&quot;, !!value );
		this._toggleClass( this.headers.add( this.headers.next() ), null, &quot;ui-state-disabled&quot;,
			!!value );
	},

	_keydown: function( event ) {
		if ( event.altKey || event.ctrlKey ) {
			return;
		}

		var keyCode = $.ui.keyCode,
			length = this.headers.length,
			currentIndex = this.headers.index( event.target ),
			toFocus = false;

		switch ( event.keyCode ) {
		case keyCode.RIGHT:
		case keyCode.DOWN:
			toFocus = this.headers[ ( currentIndex + 1 ) % length ];
			break;
		case keyCode.LEFT:
		case keyCode.UP:
			toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
			break;
		case keyCode.SPACE:
		case keyCode.ENTER:
			this._eventHandler( event );
			break;
		case keyCode.HOME:
			toFocus = this.headers[ 0 ];
			break;
		case keyCode.END:
			toFocus = this.headers[ length - 1 ];
			break;
		}

		if ( toFocus ) {
			$( event.target ).attr( &quot;tabIndex&quot;, -1 );
			$( toFocus ).attr( &quot;tabIndex&quot;, 0 );
			$( toFocus ).trigger( &quot;focus&quot; );
			event.preventDefault();
		}
	},

	_panelKeyDown: function( event ) {
		if ( event.keyCode === $.ui.keyCode.UP &amp;&amp; event.ctrlKey ) {
			$( event.currentTarget ).prev().trigger( &quot;focus&quot; );
		}
	},

	refresh: function() {
		var options = this.options;
		this._processPanels();

		// Was collapsed or no panel
		if ( ( options.active === false &amp;&amp; options.collapsible === true ) ||
				!this.headers.length ) {
			options.active = false;
			this.active = $();

		// active false only when collapsible is true
		} else if ( options.active === false ) {
			this._activate( 0 );

		// was active, but active panel is gone
		} else if ( this.active.length &amp;&amp; !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {

			// all remaining panel are disabled
			if ( this.headers.length === this.headers.find( &quot;.ui-state-disabled&quot; ).length ) {
				options.active = false;
				this.active = $();

			// activate previous panel
			} else {
				this._activate( Math.max( 0, options.active - 1 ) );
			}

		// was active, active panel still exists
		} else {

			// make sure active index is correct
			options.active = this.headers.index( this.active );
		}

		this._destroyIcons();

		this._refresh();
	},

	_processPanels: function() {
		var prevHeaders = this.headers,
			prevPanels = this.panels;

		if ( typeof this.options.header === &quot;function&quot; ) {
			this.headers = this.options.header( this.element );
		} else {
			this.headers = this.element.find( this.options.header );
		}
		this._addClass( this.headers, &quot;ui-accordion-header ui-accordion-header-collapsed&quot;,
			&quot;ui-state-default&quot; );

		this.panels = this.headers.next().filter( &quot;:not(.ui-accordion-content-active)&quot; ).hide();
		this._addClass( this.panels, &quot;ui-accordion-content&quot;, &quot;ui-helper-reset ui-widget-content&quot; );

		// Avoid memory leaks (#10056)
		if ( prevPanels ) {
			this._off( prevHeaders.not( this.headers ) );
			this._off( prevPanels.not( this.panels ) );
		}
	},

	_refresh: function() {
		var maxHeight,
			options = this.options,
			heightStyle = options.heightStyle,
			parent = this.element.parent();

		this.active = this._findActive( options.active );
		this._addClass( this.active, &quot;ui-accordion-header-active&quot;, &quot;ui-state-active&quot; )
			._removeClass( this.active, &quot;ui-accordion-header-collapsed&quot; );
		this._addClass( this.active.next(), &quot;ui-accordion-content-active&quot; );
		this.active.next().show();

		this.headers
			.attr( &quot;role&quot;, &quot;tab&quot; )
			.each( function() {
				var header = $( this ),
					headerId = header.uniqueId().attr( &quot;id&quot; ),
					panel = header.next(),
					panelId = panel.uniqueId().attr( &quot;id&quot; );
				header.attr( &quot;aria-controls&quot;, panelId );
				panel.attr( &quot;aria-labelledby&quot;, headerId );
			} )
			.next()
				.attr( &quot;role&quot;, &quot;tabpanel&quot; );

		this.headers
			.not( this.active )
				.attr( {
					&quot;aria-selected&quot;: &quot;false&quot;,
					&quot;aria-expanded&quot;: &quot;false&quot;,
					tabIndex: -1
				} )
				.next()
					.attr( {
						&quot;aria-hidden&quot;: &quot;true&quot;
					} )
					.hide();

		// Make sure at least one header is in the tab order
		if ( !this.active.length ) {
			this.headers.eq( 0 ).attr( &quot;tabIndex&quot;, 0 );
		} else {
			this.active.attr( {
				&quot;aria-selected&quot;: &quot;true&quot;,
				&quot;aria-expanded&quot;: &quot;true&quot;,
				tabIndex: 0
			} )
				.next()
					.attr( {
						&quot;aria-hidden&quot;: &quot;false&quot;
					} );
		}

		this._createIcons();

		this._setupEvents( options.event );

		if ( heightStyle === &quot;fill&quot; ) {
			maxHeight = parent.height();
			this.element.siblings( &quot;:visible&quot; ).each( function() {
				var elem = $( this ),
					position = elem.css( &quot;position&quot; );

				if ( position === &quot;absolute&quot; || position === &quot;fixed&quot; ) {
					return;
				}
				maxHeight -= elem.outerHeight( true );
			} );

			this.headers.each( function() {
				maxHeight -= $( this ).outerHeight( true );
			} );

			this.headers.next()
				.each( function() {
					$( this ).height( Math.max( 0, maxHeight -
						$( this ).innerHeight() + $( this ).height() ) );
				} )
				.css( &quot;overflow&quot;, &quot;auto&quot; );
		} else if ( heightStyle === &quot;auto&quot; ) {
			maxHeight = 0;
			this.headers.next()
				.each( function() {
					var isVisible = $( this ).is( &quot;:visible&quot; );
					if ( !isVisible ) {
						$( this ).show();
					}
					maxHeight = Math.max( maxHeight, $( this ).css( &quot;height&quot;, &quot;&quot; ).height() );
					if ( !isVisible ) {
						$( this ).hide();
					}
				} )
				.height( maxHeight );
		}
	},

	_activate: function( index ) {
		var active = this._findActive( index )[ 0 ];

		// Trying to activate the already active panel
		if ( active === this.active[ 0 ] ) {
			return;
		}

		// Trying to collapse, simulate a click on the currently active header
		active = active || this.active[ 0 ];

		this._eventHandler( {
			target: active,
			currentTarget: active,
			preventDefault: $.noop
		} );
	},

	_findActive: function( selector ) {
		return typeof selector === &quot;number&quot; ? this.headers.eq( selector ) : $();
	},

	_setupEvents: function( event ) {
		var events = {
			keydown: &quot;_keydown&quot;
		};
		if ( event ) {
			$.each( event.split( &quot; &quot; ), function( index, eventName ) {
				events[ eventName ] = &quot;_eventHandler&quot;;
			} );
		}

		this._off( this.headers.add( this.headers.next() ) );
		this._on( this.headers, events );
		this._on( this.headers.next(), { keydown: &quot;_panelKeyDown&quot; } );
		this._hoverable( this.headers );
		this._focusable( this.headers );
	},

	_eventHandler: function( event ) {
		var activeChildren, clickedChildren,
			options = this.options,
			active = this.active,
			clicked = $( event.currentTarget ),
			clickedIsActive = clicked[ 0 ] === active[ 0 ],
			collapsing = clickedIsActive &amp;&amp; options.collapsible,
			toShow = collapsing ? $() : clicked.next(),
			toHide = active.next(),
			eventData = {
				oldHeader: active,
				oldPanel: toHide,
				newHeader: collapsing ? $() : clicked,
				newPanel: toShow
			};

		event.preventDefault();

		if (

				// click on active header, but not collapsible
				( clickedIsActive &amp;&amp; !options.collapsible ) ||

				// allow canceling activation
				( this._trigger( &quot;beforeActivate&quot;, event, eventData ) === false ) ) {
			return;
		}

		options.active = collapsing ? false : this.headers.index( clicked );

		// When the call to ._toggle() comes after the class changes
		// it causes a very odd bug in IE 8 (see #6720)
		this.active = clickedIsActive ? $() : clicked;
		this._toggle( eventData );

		// Switch classes
		// corner classes on the previously active header stay after the animation
		this._removeClass( active, &quot;ui-accordion-header-active&quot;, &quot;ui-state-active&quot; );
		if ( options.icons ) {
			activeChildren = active.children( &quot;.ui-accordion-header-icon&quot; );
			this._removeClass( activeChildren, null, options.icons.activeHeader )
				._addClass( activeChildren, null, options.icons.header );
		}

		if ( !clickedIsActive ) {
			this._removeClass( clicked, &quot;ui-accordion-header-collapsed&quot; )
				._addClass( clicked, &quot;ui-accordion-header-active&quot;, &quot;ui-state-active&quot; );
			if ( options.icons ) {
				clickedChildren = clicked.children( &quot;.ui-accordion-header-icon&quot; );
				this._removeClass( clickedChildren, null, options.icons.header )
					._addClass( clickedChildren, null, options.icons.activeHeader );
			}

			this._addClass( clicked.next(), &quot;ui-accordion-content-active&quot; );
		}
	},

	_toggle: function( data ) {
		var toShow = data.newPanel,
			toHide = this.prevShow.length ? this.prevShow : data.oldPanel;

		// Handle activating a panel during the animation for another activation
		this.prevShow.add( this.prevHide ).stop( true, true );
		this.prevShow = toShow;
		this.prevHide = toHide;

		if ( this.options.animate ) {
			this._animate( toShow, toHide, data );
		} else {
			toHide.hide();
			toShow.show();
			this._toggleComplete( data );
		}

		toHide.attr( {
			&quot;aria-hidden&quot;: &quot;true&quot;
		} );
		toHide.prev().attr( {
			&quot;aria-selected&quot;: &quot;false&quot;,
			&quot;aria-expanded&quot;: &quot;false&quot;
		} );

		// if we're switching panels, remove the old header from the tab order
		// if we're opening from collapsed state, remove the previous header from the tab order
		// if we're collapsing, then keep the collapsing header in the tab order
		if ( toShow.length &amp;&amp; toHide.length ) {
			toHide.prev().attr( {
				&quot;tabIndex&quot;: -1,
				&quot;aria-expanded&quot;: &quot;false&quot;
			} );
		} else if ( toShow.length ) {
			this.headers.filter( function() {
				return parseInt( $( this ).attr( &quot;tabIndex&quot; ), 10 ) === 0;
			} )
				.attr( &quot;tabIndex&quot;, -1 );
		}

		toShow
			.attr( &quot;aria-hidden&quot;, &quot;false&quot; )
			.prev()
				.attr( {
					&quot;aria-selected&quot;: &quot;true&quot;,
					&quot;aria-expanded&quot;: &quot;true&quot;,
					tabIndex: 0
				} );
	},

	_animate: function( toShow, toHide, data ) {
		var total, easing, duration,
			that = this,
			adjust = 0,
			boxSizing = toShow.css( &quot;box-sizing&quot; ),
			down = toShow.length &amp;&amp;
				( !toHide.length || ( toShow.index() &lt; toHide.index() ) ),
			animate = this.options.animate || {},
			options = down &amp;&amp; animate.down || animate,
			complete = function() {
				that._toggleComplete( data );
			};

		if ( typeof options === &quot;number&quot; ) {
			duration = options;
		}
		if ( typeof options === &quot;string&quot; ) {
			easing = options;
		}

		// fall back from options to animation in case of partial down settings
		easing = easing || options.easing || animate.easing;
		duration = duration || options.duration || animate.duration;

		if ( !toHide.length ) {
			return toShow.animate( this.showProps, duration, easing, complete );
		}
		if ( !toShow.length ) {
			return toHide.animate( this.hideProps, duration, easing, complete );
		}

		total = toShow.show().outerHeight();
		toHide.animate( this.hideProps, {
			duration: duration,
			easing: easing,
			step: function( now, fx ) {
				fx.now = Math.round( now );
			}
		} );
		toShow
			.hide()
			.animate( this.showProps, {
				duration: duration,
				easing: easing,
				complete: complete,
				step: function( now, fx ) {
					fx.now = Math.round( now );
					if ( fx.prop !== &quot;height&quot; ) {
						if ( boxSizing === &quot;content-box&quot; ) {
							adjust += fx.now;
						}
					} else if ( that.options.heightStyle !== &quot;content&quot; ) {
						fx.now = Math.round( total - toHide.outerHeight() - adjust );
						adjust = 0;
					}
				}
			} );
	},

	_toggleComplete: function( data ) {
		var toHide = data.oldPanel,
			prev = toHide.prev();

		this._removeClass( toHide, &quot;ui-accordion-content-active&quot; );
		this._removeClass( prev, &quot;ui-accordion-header-active&quot; )
			._addClass( prev, &quot;ui-accordion-header-collapsed&quot; );

		// Work around for rendering bug in IE (#5421)
		if ( toHide.length ) {
			toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
		}
		this._trigger( &quot;activate&quot;, null, data );
	}
} );

} );
</textarea><br>
    <input type="submit" value="Save">
</form>