Toggles a class on an element when a scroll direction has been detected.
@param {Element} el The element.
@param {Object} config Config options.
@constructor
430341
function ScrollToggle(el, config) {
  this.el_ = el;

  this.config_ = objects.clone(config);
  if (this.el_.hasAttribute('data-ak-scrolltoggle')) {
    var elConfig = JSON.parse(this.el_.getAttribute('data-ak-scrolltoggle'));
    if (elConfig && typeof elConfig === 'object') {
      objects.merge(this.config_, elConfig);
    }
  }

  // Initialize the current scroll position.
  this.lastScrollPos_ = 0;
  this.onScroll();
}
486822
function (oConfigs) {

		    Prog.superclass.initAttributes.call(this, oConfigs);
			this.set('innerHTML',Prog.MARKUP);
			this.addClass(CLASS_PROGBAR);
			
			// I need to apply at least the following styles, if present in oConfigs, 
			// to the ProgressBar so when it later reads the width and height, 
			// they are already set to the correct values.
			// id is important because it can be used as a CSS selector.
			var key, presets = ['id',WIDTH,HEIGHT,'class','style'];
			while((key = presets.pop())) {
				if (key in oConfigs) {
					this.set(key,oConfigs[key]);
				}
			}
			

			/**
			 * @attribute barEl
			 * @description Reference to the HTML object that makes the moving bar (read-only)
			 * @type HTMLElement (div)
			 * @readonly
			 */			
		    this.setAttributeConfig(BAR_EL, {
		        readOnly: true,
		        value: this.getElementsByClassName(CLASS_BAR)[0]
		    });
			/**
			 * @attribute maskEl
			 * @description Reference to the HTML object that overlays the bar providing the mask. (read-only)
			 * @type HTMLElement (table)
			 * @readonly
			 */			
		    this.setAttributeConfig(MASK_EL, {
		        readOnly: true,
		        value: this.getElementsByClassName(CLASS_MASK)[0]
		    });
			
			
			/**
			 * @attribute direction
			 * @description Direction of movement of the bar.  
			 *    It can be any of 'ltr' (left to right), 'rtl' (the reverse) , 'ttb' (top to bottom) or 'btt'.
			 *    Can only be set once and only before rendering.
			 * @default 'ltr'
			 * @type String (any of "ltr", "rtl", "ttb" or "btt")
			 */			
			this.setAttributeConfig(DIRECTION, {
				value:DIRECTION_LTR,
				validator:function(value) {
					if (this._rendered) { return false; }
					switch (value) {
						case DIRECTION_LTR:
						case DIRECTION_RTL:
						case DIRECTION_TTB:
						case DIRECTION_BTT:
							return true;
						default:
							return false;
					}
				},
				method: function(value) {
					this._barSizeFunction = this._barSizeFunctions[this.get(ANIM)?1:0][value];
				}
			});
			
			/**
			 * @attribute maxValue
			 * @description Represents the top value for the bar. 
			 *   The bar will be fully extended when reaching this value.  
			 *   Values higher than this will be ignored. 
			 * @default 100
			 * @type Number
			 */				    
		    this.setAttributeConfig(MAX_VALUE, {
		        value: 100,
				validator: Lang.isNumber,
				method: function (value) {
					this.get('element').setAttribute('aria-valuemax',value);
					if (this.get(VALUE) > value) { this.set(VALUE,value); }
				}
		    });
			
			/**
			 * @attribute minValue
			 * @description Represents the lowest value for the bar. 
			 *   The bar will be totally collapsed when reaching this value.  
			 *    Values lower than this will be ignored. 
			 * @default 0
			 * @type Number
			 */				

		    this.setAttributeConfig(MIN_VALUE, {
		        value: 0,
				validator: Lang.isNumber,
				method: function (value) {
					this.get('element').setAttribute('aria-valuemin',value);
					if (this.get(VALUE) < value) { this.set(VALUE,value); }
				}
		    });
			/**
			 * @attribute width
			 * @description Width of the ProgressBar.
			 *     If a number, it will be assumed to be in pixels.  
			 *     If a string it should be a valid setting for the CSS width attribute.  
			 *     It will always be returned as a string including units.
			 * @default "200px"
			 * @type Number or String
			 */				

		    this.setAttributeConfig(WIDTH, {
				getter: function() {
					return this.getStyle(WIDTH);
				},
				method: this._widthChange
		    });
		

			/**
			 * @attribute height
			 * @description Height of the ProgressBar.
			 *     If a number, it will be assumed to be in pixels.  
			 *     If a string it should be a valid setting for the CSS height attribute.  
			 *     It will always be returned as a string including units.
			 * @default "20px"
			 * @type Number or String
			 */				
		    this.setAttributeConfig(HEIGHT, {
				getter:function() {
					return this.getStyle(HEIGHT);
				},
				method: this._heightChange
		    });
			
			
	
			/**
			 * @attribute ariaTextTemplate 
			 * @description Text to be voiced by screen readers.
			 *     The text is processed by <a href="YAHOO.lang.html#method_substitute">YAHOO.lang.substitute</a>.  
			 *     It can use the placeholders {value}, {minValue} and {maxValue}
			 * @default "{value}"
			 * @type String
			 */				
			this.setAttributeConfig(ARIA_TEXT_TEMPLATE, {
				value:'{value}'
			});
			
			/**
			 * @attribute value
			 * @description The value for the bar.  
			 *     Valid values are in between the minValue and maxValue attributes.
			 * @default 0
			 * @type Number
			 */			
			this.setAttributeConfig(VALUE, {
				value: 0,
				validator: function(value) {
					return Lang.isNumber(value) && value >= this.get(MIN_VALUE) && value <= this.get(MAX_VALUE);
				},
				method: this._valueChange
		    });
			
			/**
			 * @attribute anim
			 * @description it accepts either a boolean (recommended) or an instance of <a href="YAHOO.util.Anim.html">YAHOO.util.Anim</a>.
			 *   If a boolean, it will enable/disable animation creating its own instance of the animation utility.  
			 *   If given an instance of <a href="YAHOO.util.Anim.html">YAHOO.util.Anim</a> it will use that instance.
			 *   The <a href="YAHOO.util.Anim.html">animation</a> utility needs to be loaded.
			 *   When read, it returns the instance of the animation utility in use or null if none.  
			 *   It can be used to set the animation parameters such as easing methods or duration.
			 * @default null
			 * @type {boolean} or {instance of YAHOO.util.Anim}
			 */						
			this.setAttributeConfig(ANIM, {
				validator: function(value) {
					return !!YAHOO.util.Anim;
				},
				setter: this._animSetter
			});
			
			
		}
