(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);