(function() {
	var MutationObserver, Util, WeakMap, getComputedStyle, getComputedStyleRX,
	bind    = function(fn, me){ return function(){ return fn.apply( me, arguments ); }; },
	indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) {
			if (i in this && this[i] === item) {
				return i;
			} } return -1; };

	Util = (function() {
		function Util() {}

		Util.prototype.extend = function(custom, defaults) {
			var key, value;
			for (key in defaults) {
				value = defaults[key];
				if (custom[key] == null) {
					custom[key] = value;
				}
			}
			return custom;
		};

		Util.prototype.isMobile = function(agent) {
			return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test( agent );
		};

		Util.prototype.createEvent = function(event, bubble, cancel, detail) {
			var customEvent;
			if (bubble == null) {
				bubble = false;
			}
			if (cancel == null) {
				cancel = false;
			}
			if (detail == null) {
				detail = null;
			}
			if (document.createEvent != null) {
				customEvent = document.createEvent( 'CustomEvent' );
				customEvent.initCustomEvent( event, bubble, cancel, detail );
			} else if (document.createEventObject != null) {
				customEvent           = document.createEventObject();
				customEvent.eventType = event;
			} else {
				customEvent.eventName = event;
			}
			return customEvent;
		};

		Util.prototype.emitEvent = function(elem, event) {
			if (elem.dispatchEvent != null) {
				return elem.dispatchEvent( event );
			} else if (event in( elem != null )) {
				return elem[event]();
			} else if (("on" + event) in( elem != null )) {
				return elem["on" + event]();
			}
		};

		Util.prototype.addEvent = function(elem, event, fn) {
			if (elem.addEventListener != null) {
				return elem.addEventListener( event, fn, false );
			} else if (elem.attachEvent != null) {
				return elem.attachEvent( "on" + event, fn );
			} else {
				return elem[event] = fn;
			}
		};

		Util.prototype.removeEvent = function(elem, event, fn) {
			if (elem.removeEventListener != null) {
				return elem.removeEventListener( event, fn, false );
			} else if (elem.detachEvent != null) {
				return elem.detachEvent( "on" + event, fn );
			} else {
				return delete elem[event];
			}
		};

		Util.prototype.innerHeight = function() {
			if ('innerHeight' in window) {
				return window.innerHeight;
			} else {
				return document.documentElement.clientHeight;
			}
		};

		return Util;

	})();

	WeakMap = this.WeakMap || this.MozWeakMap || (WeakMap = (function() {
		function WeakMap() {
			this.keys   = [];
			this.values = [];
		}

		WeakMap.prototype.get = function(key) {
			var i, item, j, len, ref;
			ref = this.keys;
			for (i = j = 0, len = ref.length; j < len; i = ++j) {
				item = ref[i];
				if (item === key) {
					return this.values[i];
				}
			}
		};

		WeakMap.prototype.set = function(key, value) {
			var i, item, j, len, ref;
			ref = this.keys;
			for (i = j = 0, len = ref.length; j < len; i = ++j) {
				item = ref[i];
				if (item === key) {
					this.values[i] = value;
					return;
				}
			}
			this.keys.push( key );
			return this.values.push( value );
		};

		return WeakMap;

	})());

	MutationObserver = this.MutationObserver || this.WebkitMutationObserver || this.MozMutationObserver || (MutationObserver = (function() {
		function MutationObserver() {
			if (typeof console !== "undefined" && console !== null) {
				console.warn( 'MutationObserver is not supported by your browser.' );
			}
			if (typeof console !== "undefined" && console !== null) {
				console.warn( 'WOW.js cannot detect dom mutations, please call .sync() after loading new content.' );
			}
		}

		MutationObserver.notSupported = true;

		MutationObserver.prototype.observe = function() {};

		return MutationObserver;

	})());

	getComputedStyle = this.getComputedStyle || function(el, pseudo) {
		this.getPropertyValue = function(prop) {
			var ref;
			if (prop === 'float') {
				prop = 'styleFloat';
			}
			if (getComputedStyleRX.test( prop )) {
				prop.replace(
					getComputedStyleRX,
					function(_, _char) {
						return _char.toUpperCase();
					}
				);
			}
			return ((ref = el.currentStyle) != null ? ref[prop] : void 0) || null;
		};
		return this;
	};

	getComputedStyleRX = /(\-([a-z]){1})/g;

	this.WOW = (function() {
		WOW.prototype.defaults = {
			boxClass: 'wow',
			animateClass: 'animated',
			offset: 0,
			mobile: true,
			live: true,
			callback: null
		};

		function WOW(options) {
			if (options == null) {
				options = {};
			}
			this.scrollCallback     = bind( this.scrollCallback, this );
			this.scrollHandler      = bind( this.scrollHandler, this );
			this.resetAnimation     = bind( this.resetAnimation, this );
			this.start              = bind( this.start, this );
			this.scrolled           = true;
			this.config             = this.util().extend( options, this.defaults );
			this.animationNameCache = new WeakMap();
			this.wowEvent           = this.util().createEvent( this.config.boxClass );
		}

		WOW.prototype.init = function() {
			var ref;
			this.element = window.document.documentElement;
			if ((ref = document.readyState) === "interactive" || ref === "complete") {
				this.start();
			} else {
				this.util().addEvent( document, 'DOMContentLoaded', this.start );
			}
			return this.finished = [];
		};

		WOW.prototype.start = function() {
			var box, j, len, ref;
			this.stopped = false;
			this.boxes   = (function() {
				var j, len, ref, results;
				ref     = this.element.querySelectorAll( "." + this.config.boxClass );
				results = [];
				for (j = 0, len = ref.length; j < len; j++) {
					box = ref[j];
					results.push( box );
				}
				return results;
			}).call( this );
			this.all     = (function() {
				var j, len, ref, results;
				ref     = this.boxes;
				results = [];
				for (j = 0, len = ref.length; j < len; j++) {
					box = ref[j];
					results.push( box );
				}
				return results;
			}).call( this );
			if (this.boxes.length) {
				if (this.disabled()) {
					this.resetStyle();
				} else {
					ref = this.boxes;
					for (j = 0, len = ref.length; j < len; j++) {
						box = ref[j];
						this.applyStyle( box, true );
					}
				}
			}
			if ( ! this.disabled()) {
				this.util().addEvent( window, 'scroll', this.scrollHandler );
				this.util().addEvent( window, 'resize', this.scrollHandler );
				this.interval = setInterval( this.scrollCallback, 50 );
			}
			if (this.config.live) {
				return new MutationObserver(
					(function(_this) {
						return function(records) {
							var k, len1, node, record, results;
							results = [];
							for (k = 0, len1 = records.length; k < len1; k++) {
								record = records[k];
								results.push(
									(function() {
										var l, len2, ref1, results1;
										ref1     = record.addedNodes || [];
										results1 = [];
										for (l = 0, len2 = ref1.length; l < len2; l++) {
											node = ref1[l];
											results1.push( this.doSync( node ) );
										}
										return results1;
									}).call( _this )
								);
							}
							return results;
						};
					})( this )
				).observe(
					document.body,
					{
						childList: true,
						subtree: true
					}
				);
			}
		};

		WOW.prototype.stop = function() {
			this.stopped = true;
			this.util().removeEvent( window, 'scroll', this.scrollHandler );
			this.util().removeEvent( window, 'resize', this.scrollHandler );
			if (this.interval != null) {
				return clearInterval( this.interval );
			}
		};

		WOW.prototype.sync = function(element) {
			if (MutationObserver.notSupported) {
				return this.doSync( this.element );
			}
		};

		WOW.prototype.doSync = function(element) {
			var box, j, len, ref, results;
			if (element == null) {
				element = this.element;
			}
			if (element.nodeType !== 1) {
				return;
			}
			element = element.parentNode || element;
			ref     = element.querySelectorAll( "." + this.config.boxClass );
			results = [];
			for (j = 0, len = ref.length; j < len; j++) {
				box = ref[j];
				if (indexOf.call( this.all, box ) < 0) {
					this.boxes.push( box );
					this.all.push( box );
					if (this.stopped || this.disabled()) {
						this.resetStyle();
					} else {
						this.applyStyle( box, true );
					}
					results.push( this.scrolled = true );
				} else {
					results.push( void 0 );
				}
			}
			return results;
		};

		WOW.prototype.show = function(box) {
			this.applyStyle( box );
			box.className = box.className + " " + this.config.animateClass;
			if (this.config.callback != null) {
				this.config.callback( box );
			}
			this.util().emitEvent( box, this.wowEvent );
			this.util().addEvent( box, 'animationend', this.resetAnimation );
			this.util().addEvent( box, 'oanimationend', this.resetAnimation );
			this.util().addEvent( box, 'webkitAnimationEnd', this.resetAnimation );
			this.util().addEvent( box, 'MSAnimationEnd', this.resetAnimation );
			return box;
		};

		WOW.prototype.applyStyle = function(box, hidden) {
			var delay, duration, iteration;
			duration  = box.getAttribute( 'data-wow-duration' );
			delay     = box.getAttribute( 'data-wow-delay' );
			iteration = box.getAttribute( 'data-wow-iteration' );
			return this.animate(
				(function(_this) {
					return function() {
						return _this.customStyle( box, hidden, duration, delay, iteration );
					};
				})( this )
			);
		};

		WOW.prototype.animate = (function() {
			if ('requestAnimationFrame' in window) {
				return function(callback) {
					return window.requestAnimationFrame( callback );
				};
			} else {
				return function(callback) {
					return callback();
				};
			}
		})();

		WOW.prototype.resetStyle = function() {
			var box, j, len, ref, results;
			ref     = this.boxes;
			results = [];
			for (j = 0, len = ref.length; j < len; j++) {
				box = ref[j];
				results.push( box.style.visibility = 'visible' );
			}
			return results;
		};

		WOW.prototype.resetAnimation = function(event) {
			var target;
			if (event.type.toLowerCase().indexOf( 'animationend' ) >= 0) {
				target                  = event.target || event.srcElement;
				return target.className = target.className.replace( this.config.animateClass, '' ).trim();
			}
		};

		WOW.prototype.customStyle = function(box, hidden, duration, delay, iteration) {
			if (hidden) {
				this.cacheAnimationName( box );
			}
			box.style.visibility = hidden ? 'hidden' : 'visible';
			if (duration) {
				this.vendorSet(
					box.style,
					{
						animationDuration: duration
					}
				);
			}
			if (delay) {
				this.vendorSet(
					box.style,
					{
						animationDelay: delay
					}
				);
			}
			if (iteration) {
				this.vendorSet(
					box.style,
					{
						animationIterationCount: iteration
					}
				);
			}
			this.vendorSet(
				box.style,
				{
					animationName: hidden ? 'none' : this.cachedAnimationName( box )
				}
			);
			return box;
		};

		WOW.prototype.vendors = ["moz", "webkit"];

		WOW.prototype.vendorSet = function(elem, properties) {
			var name, results, value, vendor;
			results = [];
			for (name in properties) {
				value           = properties[name];
				elem["" + name] = value;
				results.push(
					(function() {
						var j, len, ref, results1;
						ref      = this.vendors;
						results1 = [];
						for (j = 0, len = ref.length; j < len; j++) {
							vendor = ref[j];
							results1.push( elem["" + vendor + (name.charAt( 0 ).toUpperCase()) + (name.substr( 1 ))] = value );
						}
						return results1;
					}).call( this )
				);
			}
			return results;
		};

		WOW.prototype.vendorCSS = function(elem, property) {
			var j, len, ref, result, style, vendor;
			style  = getComputedStyle( elem );
			result = style.getPropertyCSSValue( property );
			ref    = this.vendors;
			for (j = 0, len = ref.length; j < len; j++) {
				vendor = ref[j];
				result = result || style.getPropertyCSSValue( "-" + vendor + "-" + property );
			}
			return result;
		};

		WOW.prototype.animationName = function(box) {
			var animationName;
			try {
				animationName = this.vendorCSS( box, 'animation-name' ).cssText;
			} catch (_error) {
				animationName = getComputedStyle( box ).getPropertyValue( 'animation-name' );
			}
			if (animationName === 'none') {
				return '';
			} else {
				return animationName;
			}
		};

		WOW.prototype.cacheAnimationName = function(box) {
			return this.animationNameCache.set( box, this.animationName( box ) );
		};

		WOW.prototype.cachedAnimationName = function(box) {
			return this.animationNameCache.get( box );
		};

		WOW.prototype.scrollHandler = function() {
			return this.scrolled = true;
		};

		WOW.prototype.scrollCallback = function() {
			var box;
			if (this.scrolled) {
				this.scrolled = false;
				this.boxes    = (function() {
					var j, len, ref, results;
					ref     = this.boxes;
					results = [];
					for (j = 0, len = ref.length; j < len; j++) {
						box = ref[j];
						if ( ! (box)) {
							continue;
						}
						if (this.isVisible( box )) {
							this.show( box );
							continue;
						}
						results.push( box );
					}
					return results;
				}).call( this );
				if ( ! (this.boxes.length || this.config.live)) {
						return this.stop();
				}
			}
		};

		WOW.prototype.offsetTop = function(element) {
			var top;
			while (element.offsetTop === void 0) {
				element = element.parentNode;
			}
			top = element.offsetTop;
			while (element = element.offsetParent) {
				top += element.offsetTop;
			}
			return top;
		};

		WOW.prototype.isVisible = function(box) {
			var bottom, offset, top, viewBottom, viewTop;
			offset     = box.getAttribute( 'data-wow-offset' ) || this.config.offset;
			viewTop    = window.pageYOffset;
			viewBottom = viewTop + Math.min( this.element.clientHeight, this.util().innerHeight() ) - offset;
			top        = this.offsetTop( box );
			bottom     = top + box.clientHeight;
			return top <= viewBottom && bottom >= viewTop;
		};

		WOW.prototype.util = function() {
			return this._util != null ? this._util : this._util = new Util();
		};

		WOW.prototype.disabled = function() {
			return ! this.config.mobile && this.util().isMobile( navigator.userAgent );
		};

		return WOW;

	})();

}).call( this );