Template:SBS SH 112144/js/wow.js

(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,
     scrollContainer: 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);
     if (options.scrollContainer != null) {
       this.config.scrollContainer = document.querySelector(options.scrollContainer);
     }
     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(this.config.scrollContainer || 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(this.config.scrollContainer || 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, error;
     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 = (this.config.scrollContainer && this.config.scrollContainer.scrollTop) || 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);