197640
function updateIsOpen(isOpen) {
        var parent = element.parent();

        if (scope.keyDown) {
          parent[isOpen ? 'on' : 'off']('keydown', onKeyDown);
        }

        if (isOpen) {
          triggeringElement = $document[0].activeElement;
        }

        return promise = $q.all([
          $animate[isOpen ? 'removeClass' : 'addClass'](element, 'toggle-component-closed')
            .then(function setElementFocus() {
              if (scope.isOpen) {
                element.focus();
              }
            })
        ]);
      }
665275
function toggleCss() {
    if (!cssOpen) {
      exampleCss.classList.remove(hiddenClass);
      showCssBtn.innerHTML = hideText;
      cssOpen = true;
    } else {
      exampleCss.classList.add(hiddenClass);
      exampleScss.scrollIntoView();
      showCssBtn.innerHTML = showText;
      cssOpen = false;
    }
  }
914478
function(accordion, el){
		var THIS            = this;
		var heading         = el.firstElementChild;
		var content         = el.lastElementChild;
		var elClasses       = el.classList;
		var openClass       = accordion.openClass;
		var closeClass      = accordion.closeClass;
		var keysEnabled     = !accordion.noKeys;
		var useBorders      = accordion.useBorders;
		var useTransforms   = !accordion.noTransforms && cssTransform;
		var onToggle        = accordion.onToggle;
		var _disabled       = false;
		var _open, _y, _height, _ariaEnabled;
		var scrollX, scrollY;
		var onTouchStart;
		var onKeyDown;
		var onPress;
		
		
		Object.defineProperties(THIS, {
			fit: {value: fit},
			
			
			// Add or remove relevant ARIA attributes from the fold's elements
			ariaEnabled: {
				get: function(){ return _ariaEnabled; },
				set: function(input){
					if((input = !!input) !== !!_ariaEnabled){
						_ariaEnabled = input;
						
						// Enable ARIA-attribute management
						if(input){
							heading.setAttribute("role", "tab");
							content.setAttribute("role", "tabpanel");
							checkIDs();
							
							// Update the attributes that're controlled by .open's setter
							heading.setAttribute("aria-selected", !!_open);
							heading.setAttribute("aria-expanded", !!_open);
							content.setAttribute("aria-hidden",   !_open);
						}
						
						// Disabling; remove all relevant attributes
						else{
							heading.removeAttribute("role");
							heading.removeAttribute("aria-controls");
							heading.removeAttribute("aria-selected");
							heading.removeAttribute("aria-expanded");
							
							content.removeAttribute("role");
							content.removeAttribute("aria-labelledby");
							content.removeAttribute("aria-hidden");
						}
					}
				}
			},

			
			
			// Whether or not the fold's currently opened
			open: {
				
				get: function(){
					
					// Derive the fold's opened state from the DOM if it's not been determined yet
					if(undefined === _open){
						_open = elClasses.contains(openClass);
						setToken(elClasses, closeClass, !_open);
					}
					
					return _open;
				},
				
				
				set: function(input){
					if((input = !!input) !== _open){
						
						// If an onToggle callback was specified, run it. Avoid doing anything if it returns false.
						if("function" === typeof onToggle && false === onToggle.call(null, THIS, input))
							return;
						
						setToken(elClasses, openClass,   input);
						setToken(elClasses, closeClass, !input);
						_open = input;
						
						// Update ARIA attributes
						if(_ariaEnabled){
							heading.setAttribute("aria-selected",  input);
							heading.setAttribute("aria-expanded",  input);
							content.setAttribute("aria-hidden",   !input);
						}
						
						// If this fold was closed when the screen resized, run a full update in case its contents were juggled around
						if(THIS.needsRefresh){
							delete THIS.needsRefresh;
							accordion.refresh();
						}
						else accordion.update();
						
						// Close other folds if accordion is modal
						if(accordion.modal && _open){
							for(var fold, i = 0, l = accordion.folds.length; i < l; ++i){
								if(THIS !== (fold = accordion.folds[i]))
									fold.open = false;
							}
						}
					}
				}
			},
			
			
			// Whether the fold's been deactivated
			disabled: {
				get: function(){ return _disabled },
				set: function(input){
					if((input = !!input) !== _disabled){
						var style = el.style;
						
						// Deactivated
						if(_disabled = input){
							style.height = null;
							useTransforms
								? (style[cssTransform] = null)
								: (style.top = null);
							
							touchEnabled && heading.removeEventListener("touchstart", onTouchStart);
							heading.removeEventListener(pressEvent, onPress);
							elClasses.remove(openClass, closeClass);
							if(onKeyDown){
								heading.removeEventListener("keydown", onKeyDown);
								heading.removeAttribute("tabindex");
							}
							
							if(_ariaEnabled){
								THIS.ariaEnabled = false;
								_ariaEnabled     = true;
							}
						}
						
						// Reactivated
						else{
							style.height = _height + "px";
							useTransforms
								? style[cssTransform] =
									css3DSupported
										? ("translate3D(0," + _y + "px,0)")
										: ("translateY("    + _y + "px)")
								: (style.top = _y + "px");
							
							touchEnabled && heading.addEventListener("touchstart", onTouchStart);
							heading.addEventListener(pressEvent, onPress);
							
							if(onKeyDown){
								heading.addEventListener("keydown", onKeyDown);
								heading.tabIndex = 0;
							}
						}
					}
				}
			},
			
			
			// Vertical position of the fold within an accordion's container
			y: {
				get: function(){
					if(undefined === _y)
						return (_y = parseInt(el.style.top) || 0);
					return _y;
				},
				
				set: function(input){
					if((input = +input) !== _y){
						_y = input;
						useTransforms
							? el.style[cssTransform] =
								css3DSupported
									? ("translate3D(0," + input + "px,0)")
									: ("translateY("    + input + "px)")
							: (el.style.top = input + "px");
					}
				}
			},
			
			
			// Height of the fold's outermost container
			height: {
				
				get: function(){
					if(undefined === _height){
						_height = THIS.headingHeight + content.scrollHeight;
						el.style.height = _height + "px";
					}
					return _height;
				},
				
				set: function(input){
					if(input && (input = +input) !== _height){
						el.style.height = input + "px"
						_height         = input;
					}
				}
			},
			

			// Current height of the fold's heading
			headingHeight: {
				get: function(){
					return heading.scrollHeight
						+ THIS.heightOffset
						+ (useBorders ? THIS.headingBorder : 0)
				}
			},
			
			// Total height consumed by the heading element's CSS borders, if any
			headingBorder: {
				get: function(){
					return (heading.offsetHeight || 0) - (heading.clientHeight || 0);
				}
			},
			
			
			
			// Total height of the fold's container element
			elHeight: {
				get: function(){
					return el.scrollHeight + (useBorders ? THIS.elBorder : 0);
				}
			},
			
			// Total height consumed by container element's CSS borders, if any
			elBorder: {
				get: function(){
					return (el.offsetHeight || 0) - (el.clientHeight || 0);
				}
			},
			
			
			// Whether the fold's container has been resized incorrectly
			wrongSize: {
				get: function(){
					return THIS.headingHeight + content.scrollHeight !== el.scrollHeight;
				}
			}
		});
		
		
		
		THIS.index        = folds.push(THIS) - 1;
		THIS.accordion    = accordion;
		THIS.el           = el;
		THIS.heading      = heading;
		THIS.content      = content;
		THIS.ariaEnabled  = !accordion.noAria;
		THIS.heightOffset = accordion.heightOffset;
		el.accordionFold  = THIS.index;
		useBorders        = "auto" === useBorders ? (0 !== THIS.elBorder + THIS.headingBorder) : useBorders;
		
		
		
		function checkIDs(){
			var headingSuffix = "-heading";
			var contentSuffix = "-content";
			var elID            = el.id;
			var id;
			
			// Neither of the fold's elements have an ID attribute
			if(!heading.id && !content.id){
				id             = elID || uniqueID("a");
				heading.id     = id + headingSuffix;
				content.id     = id + contentSuffix;
			}
			
			// Either the heading or element lack an ID
			else if(!content.id) content.id   = (elID || heading.id) + contentSuffix;
			else if(!heading.id) heading.id   = (elID || content.id) + headingSuffix;
			
			// Finally, double-check each element's ID is really unique
			var $ = function(s){return document.querySelectorAll("#"+s)};
			while($(content.id).length > 1 || $(heading.id).length > 1){
				id         = uniqueID("a");
				content.id = id + contentSuffix;
				heading.id = id + headingSuffix;
			}
			
			// Update ARIA attributes
			heading.setAttribute("aria-controls",    content.id);
			content.setAttribute("aria-labelledby",  heading.id);
		}
		
		
		
		// Keyboard navigation
		if(keysEnabled){
			heading.tabIndex = 0;
			heading.addEventListener("keydown", onKeyDown = function(e){
				var key = e.keyCode;
				var fold;
				
				switch(key){

					// Spacebar: Toggle
					case 32:
						e.preventDefault(); // Fall-through
					
					
					// Enter: Toggle
					case 13:
						THIS.open = !THIS.open;
						if("A" === e.target.tagName)
							e.preventDefault();
						break;
					
					
					// Escape: Clear focus
					case 27:
						e.target.blur();
						break;
					
					
					// Up arrow: Previous section
					case 38:{
						
						// Is there a previous sibling to navigate up to?
						if(fold = THIS.previousFold){
							var children = fold.childAccordions;
							
							// Is it open, and does it have nested accordions?
							if(fold.open && children){
								var lastAcc;
								var lastFold;
								
								// Locate the deepest/nearest accordion that's currently exposed
								while(children){
									lastAcc  = children[children.length - 1];
									lastFold = lastAcc.folds[lastAcc.folds.length - 1];
									if(!lastFold.open) break;
									children = lastFold.childAccordions;
								}
								
								lastFold.heading.focus();
							}
							
							// Nope
							else fold.heading.focus();
						}
						
						// Is there a higher level we can jump back up to?
						else if(accordion.parent)
							accordion.parentFold.heading.focus();
						
						// There's nothing to move back to, so just let the browser run its usual behaviour
						else return true;
						
						e.preventDefault();
						return false;
					}
					
					
					
					// Down arrow: Next section
					case 40:{
						var children = THIS.childAccordions;
						
						// Is there a nested accordion to jump into?
						if(THIS.open && children)
							children[0].folds[0].heading.focus();
						
						// No, there isn't. Is there another sibling to move down to?
						else if(fold = THIS.nextFold)
							fold.heading.focus();
						
						// Is there a containing accordion we can navigate back up to?
						else if(THIS.accordion.parent){
							var parent = THIS;
							while(parent = parent.accordion.parentFold)
								if(fold = parent.nextFold){
									fold.heading.focus();
									break;
								}
							
							// Nowhere left to go...
							if(!parent) return true;
						}
						
						// Nah. Just scroll the window normally, as per browser default
						else return true;
						
						e.preventDefault();
						return false;
					}
					
					
					// Left arrow
					case 37:{
						
						// Close an opened section
						if(THIS.open) THIS.open = false;
						
						// Switch focus back to parent
						else if(accordion.parent)
							accordion.parentFold.heading.focus();
						
						break;
					}
					
					// Right arrow
					case 39:{
						var children = THIS.childAccordions;
						
						// Open a closed section
						if(!THIS.open) THIS.open = true;
						
						// Switch focus to a nested accordion
						else if(children)
							children[0].folds[0].heading.focus();
						
						break;
					}
				}
			});
		}
		
		
		// Listener to record the viewport's scroll offsets at the beginning of a touch
		touchEnabled && heading.addEventListener("touchstart", onTouchStart = function(e){
			scrollX = window.pageXOffset;
			scrollY = window.pageYOffset;
		}, {passive: true});
		
		
		heading.addEventListener(pressEvent, onPress = function(e){
			
			// Pressed on something inside the header
			if(e.target !== heading && heading.contains(e.target)){
				
				// Cancel fold-toggle if user clicked on an anchor-link
				if("A" === e.target.tagName && e.target.href)
					return true;
			}
			
			if(e.type !== "touchend" || (e.cancelable && window.pageXOffset === scrollX && window.pageYOffset === scrollY)){
				THIS.open = !THIS.open;
				e.preventDefault();
			}
			return false;
		});
		
		
		
		
		/**
		 * Adjust a fold's container to fit its content.
		 */
		function fit(){
			var height = THIS.headingHeight;
			if(THIS.open)   height += content.scrollHeight;
			if(useBorders)  height += THIS.elBorder;
			THIS.height = height;
		}
	}
