text: /*!
   * @file Debug Extension for ScrollMagic.
   */
  /**
   * This plugin was formerly known as the ScrollMagic debug extension.
   *
   * It enables you to add visual indicators to your page, to be able to see exactly when a scene is triggered.
   *
   * To have access to this extension, please include `plugins/debug.addIndicators.js`.
   * @mixin debug.addIndicators
   */
  (function (root, factory) {
      if (typeof define === 'function' && define.amd) {
          // AMD. Register as an anonymous module.
          define(['ScrollMagic'], factory);
      } else if (typeof exports === 'object') {
      		// CommonJS
      		factory(require('scrollmagic'));
      } else {
      		// no browser global export needed, just execute
          factory(root.ScrollMagic || (root.jQuery && root.jQuery.ScrollMagic));
      }
  }(this, function(ScrollMagic) {
  	"use strict";
  	var NAMESPACE = "debug.addIndicators";
  
  	// (BUILD) - REMOVE IN MINIFY - START
  	var
  		console = window.console || {},
  		err = Function.prototype.bind.call(console.error || console.log || function() {}, console);
  	if (!ScrollMagic) {
  		err("(" + NAMESPACE + ") -> ERROR: The ScrollMagic main module could not be found. Please make sure it's loaded before this plugin or use an asynchronous loader like requirejs.");
  	}
  	// (BUILD) - REMOVE IN MINIFY - END
  
  	// plugin settings
  	var
  		FONT_SIZE = "0.85em",
  		ZINDEX = "9999",
  		EDGE_OFFSET = 15; // minimum edge distance, added to indentation
  
  	// overall vars
  	var
  		_util = ScrollMagic._util,
  		_autoindex = 0;
  
  
  
  	ScrollMagic.Scene.extend(function () {
  		var
  			Scene = this,
  			_indicator;
  
  		// (BUILD) - REMOVE IN MINIFY - START
  		var log = function () {
  			if (Scene._log) { // not available, when main source minified
  				Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
  				Scene._log.apply(this, arguments);
  			}
  		};
  		// (BUILD) - REMOVE IN MINIFY - END
  
  		/**
  		 * Add visual indicators for a ScrollMagic.Scene.  
  		 * @memberof! debug.addIndicators#
  		 *
  		 * @example
  		 * // add basic indicators
  		 * scene.addIndicators()
  		 *
  		 * // passing options
  		 * scene.addIndicators({name: "pin scene", colorEnd: "#FFFFFF"});
  		 *
  		 * @param {object} [options] - An object containing one or more options for the indicators.
  		 * @param {(string|object)} [options.parent] - A selector, DOM Object or a jQuery object that the indicators should be added to.  
  		 														 														 If undefined, the controller's container will be used.
  		 * @param {number} [options.name=""] - This string will be displayed at the start and end indicators of the scene for identification purposes. If no name is supplied an automatic index will be used.
  		 * @param {number} [options.indent=0] - Additional position offset for the indicators (useful, when having multiple scenes starting at the same position).
  		 * @param {string} [options.colorStart=green] - CSS color definition for the start indicator.
  		 * @param {string} [options.colorEnd=red] - CSS color definition for the end indicator.
  		 * @param {string} [options.colorTrigger=blue] - CSS color definition for the trigger indicator.
  		 */
  		Scene.addIndicators = function(options) {
  			if (!_indicator) {
  				var
  					DEFAULT_OPTIONS = {
  						name: "",
  						indent: 0,
  						parent: undefined,
  						colorStart: "green",
  						colorEnd: "red",
  						colorTrigger: "blue",
  					};
  				
  				options = _util.extend({}, DEFAULT_OPTIONS, options);
  
  				_autoindex++;
  				_indicator = new Indicator(Scene, options);
  
  				Scene.on("add.plugin_addIndicators", _indicator.add);
  				Scene.on("remove.plugin_addIndicators", _indicator.remove);
  				Scene.on("destroy.plugin_addIndicators", Scene.removeIndicators);
  
  				// it the scene already has a controller we can start right away.
  				if (Scene.controller()) {
  					_indicator.add();
  				}
  			}
  			return Scene;
  		};
  
  		/**
  		 * Removes visual indicators from a ScrollMagic.Scene.
  		 * @memberof! debug.addIndicators#
  		 *
  		 * @example
  		 * // remove previously added indicators
  		 * scene.removeIndicators()
  		 *
  		 */
  		Scene.removeIndicators = function() {
  			if (_indicator) {
  				_indicator.remove();
  				this.off("*.plugin_addIndicators");
  				_indicator = undefined;
  			}
  			return Scene;
  		};
  
  	});
  
  
  	/*
  	 * ----------------------------------------------------------------
  	 * Extension for controller to store and update related indicators
  	 * ----------------------------------------------------------------
  	 */
  	// add option to globally auto-add indicators to scenes
  	/**
  	 * Every ScrollMagic.Controller instance now accepts an additional option.  
  	 * See {@link ScrollMagic.Controller} for a complete list of the standard options.
  	 * @memberof! debug.addIndicators#
  	 * @method new ScrollMagic.Controller(options)
  	 * @example
  	 * // make a controller and add indicators to all scenes attached
  	 * var controller = new ScrollMagic.Controller({addIndicators: true});
  	 * // this scene will automatically have indicators added to it
  	 * new ScrollMagic.Scene()
  	 *                .addTo(controller);
  	 *
  	 * @param {object} [options] - Options for the Controller.
  	 * @param {boolean} [options.addIndicators=false] - If set to `true` every scene that is added to the controller will automatically get indicators added to it.
  	 */
  	ScrollMagic.Controller.addOption("addIndicators", false);
  	// extend Controller
  	ScrollMagic.Controller.extend(function () {
  		var
  			Controller = this,
  			_info = Controller.info(),
  			_container = _info.container,
  			_isDocument = _info.isDocument,
  			_vertical = _info.vertical,
  			_indicators = { // container for all indicators and methods
  				groups: []
  			};
  
  		// (BUILD) - REMOVE IN MINIFY - START
  		var log = function () {
  			if (Controller._log) { // not available, when main source minified
  				Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
  				Controller._log.apply(this, arguments);
  			}
  		};
  		if (Controller._indicators) {
  			log(2, "WARNING: Scene already has a property '_indicators', which will be overwritten by plugin.");
  		}
  		// (BUILD) - REMOVE IN MINIFY - END
  	
  		// add indicators container
  		this._indicators = _indicators;
  		/*
  			needed updates:
  			+++++++++++++++
  			start/end position on scene shift (handled in Indicator class)
  			trigger parameters on triggerHook value change (handled in Indicator class)
  			bounds position on container scroll or resize (to keep alignment to bottom/right)
  			trigger position on container resize, window resize (if container isn't document) and window scroll (if container isn't document)
  		*/
  		
  		// event handler for when associated bounds markers need to be repositioned
  		var handleBoundsPositionChange = function () {
  			_indicators.updateBoundsPositions();
  		};
  
  		// event handler for when associated trigger groups need to be repositioned
  		var handleTriggerPositionChange = function () {
  			_indicators.updateTriggerGroupPositions();
  		};
  
  		_container.addEventListener("resize", handleTriggerPositionChange);
  		if (!_isDocument) {
  			window.addEventListener("resize", handleTriggerPositionChange);
  			window.addEventListener("scroll", handleTriggerPositionChange);
  		}
  		// update all related bounds containers
  		_container.addEventListener("resize", handleBoundsPositionChange);
  		_container.addEventListener("scroll", handleBoundsPositionChange);
  
  
  		// updates the position of the bounds container to aligned to the right for vertical containers and to the bottom for horizontal
  		this._indicators.updateBoundsPositions = function (specificIndicator) {
  			var // constant for all bounds
  				groups = specificIndicator ?
  								[_util.extend({}, specificIndicator.triggerGroup, {members: [specificIndicator]})]: // create a group with only one element
  								_indicators.groups, // use all
  				g = groups.length,
  				css = {},
  				paramPos = _vertical ? "left"  : "top",
  				paramDimension = _vertical ? "width" : "height",
  				edge = _vertical ?
  							_util.get.scrollLeft(_container) + _util.get.width(_container) - EDGE_OFFSET:
  							_util.get.scrollTop(_container) + _util.get.height(_container) - EDGE_OFFSET,
  				b, triggerSize, group;
  			while (g--) { // group loop
  				group = groups[g];
  				b = group.members.length;
  				triggerSize = _util.get[paramDimension](group.element.firstChild);
  				while (b--) { // indicators loop
  					css[paramPos] = edge - triggerSize;
  					_util.css(group.members[b].bounds, css);
  				}
  			}
  		};
  
  		// updates the positions of all trigger groups attached to a controller or a specific one, if provided
  		this._indicators.updateTriggerGroupPositions = function (specificGroup) {
  			var // constant vars
  				groups = specificGroup ? [specificGroup] : _indicators.groups,
  				i = groups.length,
  				container = _isDocument ? document.body : _container,
  				containerOffset = _isDocument ?  {top: 0, left: 0} : _util.get.offset(container, true),
  				edge = _vertical ?
  							_util.get.width(_container) - EDGE_OFFSET :
  							_util.get.height(_container) - EDGE_OFFSET,
  				paramDimension = _vertical ? "width"  : "height",
  				paramTransform = _vertical ? "Y" : "X";
  			var // changing vars
  					group,
  					elem,
  					pos,
  					elemSize,
  					transform;
  			while (i--) {
  				group = groups[i];
  				elem = group.element;
  				pos = group.triggerHook * Controller.info("size");
  				elemSize = _util.get[paramDimension](elem.firstChild.firstChild);
  				transform = pos > elemSize ? "translate" + paramTransform + "(-100%)" : "";
  
  				_util.css(elem, {
  					top: containerOffset.top + (_vertical ? pos : edge - group.members[0].options.indent),
  					left: containerOffset.left + (_vertical ? edge - group.members[0].options.indent : pos)
  				});
  				_util.css(elem.firstChild.firstChild, {
  					"-ms-transform" : transform,
  					"-webkit-transform" : transform,
  					"transform" : transform
  				});
  			}
  		};
  
  		// updates the label for the group to contain the name, if it only has one member
  		this._indicators.updateTriggerGroupLabel = function (group) {
  			var
  				text = "trigger" + (group.members.length > 1 ? "" : " " + group.members[0].options.name),
  				elem = group.element.firstChild.firstChild,
  				doUpdate = elem.textContent !== text;
  			if (doUpdate) {
  				elem.textContent = text;
  				if (_vertical) { // bounds position is dependent on text length, so update
  					_indicators.updateBoundsPositions();
  				}
  			}
  		};
  
  		// add indicators if global option is set
  		this.addScene = function (newScene) {
  
  			if (this._options.addIndicators && newScene instanceof ScrollMagic.Scene && newScene.controller() === Controller) {
  				newScene.addIndicators();
  			}
  			// call original destroy method
  			this.$super.addScene.apply(this, arguments);
  		};
  
  		// remove all previously set listeners on destroy
  		this.destroy = function () {
  			_container.removeEventListener("resize", handleTriggerPositionChange);
  			if (!_isDocument) {
  				window.removeEventListener("resize", handleTriggerPositionChange);
  				window.removeEventListener("scroll", handleTriggerPositionChange);
  			}
  			_container.removeEventListener("resize", handleBoundsPositionChange);
  			_container.removeEventListener("scroll", handleBoundsPositionChange);
  			// call original destroy method
  			this.$super.destroy.apply(this, arguments);
  		};
  		return Controller;
  
  	});
  
  	/*
  	 * ----------------------------------------------------------------
  	 * Internal class for the construction of Indicators
  	 * ----------------------------------------------------------------
  	 */
  	var Indicator = function (Scene, options) {
  		var
  			Indicator = this,
  			_elemBounds = TPL.bounds(),
  			_elemStart = TPL.start(options.colorStart),
  			_elemEnd = TPL.end(options.colorEnd),
  			_boundsContainer = options.parent && _util.get.elements(options.parent)[0],
  			_vertical,
  			_ctrl;
  
  		// (BUILD) - REMOVE IN MINIFY - START
  		var log = function () {
  			if (Scene._log) { // not available, when main source minified
  				Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
  				Scene._log.apply(this, arguments);
  			}
  		};
  		// (BUILD) - REMOVE IN MINIFY - END
  
  		options.name = options.name || _autoindex;
  
  		// prepare bounds elements
  		_elemStart.firstChild.textContent += " " + options.name;
  		_elemEnd.textContent += " " + options.name;
  		_elemBounds.appendChild(_elemStart);
  		_elemBounds.appendChild(_elemEnd);
  
  		// set public variables
  		Indicator.options = options;
  		Indicator.bounds = _elemBounds;
  		// will be set later
  		Indicator.triggerGroup = undefined;
  
  		// add indicators to DOM
  		this.add = function () {
  			_ctrl = Scene.controller();
  			_vertical = _ctrl.info("vertical");
  
  			var isDocument = _ctrl.info("isDocument");
  
  			if (!_boundsContainer) {
  				// no parent supplied or doesnt exist
  				_boundsContainer = isDocument ? document.body : _ctrl.info("container"); // check if window/document (then use body)
  			}
  			if (!isDocument && _util.css(_boundsContainer, "position") === 'static') {
  				// position mode needed for correct positioning of indicators
  				_util.css(_boundsContainer, {position: "relative"});
  			}
  
  			// add listeners for updates
  			Scene.on("change.plugin_addIndicators", handleTriggerParamsChange);
  			Scene.on("shift.plugin_addIndicators", handleBoundsParamsChange);
  
  			// updates trigger & bounds (will add elements if needed)
  			updateTriggerGroup();
  			updateBounds();
  
  			setTimeout(function () { // do after all execution is finished otherwise sometimes size calculations are off
  				_ctrl._indicators.updateBoundsPositions(Indicator);
  			}, 0);
  
  			log(3, "added indicators");
  		};
  
  		// remove indicators from DOM
  		this.remove = function () {
  			if (Indicator.triggerGroup) { // if not set there's nothing to remove
  				Scene.off("change.plugin_addIndicators", handleTriggerParamsChange);
  				Scene.off("shift.plugin_addIndicators", handleBoundsParamsChange);
  
  				if (Indicator.triggerGroup.members.length > 1) {
  					// just remove from memberlist of old group
  					var group = Indicator.triggerGroup;
  					group.members.splice(group.members.indexOf(Indicator), 1);
  					_ctrl._indicators.updateTriggerGroupLabel(group);
  					_ctrl._indicators.updateTriggerGroupPositions(group);
  					Indicator.triggerGroup = undefined;
  	 			} else {
  	 				// remove complete group
  	 				removeTriggerGroup();
  	 			}
  				removeBounds();
  				
  				log(3, "removed indicators");
  			}
  		};
  
  		/*
  		 * ----------------------------------------------------------------
  		 * internal Event Handlers
  		 * ----------------------------------------------------------------
  		 */
  
  		// event handler for when bounds params change
  		var handleBoundsParamsChange = function () {
  			updateBounds();
  		};
  
  		// event handler for when trigger params change
  		var handleTriggerParamsChange = function (e) {
  			if (e.what === "triggerHook") {
  				updateTriggerGroup();
  			}
  		};
  
  		/*
  		 * ----------------------------------------------------------------
  		 * Bounds (start / stop) management
  		 * ----------------------------------------------------------------
  		 */
  
  		// adds an new bounds elements to the array and to the DOM
  		var addBounds = function () {
  			var v = _ctrl.info("vertical");
  			// apply stuff we didn't know before...
  			_util.css(_elemStart.firstChild, {
  				"border-bottom-width" : v ? 1 : 0,
  				"border-right-width" :	v ? 0 : 1,
  				"bottom":								v ? -1 : options.indent,
  				"right":								v ? options.indent : -1,
  				"padding":							v ? "0 8px" : "2px 4px",
  			});
  			_util.css(_elemEnd, {
  				"border-top-width" :		v ? 1 : 0,
  				"border-left-width" : 	v ? 0 : 1,
  				"top":									v ? "100%" : "",
  				"right":								v ? options.indent : "",
  				"bottom":								v ? "" : options.indent,
  				"left":									v ? "" : "100%",
  				"padding":							v ? "0 8px" : "2px 4px"
  			});
  			// append
  			_boundsContainer.appendChild(_elemBounds);
  		};
  
  		// remove bounds from list and DOM
  		var removeBounds = function () {
  			_elemBounds.parentNode.removeChild(_elemBounds);
  		};
  
  		// update the start and end positions of the scene
  		var updateBounds = function () {
  			if (_elemBounds.parentNode !== _boundsContainer) {
  				addBounds(); // Add Bounds elements (start/end)
  			}
  			var css = {};
  			css[_vertical ? "top" : "left"] = Scene.triggerPosition();
  			css[_vertical ? "height" : "width"] = Scene.duration();
  			_util.css(_elemBounds, css);
  			_util.css(_elemEnd, {
  				display: Scene.duration() > 0 ? "" : "none"
  			});
  		};
  
  		/*
  		 * ----------------------------------------------------------------
  		 * trigger and trigger group management
  		 * ----------------------------------------------------------------
  		 */
  
  		// adds an new trigger group to the array and to the DOM
  		var addTriggerGroup = function () {
  			var triggerElem = TPL.trigger(options.colorTrigger); // new trigger element
  			var css = {};
  			css[_vertical ? "right" : "bottom"] = 0;
  			css[_vertical ? "border-top-width" : "border-left-width"] = 1;
  			_util.css(triggerElem.firstChild, css);
  			_util.css(triggerElem.firstChild.firstChild, {
  				padding: _vertical ? "0 8px 3px 8px" : "3px 4px"
  			});
  			document.body.appendChild(triggerElem); // directly add to body
  			var newGroup = {
  				triggerHook: Scene.triggerHook(),
  				element: triggerElem,
  				members: [Indicator]
  			};
  			_ctrl._indicators.groups.push(newGroup);
  			Indicator.triggerGroup = newGroup;
  			// update right away
  			_ctrl._indicators.updateTriggerGroupLabel(newGroup);
  			_ctrl._indicators.updateTriggerGroupPositions(newGroup);
  		};
  
  		var removeTriggerGroup = function () {
  			_ctrl._indicators.groups.splice(_ctrl._indicators.groups.indexOf(Indicator.triggerGroup), 1);
  			Indicator.triggerGroup.element.parentNode.removeChild(Indicator.triggerGroup.element);
  			Indicator.triggerGroup = undefined;
  		};
  
  		// updates the trigger group -> either join existing or add new one
  		/*	
  		 * Logic:
  		 * 1 if a trigger group exist, check if it's in sync with Scene settings – if so, nothing else needs to happen
  		 * 2 try to find an existing one that matches Scene parameters
  		 * 	 2.1 If a match is found check if already assigned to an existing group
  		 *			 If so:
  		 *       A: it was the last member of existing group -> kill whole group
  		 *       B: the existing group has other members -> just remove from member list
  		 *	 2.2 Assign to matching group
  		 * 3 if no new match could be found, check if assigned to existing group
  		 *   A: yes, and it's the only member -> just update parameters and positions and keep using this group
  		 *   B: yes but there are other members -> remove from member list and create a new one
  		 *   C: no, so create a new one
  		 */
  		var updateTriggerGroup = function () {
  			var
  				triggerHook = Scene.triggerHook(),
  				closeEnough = 0.0001;
  
  			// Have a group, check if it still matches
  			if (Indicator.triggerGroup) {
  				if (Math.abs(Indicator.triggerGroup.triggerHook - triggerHook) < closeEnough) {
  					// _util.log(0, "trigger", options.name, "->", "no need to change, still in sync");
  					return; // all good
  				}
  			}
  			// Don't have a group, check if a matching one exists
  			// _util.log(0, "trigger", options.name, "->", "out of sync!");
  			var
  				groups = _ctrl._indicators.groups,
  				group,
  				i = groups.length;
  			while (i--) {
  				group = groups[i];
  				if (Math.abs(group.triggerHook - triggerHook) < closeEnough) {
  					// found a match!
  					// _util.log(0, "trigger", options.name, "->", "found match");
  					if (Indicator.triggerGroup) { // do I have an old group that is out of sync?
  						if (Indicator.triggerGroup.members.length === 1) { // is it the only remaining group?
  							// _util.log(0, "trigger", options.name, "->", "kill");
  							// was the last member, remove the whole group
  							removeTriggerGroup();
  						} else {
  							Indicator.triggerGroup.members.splice(Indicator.triggerGroup.members.indexOf(Indicator), 1); // just remove from memberlist of old group
  							_ctrl._indicators.updateTriggerGroupLabel(Indicator.triggerGroup);
  							_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
  							// _util.log(0, "trigger", options.name, "->", "removing from previous member list");
  						}
  					}
  					// join new group
  					group.members.push(Indicator);
  					Indicator.triggerGroup = group;
  					_ctrl._indicators.updateTriggerGroupLabel(group);
  					return;
  				}
  			}
  
  			// at this point I am obviously out of sync and don't match any other group
  			if (Indicator.triggerGroup) {
  				if (Indicator.triggerGroup.members.length === 1) {
  					// _util.log(0, "trigger", options.name, "->", "updating existing");
  					// out of sync but i'm the only member => just change and update
  					Indicator.triggerGroup.triggerHook = triggerHook;
  					_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
  					return;
  				} else {
  					// _util.log(0, "trigger", options.name, "->", "removing from previous member list");
  					Indicator.triggerGroup.members.splice(Indicator.triggerGroup.members.indexOf(Indicator), 1); // just remove from memberlist of old group
  					_ctrl._indicators.updateTriggerGroupLabel(Indicator.triggerGroup);
  					_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
  					Indicator.triggerGroup = undefined; // need a brand new group...
  				}
  			}
  			// _util.log(0, "trigger", options.name, "->", "add a new one");
  			// did not find any match, make new trigger group
  			addTriggerGroup();
  		};
  	};
  
  	/*
  	 * ----------------------------------------------------------------
  	 * Templates for the indicators
  	 * ----------------------------------------------------------------
  	 */
  	var TPL = {
  		start: function (color) {
  			// inner element (for bottom offset -1, while keeping top position 0)
  			var inner = document.createElement("div");
  			inner.textContent = "start";
  			_util.css(inner, {
  				position: "absolute",
  				overflow: "visible",
  				"border-width" : 0,
  				"border-style" : "solid",
  				color: color,
  				"border-color" : color
  			});
  			var e = document.createElement('div');
  			// wrapper
  			_util.css(e, {
  				position: "absolute",
  				overflow: "visible",
  				width: 0,
  				height: 0
  			});
  			e.appendChild(inner);
  			return e;
  		},
  		end: function (color) {
  			var e = document.createElement('div');
  			e.textContent = "end";
  			_util.css(e, {
  				position: "absolute",
  				overflow: "visible",
  				"border-width" : 0,
  				"border-style" : "solid",
  				color: color,
  				"border-color" : color
  			});
  			return e;
  		},
  		bounds: function () {
  			var e = document.createElement('div');
  			_util.css(e, {
  				position: "absolute",
  				overflow: "visible",
  				"white-space": "nowrap",
  				"pointer-events" : "none",
  				"font-size": FONT_SIZE
  			});
  			e.style.zIndex = ZINDEX;
  			return e;
  		},
  		trigger: function (color) {
  			// inner to be above or below line but keep position
  			var inner = document.createElement('div');
  			inner.textContent = "trigger";
  			_util.css(inner, {
  				position: "relative",
  			});
  			// inner wrapper for right: 0 and main element has no size
  			var w = document.createElement('div'); 
  			_util.css(w, {
  				position: "absolute",
  				overflow: "visible",
  				"border-width" : 0,
  				"border-style" : "solid",
  				color: color,
  				"border-color" : color
  			});
  			w.appendChild(inner);
  			// wrapper
  			var e = document.createElement('div');
  			_util.css(e, {
  				position: "fixed",
  				overflow: "visible",
  				"white-space": "nowrap",
  				"pointer-events" : "none",
  				"font-size": FONT_SIZE
  			});
  			e.style.zIndex = ZINDEX;
  			e.appendChild(w);
  			return e;
  		},
  	};
  
  }));
  