1009316
function (e) {
            if (e && e.preventDefault) e.preventDefault();
            var $el = $(e.target);
            var cid = $el.attr('todo-cid');
            if (cid) {
                this.options.toggleItem(cid);
            }
            return false;
        }
214457
function toggle(ev) {
		if (ev)
			ev.preventDefault()
		
		autoTime = 0
		autoPlay = true
		curTimeline = curTimeline === anim1 ? anim2 : anim1
		duration = curTimeline.duration()

		//clear style
		widget.element.style.cssText = ''

		editor.show(curTimeline === anim1 ? 0 : 1)
		editor.hide(curTimeline === anim1 ? 1 : 0)
	}
206697
function (el, cls) {
        cls = getString(cls);
        if (!cls) return;
        if (Array.isArray(cls)) {
            cls.forEach(function(c) {
                dom.addClass(el, c);
            });
        } else if (el.classList) {
            el.classList.add(cls);
        } else {
            if (!hasClass(el, cls)) {
                if (el.classList) {
                    el.classList.add(cls);
                } else {
                    el.className += ' ' + cls;
                }
            }
        }
    }
1111820
function(elementId, apiController, direction) {

            if (elementId == pgwSlideshow.currentSlide) {
                return false;
            }

            var element = pgwSlideshow.data[elementId - 1];

            if (typeof element == 'undefined') {
                throw new Error('pgwSlideshow - The element ' + elementId + ' is undefined');
                return false;
            }

            if (typeof direction == 'undefined') {
                direction = 'left';
            }

            // Before slide
            if (typeof pgwSlideshow.config.beforeSlide == 'function') {
                pgwSlideshow.config.beforeSlide(elementId);
            }

            if (typeof pgwSlideshow.plugin.find('.ps-caption').fadeOut == 'function') {
                pgwSlideshow.plugin.find('.ps-caption, .ps-prev, .ps-next').fadeOut(pgwSlideshow.config.transitionDuration / 2);
            } else {
                pgwSlideshow.plugin.find('.ps-caption, .ps-prev, .ps-next').hide();
            }

            // Choose the transition effect
            if (pgwSlideshow.config.transitionEffect == 'sliding') {
                slideElement(element, direction);
            } else {
                fadeElement(element);
            }

            // Reset interval to avoid a half interval after an API control
            if (typeof apiController != 'undefined' && pgwSlideshow.config.autoSlide) {
                activateInterval();
            }

            return true;
        }
778019
function() {
		var Elm = gui.Client.isExplorer ? HTMLElement : Element;
		this._change(Elm.prototype, gui.DOMCombos);
	}
2
function() {
        var options = this.options;

        if (options.hideOthers) {
            this.secondary.each(function() {
                var sidebar = $(this);

                if (sidebar.hasClass('is-expanded')) {
                    sidebar.toolkit('offCanvas', 'hide');
                }
            });
        }

        this.fireEvent('showing');

        this.container.addClass('move-' + this.opposite);

        this.element
            .reveal()
            .addClass('is-expanded')
            .aria('expanded', true);

        if (options.stopScroll) {
            $('body').addClass('no-scroll');
        }

        this.fireEvent('shown');
    }
483614
function( element, options ) {
  options = options || {};
  $.extend( this, Shuffle.options, options, Shuffle.settings );

  this.$el = $(element);
  this.element = element;
  this.unique = 'shuffle_' + id++;

  this._fire( Shuffle.EventType.LOADING );
  this._init();

  // Dispatch the done event asynchronously so that people can bind to it after
  // Shuffle has been initialized.
  defer(function() {
    this.initialized = true;
    this._fire( Shuffle.EventType.DONE );
  }, this, 16);
}
940998
function (el, options) {
        this.$element = $(el);
        this.$collapse = this.$element.find('[data-widgster=collapse]');
        this.$expand = this.$element.find('[data-widgster=expand]');
        this.$fullscreen = this.$element.find('[data-widgster=fullscreen]');
        this.$restore = this.$element.find('[data-widgster=restore]');
        this.options = options;
        this.collapsed = options.collapsed;
        this.fullscreened = options.fullscreened;

        this._initHandlers();

        if (this.collapsed){
            this.collapse(false);
        } else {
            this.$expand.hide();
        }

        if (this.fullscreened){
            this.fullscreen();
        } else {
            this.$restore.hide();
        }

        this.options.autoload && this.load();
        var interval = parseInt(this.options.autoload);
        if (!isNaN(interval)){
            var widgster = this;
            this._autoloadInterval = setInterval(function(){
                widgster.load();
            }, interval)
        }
    }
1158595
function(elementId, apiController, direction) {

            if (elementId == pgwSlider.currentSlide) {
                return false;
            }

            var element = pgwSlider.data[elementId - 1];

            if (typeof element == 'undefined') {
                throw new Error('PgwSlider - The element ' + elementId + ' is undefined');
                return false;
            }

            if (typeof direction == 'undefined') {
                direction = 'left';
            }

            // Before slide
            if (typeof pgwSlider.config.beforeSlide == 'function') {
                pgwSlider.config.beforeSlide(elementId);
            }

            if (typeof pgwSlider.plugin.find('.ps-caption').fadeOut == 'function') {
                pgwSlider.plugin.find('.ps-caption, .ps-prev, .ps-next').fadeOut(pgwSlider.config.transitionDuration / 2);
            } else {
                pgwSlider.plugin.find('.ps-caption, .ps-prev, .ps-next').hide();
            }

            // Choose the transition effect
            if (pgwSlider.config.transitionEffect == 'sliding') {
                slideElement(element, direction);
            } else {
                fadeElement(element);
            }

            // Reset interval to avoid a half interval after an API control
            if (typeof apiController != 'undefined' && pgwSlider.config.autoSlide) {
                activateInterval();
            }

            return true;
        }
286785
function (config) {
			if (config) {
				if (config.element) {
					this.expect.element(config.element).to.not.be.visible;
				} else {
					throw new Error('adminUIApp:must specify an element!');
				}
			} else {
				throw new Error('adminUIApp:invalid config specification!');
			}
			return this;
		}
226065
protected void detectOutOfScopeElement(Element element, Functions.Func callback) {
        if (scrollHelper.isInViewPort(element)) {
            callback.call();
        } else {
            scrollHelper.setOffsetPosition(OffsetPosition.MIDDLE);
            scrollHelper.setCompleteCallback(() -> callback.call());
            scrollHelper.scrollTo(element);
        }
    }
710738
function toggleTargetState( element ) {
  if ( element.classList.contains( this.classes.targetExpanded ) ) {
    this.ui.target.classList.add( this.classes.targetCollapsed );
    this.ui.target.classList.remove( this.classes.targetExpanded );
  } else {
    this.ui.target.classList.add( this.classes.targetExpanded );
    this.ui.target.classList.remove( this.classes.targetCollapsed );
  }
}