https://alexandraumlas.com/_static/??-eJydktFOBDEIRX/IDmPcZOOD8VNM…/z5WYJvpSvyd9stcf2W5/x0f3yc5+P8cDisn1YG+BM=

1settings.body_class.split(" ").forEach(function(e){e&&document.body.classList.add(e)}),stats=infiniteScroll.settings.stats,type=infiniteScroll.settings.type,text=infiniteScroll.settings.text,totop=infiniteScroll.settings.totop,loading_text=infiniteScroll.settings.loading_text,infiniteScroll.scroller=new Scroller(infiniteScroll.settings),"click"===type)){var e=null;window.addEventListener("scroll",function(){e||(e=setTimeout(function(){infiniteScroll.scroller.determineURL(),e=null},250))})}};"interactive"===document.readyState||"complete"===document.readyState?jetpackInfinityModule():document.addEventListener("DOMContentLoaded",jetpackInfinityModule)})()})();;
2/*
3 * jQuery FlexSlider v2.6.1
4 * Copyright 2012 WooThemes
5 * Contributing Author: Tyler Smith
6 */
7;
8(function ($) {
9
10  var focused = true;
11
12  //FlexSlider: Object Instance
13  $.flexslider = function(el, options) {
14    var slider = $(el);
15
16    // making variables public
17    slider.vars = $.extend({}, $.flexslider.defaults, options);
18
19    var namespace = slider.vars.namespace,
20        msGesture = window.navigator && window.navigator.msPointerEnabled && window.MSGesture,
21        touch = (( "ontouchstart" in window ) || msGesture || window.DocumentTouch && document instanceof DocumentTouch) && slider.vars.touch,
22        // depricating this idea, as devices are being released with both of these events
23        eventType = "click touchend MSPointerUp keyup",
24        watchedEvent = "",
25        watchedEventClearTimer,
26        vertical = slider.vars.direction === "vertical",
27        reverse = slider.vars.reverse,
28        carousel = (slider.vars.itemWidth > 0),
29        fade = slider.vars.animation === "fade",
30        asNav = slider.vars.asNavFor !== "",
31        methods = {};
32
33    // Store a reference to the slider object
34    $.data(el, "flexslider", slider);
35
36    // Private slider methods
37    methods = {
38      init: function() {
39        slider.animating = false;
40        // Get current slide and make sure it is a number
41        slider.currentSlide = parseInt( ( slider.vars.startAt ? slider.vars.startAt : 0), 10 );
42        if ( isNaN( slider.currentSlide ) ) { slider.currentSlide = 0; }
43        slider.animatingTo = slider.currentSlide;
44        slider.atEnd = (slider.currentSlide === 0 || slider.currentSlide === slider.last);
45        slider.containerSelector = slider.vars.selector.substr(0,slider.vars.selector.search(' '));
46        slider.slides = $(slider.vars.selector, slider);
47        slider.container = $(slider.containerSelector, slider);
48        slider.count = slider.slides.length;
49        // SYNC:
50        slider.syncExists = $(slider.vars.sync).length > 0;
51        // SLIDE:
52        if (slider.vars.animation === "slide") { slider.vars.animation = "swing"; }
53        slider.prop = (vertical) ? "top" : "marginLeft";
54        slider.args = {};
55        // SLIDESHOW:
56        slider.manualPause = false;
57        slider.stopped = false;
58        //PAUSE WHEN INVISIBLE
59        slider.started = false;
60        slider.startTimeout = null;
61        // TOUCH/USECSS:
62        slider.transitions = !slider.vars.video && !fade && slider.vars.useCSS && (function() {
63          var obj = document.createElement('div'),
64              props = ['perspectiveProperty', 'WebkitPerspective', 'MozPerspective', 'OPerspective', 'msPerspective'];
65          for (var i in props) {
66            if ( obj.style[ props[i] ] !== undefined ) {
67              slider.pfx = props[i].replace('Perspective','').toLowerCase();
68              slider.prop = "-" + slider.pfx + "-transform";
69              return true;
70            }
71          }
72          return false;
73        }());
74        slider.ensureAnimationEnd = '';
75        // CONTROLSCONTAINER:
76        if (slider.vars.controlsContainer !== "") slider.controlsContainer = $(slider.vars.controlsContainer).length > 0 && $(slider.vars.controlsContainer);
77        // MANUAL:
78        if (slider.vars.manualControls !== "") slider.manualControls = $(slider.vars.manualControls).length > 0 && $(slider.vars.manualControls);
79
80        // CUSTOM DIRECTION NAV:
81        if (slider.vars.customDirectionNav !== "") slider.customDirectionNav = $(slider.vars.customDirectionNav).length === 2 && $(slider.vars.customDirectionNav);
82
83        // RANDOMIZE:
84        if (slider.vars.randomize) {
85          slider.slides.sort(function() { return (Math.round(Math.random())-0.5); });
86          slider.container.empty().append(slider.slides);
87        }
88
89        slider.doMath();
90
91        // INIT
92        slider.setup("init");
93
94        // CONTROLNAV:
95        if (slider.vars.controlNav) { methods.controlNav.setup(); }
96
97        // DIRECTIONNAV:
98        if (slider.vars.directionNav) { methods.directionNav.setup(); }
99
100        // KEYBOARD:
101        if (slider.vars.keyboard && ($(slider.containerSelector).length === 1 || slider.vars.multipleKeyboard)) {
102          $(document).bind('keyup', function(event) {
103            var keycode = event.keyCode;
104            if (!slider.animating && (keycode === 39 || keycode === 37)) {
105              var target = (keycode === 39) ? slider.getTarget('next') :
106                           (keycode === 37) ? slider.getTarget('prev') : false;
107              slider.flexAnimate(target, slider.vars.pauseOnAction);
108            }
109          });
110        }
111        // MOUSEWHEEL:
112        if (slider.vars.mousewheel) {
113          slider.bind('mousewheel', function(event, delta, deltaX, deltaY) {
114            event.preventDefault();
115            var target = (delta < 0) ? slider.getTarget('next') : slider.getTarget('prev');
116            slider.flexAnimate(target, slider.vars.pauseOnAction);
117          });
118        }
119
120        // PAUSEPLAY
121        if (slider.vars.pausePlay) { methods.pausePlay.setup(); }
122
123        //PAUSE WHEN INVISIBLE
124        if (slider.vars.slideshow && slider.vars.pauseInvisible) { methods.pauseInvisible.init(); }
125
126        // SLIDSESHOW
127        if (slider.vars.slideshow) {
128          if (slider.vars.pauseOnHover) {
129            slider.hover(function() {
130              if (!slider.manualPlay && !slider.manualPause) { slider.pause(); }
131            }, function() {
132              if (!slider.manualPause && !slider.manualPlay && !slider.stopped) { slider.play(); }
133            });
134          }
135          // initialize animation
136          //If we're visible, or we don't use PageVisibility API
137          if(!slider.vars.pauseInvisible || !methods.pauseInvisible.isHidden()) {
138            (slider.vars.initDelay > 0) ? slider.startTimeout = setTimeout(slider.play, slider.vars.initDelay) : slider.play();
139          }
140        }
141
142        // ASNAV:
143        if (asNav) { methods.asNav.setup(); }
144
145        // TOUCH
146        if (touch && slider.vars.touch) { methods.touch(); }
147
148        // FADE&&SMOOTHHEIGHT || SLIDE:
149        if (!fade || (fade && slider.vars.smoothHeight)) { $(window).bind("resize orientationchange focus", methods.resize); }
150
151        slider.find("img").attr("draggable", "false");
152
153        // API: start() Callback
154        setTimeout(function(){
155          slider.vars.start(slider);
156        }, 200);
157      },
158      asNav: {
159        setup: function() {
160          slider.asNav = true;
161          slider.animatingTo = Math.floor(slider.currentSlide/slider.move);
162          slider.currentItem = slider.currentSlide;
163          slider.slides.removeClass(namespace + "active-slide").eq(slider.currentItem).addClass(namespace + "active-slide");
164          if(!msGesture){
165              slider.slides.on(eventType, function(e){
166                e.preventDefault();
167                var $slide = $(this),
168                    target = $slide.index();
169                var posFromLeft = $slide.offset().left - $(slider).scrollLeft(); // Find position of slide relative to left of slider container
170                if( posFromLeft <= 0 && $slide.hasClass( namespace + 'active-slide' ) ) {
171                  slider.flexAnimate(slider.getTarget("prev"), true);
172                } else if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass(namespace + "active-slide")) {
173                  slider.direction = (slider.currentItem < target) ? "next" : "prev";
174                  slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
175                }
176              });
177          }else{
178              el._slider = slider;
179              slider.slides.each(function (){
180                  var that = this;
181                  that._gesture = new MSGesture();
182                  that._gesture.target = that;
183                  that.addEventListener("MSPointerDown", function (e){
184                      e.preventDefault();
185                      if(e.currentTarget._gesture) {
186                        e.currentTarget._gesture.addPointer(e.pointerId);
187                      }
188                  }, false);
189                  that.addEventListener("MSGestureTap", function (e){
190                      e.preventDefault();
191                      var $slide = $(this),
192                          target = $slide.index();
193                      if (!$(slider.vars.asNavFor).data('flexslider').animating && !$slide.hasClass('active')) {
194                          slider.direction = (slider.currentItem < target) ? "next" : "prev";
195                          slider.flexAnimate(target, slider.vars.pauseOnAction, false, true, true);
196                      }
197                  });
198              });
199          }
200        }
201      },
202      controlNav: {
203        setup: function() {
204          if (!slider.manualControls) {
205            methods.controlNav.setupPaging();
206          } else { // MANUALCONTROLS:
207            methods.controlNav.setupManual();
208          }
209        },
210        setupPaging: function() {
211          var type = (slider.vars.controlNav === "thumbnails") ? 'control-thumbs' : 'control-paging',
212              j = 1,
213              item,
214              slide;
215
216          slider.controlNavScaffold = $('<ol class="'+ namespace + 'control-nav ' + namespace + type + '"></ol>');
217
218          if (slider.pagingCount > 1) {
219            for (var i = 0; i < slider.pagingCount; i++) {
220              slide = slider.slides.eq(i);
221
222              if ( undefined === slide.attr( 'data-thumb-alt' ) ) { 
223                slide.attr( 'data-thumb-alt', '' ); 
224              }
225              
226              item = $( '<a></a>' ).attr( 'href', '#' ).text( j );
227              if ( slider.vars.controlNav === "thumbnails" ) {
228                item = $( '<img/>' ).attr( 'src', slide.attr( 'data-thumb' ) );
229              }
230              
231              if ( '' !== slide.attr( 'data-thumb-alt' ) ) {
232                item.attr( 'alt', slide.attr( 'data-thumb-alt' ) );
233              }
234
235              if ( 'thumbnails' === slider.vars.controlNav && true === slider.vars.thumbCaptions ) {
236                var captn = slide.attr( 'data-thumbcaption' );
237                if ( '' !== captn && undefined !== captn ) { 
238                  var caption = $('<span></span>' ).addClass( namespace + 'caption' ).text( captn );
239                  item.append( caption );
240                }
241              }
242              
243              var liElement = $( '<li>' );
244              item.appendTo( liElement );
245              liElement.append( '</li>' );
246
247              slider.controlNavScaffold.append(liElement);
248              j++;
249            }
250          }
251
252          // CONTROLSCONTAINER:
253          (slider.controlsContainer) ? $(slider.controlsContainer).append(slider.controlNavScaffold) : slider.append(slider.controlNavScaffold);
254          methods.controlNav.set();
255
256          methods.controlNav.active();
257
258          slider.controlNavScaffold.delegate('a, img', eventType, function(event) {
259            event.preventDefault();
260
261            if (watchedEvent === "" || watchedEvent === event.type) {
262              var $this = $(this),
263                  target = slider.controlNav.index($this);
264
265              if (!$this.hasClass(namespace + 'active')) {
266                slider.direction = (target > slider.currentSlide) ? "next" : "prev";
267                slider.flexAnimate(target, slider.vars.pauseOnAction);
268              }
269            }
270
271            // setup flags to prevent event duplication
272            if (watchedEvent === "") {
273              watchedEvent = event.type;
274            }
275            methods.setToClearWatchedEvent();
276
277          });
278        },
279        setupManual: function() {
280          slider.controlNav = slider.manualControls;
281          methods.controlNav.active();
282
283          slider.controlNav.bind(eventType, function(event) {
284            event.preventDefault();
285
286            if (watchedEvent === "" || watchedEvent === event.type) {
287              var $this = $(this),
288                  target = slider.controlNav.index($this);
289
290              if (!$this.hasClass(namespace + 'active')) {
291                (target > slider.currentSlide) ? slider.direction = "next" : slider.direction = "prev";
292                slider.flexAnimate(target, slider.vars.pauseOnAction);
293              }
294            }
295
296            // setup flags to prevent event duplication
297            if (watchedEvent === "") {
298              watchedEvent = event.type;
299            }
300            methods.setToClearWatchedEvent();
301          });
302        },
303        set: function() {
304          var selector = (slider.vars.controlNav === "thumbnails") ? 'img' : 'a';
305          slider.controlNav = $('.' + namespace + 'control-nav li ' + selector, (slider.controlsContainer) ? slider.controlsContainer : slider);
306        },
307        active: function() {
308          slider.controlNav.removeClass(namespace + "active").eq(slider.animatingTo).addClass(namespace + "active");
309        },
310        update: function(action, pos) {
311          if (slider.pagingCount > 1 && action === "add") {
312            slider.controlNavScaffold.append($('<li><a href="#">' + slider.count + '</a></li>'));
313          } else if (slider.pagingCount === 1) {
314            slider.controlNavScaffold.find('li').remove();
315          } else {
316            slider.controlNav.eq(pos).closest('li').remove();
317          }
318          methods.controlNav.set();
319          (slider.pagingCount > 1 && slider.pagingCount !== slider.controlNav.length) ? slider.update(pos, action) : methods.controlNav.active();
320        }
321      },
322      directionNav: {
323        setup: function() {
324          var directionNavScaffold = $('<ul class="' + namespace + 'direction-nav"><li class="' + namespace + 'nav-prev"><a class="' + namespace + 'prev" href="#">' + slider.vars.prevText + '</a></li><li class="' + namespace + 'nav-next"><a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a></li></ul>');
325
326          // CUSTOM DIRECTION NAV:
327          if (slider.customDirectionNav) {
328            slider.directionNav = slider.customDirectionNav;
329          // CONTROLSCONTAINER:
330          } else if (slider.controlsContainer) {
331            $(slider.controlsContainer).append(directionNavScaffold);
332            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
333          } else {
334            slider.append(directionNavScaffold);
335            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
336          }
337
338          methods.directionNav.update();
339
340          slider.directionNav.bind(eventType, function(event) {
341            event.preventDefault();
342            var target;
343
344            if (watchedEvent === "" || watchedEvent === event.type) {
345              target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
346              slider.flexAnimate(target, slider.vars.pauseOnAction);
347            }
348
349            // setup flags to prevent event duplication
350            if (watchedEvent === "") {
351              watchedEvent = event.type;
352            }
353            methods.setToClearWatchedEvent();
354          });
355        },
356        update: function() {
357          var disabledClass = namespace + 'disabled';
358          if (slider.pagingCount === 1) {
359            slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
360          } else if (!slider.vars.animationLoop) {
361            if (slider.animatingTo === 0) {
362              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
363            } else if (slider.animatingTo === slider.last) {
364              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
365            } else {
366              slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
367            }
368          } else {
369            slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
370          }
371        }
372      },
373      pausePlay: {
374        setup: function() {
375          var pausePlayScaffold = $('<div class="' + namespace + 'pauseplay"><a href="#"></a></div>');
376
377          // CONTROLSCONTAINER:
378          if (slider.controlsContainer) {
379            slider.controlsContainer.append(pausePlayScaffold);
380            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
381          } else {
382            slider.append(pausePlayScaffold);
383            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
384          }
385
386          methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
387
388          slider.pausePlay.bind(eventType, function(event) {
389            event.preventDefault();
390
391            if (watchedEvent === "" || watchedEvent === event.type) {
392              if ($(this).hasClass(namespace + 'pause')) {
393                slider.manualPause = true;
394                slider.manualPlay = false;
395                slider.pause();
396              } else {
397                slider.manualPause = false;
398                slider.manualPlay = true;
399                slider.play();
400              }
401            }
402
403            // setup flags to prevent event duplication
404            if (watchedEvent === "") {
405              watchedEvent = event.type;
406            }
407            methods.setToClearWatchedEvent();
408          });
409        },
410        update: function(state) {
411          (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
412        }
413      },
414      touch: function() {
415        var startX,
416          startY,
417          offset,
418          cwidth,
419          dx,
420          startT,
421          onTouchStart,
422          onTouchMove,
423          onTouchEnd,
424          scrolling = false,
425          localX = 0,
426          localY = 0,
427          accDx = 0;
428
429        if(!msGesture){
430            onTouchStart = function(e) {
431              if (slider.animating) {
432                e.preventDefault();
433              } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
434                slider.pause();
435                // CAROUSEL:
436                cwidth = (vertical) ? slider.h : slider. w;
437                startT = Number(new Date());
438                // CAROUSEL:
439
440                // Local vars for X and Y points.
441                localX = e.touches[0].pageX;
442                localY = e.touches[0].pageY;
443
444                offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
445                         (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
446                         (carousel && slider.currentSlide === slider.last) ? slider.limit :
447                         (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
448                         (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
449                startX = (vertical) ? localY : localX;
450                startY = (vertical) ? localX : localY;
451
452                el.addEventListener('touchmove', onTouchMove, false);
453                el.addEventListener('touchend', onTouchEnd, false);
454              }
455            };
456
457            onTouchMove = function(e) {
458              // Local vars for X and Y points.
459
460              localX = e.touches[0].pageX;
461              localY = e.touches[0].pageY;
462
463              dx = (vertical) ? startX - localY : startX - localX;
464              scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
465
466              var fxms = 500;
467
468              if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
469                e.preventDefault();
470                if (!fade && slider.transitions) {
471                  if (!slider.vars.animationLoop) {
472                    dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
473                  }
474                  slider.setProps(offset + dx, "setTouch");
475                }
476              }
477            };
478
479            onTouchEnd = function(e) {
480              // finish the touch by undoing the touch session
481              el.removeEventListener('touchmove', onTouchMove, false);
482
483              if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
484                var updateDx = (reverse) ? -dx : dx,
485                    target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
486
487                if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
488                  slider.flexAnimate(target, slider.vars.pauseOnAction);
489                } else {
490                  if (!fade) { slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true); }
491                }
492              }
493              el.removeEventListener('touchend', onTouchEnd, false);
494
495              startX = null;
496              startY = null;
497              dx = null;
498              offset = null;
499            };
500
501            el.addEventListener('touchstart', onTouchStart, false);
502        }else{
503            el.style.msTouchAction = "none";
504            el._gesture = new MSGesture();
505            el._gesture.target = el;
506            el.addEventListener("MSPointerDown", onMSPointerDown, false);
507            el._slider = slider;
508            el.addEventListener("MSGestureChange", onMSGestureChange, false);
509            el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
510
511            function onMSPointerDown(e){
512                e.stopPropagation();
513                if (slider.animating) {
514                    e.preventDefault();
515                }else{
516                    slider.pause();
517                    el._gesture.addPointer(e.pointerId);
518                    accDx = 0;
519                    cwidth = (vertical) ? slider.h : slider. w;
520                    startT = Number(new Date());
521                    // CAROUSEL:
522
523                    offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
524                        (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
525                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
526                                (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
527                                    (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
528                }
529            }
530
531            function onMSGestureChange(e) {
532                e.stopPropagation();
533                var slider = e.target._slider;

542accDx;
543                scrolling = (vertical) ? (Math.abs(accDx) < Math.abs(-transX)) : (Math.abs(accDx) < Math.abs(-transY));
544
545                if(e.detail === e.MSGESTURE_FLAG_INERTIA){
546                    setImmediate(function (){
547                        el._gesture.stop();
548                    });
549
550                    return;
551                }
552
553                if (!scrolling || Number(new Date()) - startT > 500) {
554                    e.preventDefault();
555                    if (!fade && slider.transitions) {
556                        if (!slider.vars.animationLoop) {
557                            dx = accDx / ((slider.currentSlide === 0 && accDx < 0 || slider.currentSlide === slider.last && accDx > 0) ? (Math.abs(accDx) / cwidth + 2) : 1);
558                        }
559                        slider.setProps(offset + dx, "setTouch");
560                    }
561                }
562            }
563
564            function onMSGestureEnd(e) {
565                e.stopPropagation();
566                var slider = e.target._slider;
567                if(!slider){
568                    return;
569                }
570                if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
571                    var updateDx = (reverse) ? -dx : dx,
572                        target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
573
574                    if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
575                        slider.flexAnimate(target, slider.vars.pauseOnAction);
576                    } else {
577                        if (!fade) { slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true); }
578                    }
579                }
580
581                startX = null;
582                startY = null;
583                dx = null;
584                offset = null;
585                accDx = 0;
586            }
587        }
588      },
589      resize: function() {
590        if (!slider.animating && slider.is(':visible')) {
591          if (!carousel) { slider.doMath(); }
592
593          if (fade) {
594            // SMOOTH HEIGHT:
595            methods.smoothHeight();
596          } else if (carousel) { //CAROUSEL:
597            slider.slides.width(slider.computedW);
598            slider.update(slider.pagingCount);
599            slider.setProps();
600          }
601          else if (vertical) { //VERTICAL:
602            slider.viewport.height(slider.h);
603            slider.setProps(slider.h, "setTotal");
604          } else {
605            // SMOOTH HEIGHT:
606            if (slider.vars.smoothHeight) { methods.smoothHeight(); }
607            slider.newSlides.width(slider.computedW);
608            slider.setProps(slider.computedW, "setTotal");
609          }
610        }
611      },
612      smoothHeight: function(dur) {
613        if (!vertical || fade) {
614          var $obj = (fade) ? slider : slider.viewport;
615          (dur) ? $obj.animate({"height": slider.slides.eq(slider.animatingTo).innerHeight()}, dur) : $obj.innerHeight(slider.slides.eq(slider.animatingTo).innerHeight());
616        }
617      },
618      sync: function(action) {
619        var $obj = $(slider.vars.sync).data("flexslider"),
620            target = slider.animatingTo;
621
622        switch (action) {
623          case "animate": $obj.flexAnimate(target, slider.vars.pauseOnAction, false, true); break;
624          case "play": if (!$obj.playing && !$obj.asNav) { $obj.play(); } break;
625          case "pause": $obj.pause(); break;
626        }
627      },
628      uniqueID: function($clone) {
629        // Append _clone to current level and children elements with id attributes
630        $clone.filter( '[id]' ).add($clone.find( '[id]' )).each(function() {
631          var $this = $(this);
632          $this.attr( 'id', $this.attr( 'id' ) + '_clone' );
633        });
634        return $clone;
635      },
636      pauseInvisible: {
637        visProp: null,
638        init: function() {
639          var visProp = methods.pauseInvisible.getHiddenProp();
640          if (visProp) {
641            var evtname = visProp.replace(/[H|h]idden/,'') + 'visibilitychange';
642            document.addEventListener(evtname, function() {
643              if (methods.pauseInvisible.isHidden()) {
644                if(slider.startTimeout) {
645                  clearTimeout(slider.startTimeout); //If clock is ticking, stop timer and prevent from starting while invisible
646                } else {
647                  slider.pause(); //Or just pause
648                }
649              }
650              else {
651                if(slider.started) {
652                  slider.play(); //Initiated before, just play
653                } else {
654                  if (slider.vars.initDelay > 0) {
655                    setTimeout(slider.play, slider.vars.initDelay);
656                  } else {
657                    slider.play(); //Didn't init before: simply init or wait for it
658                  }
659                }
660              }
661            });
662          }
663        },
664        isHidden: function() {
665          var prop = methods.pauseInvisible.getHiddenProp();
666          if (!prop) {
667            return false;
668          }
669          return document[prop];
670        },
671        getHiddenProp: function() {
672          var prefixes = ['webkit','moz','ms','o'];
673          // if 'hidden' is natively supported just return it
674          if ('hidden' in document) {
675            return 'hidden';
676          }
677          // otherwise loop over all the known prefixes until we find one
678          for ( var i = 0; i < prefixes.length; i++ ) {
679              if ((prefixes[i] + 'Hidden') in document) {
680                return prefixes[i] + 'Hidden';
681              }
682          }
683          // otherwise it's not supported
684          return null;
685        }
686      },
687      setToClearWatchedEvent: function() {
688        clearTimeout(watchedEventClearTimer);
689        watchedEventClearTimer = setTimeout(function() {
690          watchedEvent = "";
691        }, 3000);
692      }
693    };
694
695    // public methods
696    slider.flexAnimate = function(target, pause, override, withSync, fromNav) {
697      if (!slider.vars.animationLoop && target !== slider.currentSlide) {
698        slider.direction = (target > slider.currentSlide) ? "next" : "prev";
699      }
700
701      if (asNav && slider.pagingCount === 1) slider.direction = (slider.currentItem < target) ? "next" : "prev";
702
703      if (!slider.animating && (slider.canAdvance(target, fromNav) || override) && slider.is(":visible")) {
704        if (asNav && withSync) {
705          var master = $(slider.vars.asNavFor).data('flexslider');
706          slider.atEnd = target === 0 || target === slider.count - 1;
707          master.flexAnimate(target, true, false, true, fromNav);
708          slider.direction = (slider.currentItem < target) ? "next" : "prev";
709          master.direction = slider.direction;
710
711          if (Math.ceil((target + 1)/slider.visible) - 1 !== slider.currentSlide && target !== 0) {
712            slider.currentItem = target;
713            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
714            target = Math.floor(target/slider.visible);
715          } else {
716            slider.currentItem = target;
717            slider.slides.removeClass(namespace + "active-slide").eq(target).addClass(namespace + "active-slide");
718            return false;
719          }
720        }
721
722        slider.animating = true;
723        slider.animatingTo = target;
724
725        // SLIDESHOW:
726        if (pause) { slider.pause(); }
727
728        // API: before() animation Callback
729        slider.vars.before(slider);
730
731        // SYNC:
732        if (slider.syncExists && !fromNav) { methods.sync("animate"); }
733
734        // CONTROLNAV
735        if (slider.vars.controlNav) { methods.controlNav.active(); }
736
737        // !CAROUSEL:
738        // CANDIDATE: slide active class (for add/remove slide)
739        if (!carousel) { slider.slides.removeClass(namespace + 'active-slide').eq(target).addClass(namespace + 'active-slide'); }
740
741        // INFINITE LOOP:
742        // CANDIDATE: atEnd
743        slider.atEnd = target === 0 || target === slider.last;
744
745        // DIRECTIONNAV:
746        if (slider.vars.directionNav) { methods.directionNav.update(); }
747
748        if (target === slider.last) {
749          // API: end() of cycle Callback
750          slider.vars.end(slider);
751          // SLIDESHOW && !INFINITE LOOP:
752          if (!slider.vars.animationLoop) { slider.pause(); }
753        }
754
755        // SLIDE:
756        if (!fade) {
757          var dimension = (vertical) ? slider.slides.filter(':first').height() : slider.computedW,
758              margin, slideString, calcNext;
759
760          // INFINITE LOOP / REVERSE:
761          if (carousel) {
762            margin = slider.vars.itemMargin;
763            calcNext = ((slider.itemW + margin) * slider.move) * slider.animatingTo;
764            slideString = (calcNext > slider.limit && slider.visible !== 1) ? slider.limit : calcNext;
765          } else if (slider.currentSlide === 0 && target === slider.count - 1 && slider.vars.animationLoop && slider.direction !== "next") {
766            slideString = (reverse) ? (slider.count + slider.cloneOffset) * dimension : 0;
767          } else if (slider.currentSlide === slider.last && target === 0 && slider.vars.animationLoop && slider.direction !== "prev") {
768            slideString = (reverse) ? 0 : (slider.count + 1) * dimension;
769          } else {
770            slideString = (reverse) ? ((slider.count - 1) - target + slider.cloneOffset) * dimension : (target + slider.cloneOffset) * dimension;
771          }
772          slider.setProps(slideString, "", slider.vars.animationSpeed);
773          if (slider.transitions) {
774            if (!slider.vars.animationLoop || !slider.atEnd) {
775              slider.animating = false;
776              slider.currentSlide = slider.animatingTo;
777            }
778
779            // Unbind previous transitionEnd events and re-bind new transitionEnd event
780            slider.container.unbind("webkitTransitionEnd transitionend");
781            slider.container.bind("webkitTransitionEnd transitionend", function() {
782              clearTimeout(slider.ensureAnimationEnd);
783              slider.wrapup(dimension);
784            });
785
786            // Insurance for the ever-so-fickle transitionEnd event
787            clearTimeout(slider.ensureAnimationEnd);
788            slider.ensureAnimationEnd = setTimeout(function() {
789              slider.wrapup(dimension);
790            }, slider.vars.animationSpeed + 100);
791
792          } else {
793            slider.container.animate(slider.args, slider.vars.animationSpeed, slider.vars.easing, function(){
794              slider.wrapup(dimension);
795            });
796          }
797        } else { // FADE:
798          if (!touch) {
799            

799//slider.slides.eq(slider.currentSlide).fadeOut(slider.vars.animationSpeed, slider.vars.easing);
800            //slider.slides.eq(target).fadeIn(slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
801
802            slider.slides.eq(slider.currentSlide).css({"zIndex": 1}).animate({"opacity": 0}, slider.vars.animationSpeed, slider.vars.easing);
803            slider.slides.eq(target).css({"zIndex": 2}).animate({"opacity": 1}, slider.vars.animationSpeed, slider.vars.easing, slider.wrapup);
804
805          } else {
806            slider.slides.eq(slider.currentSlide).css({ "opacity": 0, "zIndex": 1 });
807            slider.slides.eq(target).css({ "opacity": 1, "zIndex": 2 });
808            slider.wrapup(dimension);
809          }
810        }
811        // SMOOTH HEIGHT:
812        if (slider.vars.smoothHeight) { methods.smoothHeight(slider.vars.animationSpeed); }
813      }
814    };
815    slider.wrapup = function(dimension) {
816      // SLIDE:
817      if (!fade && !carousel) {
818        if (slider.currentSlide === 0 && slider.animatingTo === slider.last && slider.vars.animationLoop) {
819          slider.setProps(dimension, "jumpEnd");
820        } else if (slider.currentSlide === slider.last && slider.animatingTo === 0 && slider.vars.animationLoop) {
821          slider.setProps(dimension, "jumpStart");
822        }
823      }
824      slider.animating = false;
825      slider.currentSlide = slider.animatingTo;
826      // API: after() animation Callback
827      slider.vars.after(slider);
828    };
829
830    // SLIDESHOW:
831    slider.animateSlides = function() {
832      if (!slider.animating && focused ) { slider.flexAnimate(slider.getTarget("next")); }
833    };
834    // SLIDESHOW:
835    slider.pause = function() {
836      clearInterval(slider.animatedSlides);
837      slider.animatedSlides = null;
838      slider.playing = false;
839      // PAUSEPLAY:
840      if (slider.vars.pausePlay) { methods.pausePlay.update("play"); }
841      // SYNC:
842      if (slider.syncExists) { methods.sync("pause"); }
843    };
844    // SLIDESHOW:
845    slider.play = function() {
846      if (slider.playing) { clearInterval(slider.animatedSlides); }
847      slider.animatedSlides = slider.animatedSlides || setInterval(slider.animateSlides, slider.vars.slideshowSpeed);
848      slider.started = slider.playing = true;
849      // PAUSEPLAY:
850      if (slider.vars.pausePlay) { methods.pausePlay.update("pause"); }
851      // SYNC:
852      if (slider.syncExists) { methods.sync("play"); }
853    };
854    // STOP:
855    slider.stop = function () {
856      slider.pause();
857      slider.stopped = true;
858    };
859    slider.canAdvance = function(target, fromNav) {
860      // ASNAV:
861      var last = (asNav) ? slider.pagingCount - 1 : slider.last;
862      return (fromNav) ? true :
863             (asNav && slider.currentItem === slider.count - 1 && target === 0 && slider.direction === "prev") ? true :
864             (asNav && slider.currentItem === 0 && target === slider.pagingCount - 1 && slider.direction !== "next") ? false :
865             (target === slider.currentSlide && !asNav) ? false :
866             (slider.vars.animationLoop) ? true :
867             (slider.atEnd && slider.currentSlide === 0 && target === last && slider.direction !== "next") ? false :
868             (slider.atEnd && slider.currentSlide === last && target === 0 && slider.direction === "next") ? false :
869             true;
870    };
871    slider.getTarget = function(dir) {
872      slider.direction = dir;
873      if (dir === "next") {
874        return (slider.currentSlide === slider.last) ? 0 : slider.currentSlide + 1;
875      } else {
876        return (slider.currentSlide === 0) ? slider.last : slider.currentSlide - 1;
877      }
878    };
879
880    // SLIDE:
881    slider.setProps = function(pos, special, dur) {
882      var target = (function() {
883        var posCheck = (pos) ? pos : ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo,
884            posCalc = (function() {
885              if (carousel) {
886                return (special === "setTouch") ? pos :
887                       (reverse && slider.animatingTo === slider.last) ? 0 :
888                       (reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
889                       (slider.animatingTo === slider.last) ? slider.limit : posCheck;
890              } else {
891                switch (special) {
892                  case "setTotal": return (reverse) ? ((slider.count - 1) - slider.currentSlide + slider.cloneOffset) * pos : (slider.currentSlide + slider.cloneOffset) * pos;
893                  case "setTouch": return (reverse) ? pos : pos;
894                  case "jumpEnd": return (reverse) ? pos : slider.count * pos;
895                  case "jumpStart": return (reverse) ? slider.count * pos : pos;
896                  default: return pos;
897                }
898              }
899            }());
900
901            return (posCalc * -1) + "px";
902          }());
903
904      if (slider.transitions) {
905        target = (vertical) ? "translate3d(0," + target + ",0)" : "translate3d(" + target + ",0,0)";
906        dur = (dur !== undefined) ? (dur/1000) + "s" : "0s";
907        slider.container.css("-" + slider.pfx + "-transition-duration", dur);
908         slider.container.css("transition-duration", dur);
909      }
910
911      slider.args[slider.prop] = target;
912      if (slider.transitions || dur === undefined) { slider.container.css(slider.args); }
913
914      slider.container.css('transform',target);
915    };
916
917    slider.setup = function(type) {
918      // SLIDE:
919      if (!fade) {
920        var sliderOffset, arr;
921
922        if (type === "init") {
923          slider.viewport = $('<div class="' + namespace + 'viewport"></div>').css({"overflow": "hidden", "position": "relative"}).appendTo(slider).append(slider.container);
924          // INFINITE LOOP:
925          slider.cloneCount = 0;
926          slider.cloneOffset = 0;
927          // REVERSE:
928          if (reverse) {
929            arr = $.makeArray(slider.slides).reverse();
930            slider.slides = $(arr);
931            slider.container.empty().append(slider.slides);
932          }
933        }
934        // INFINITE LOOP && !CAROUSEL:
935        if (slider.vars.animationLoop && !carousel) {
936          slider.cloneCount = 2;
937          slider.cloneOffset = 1;
938          // clear out old clones
939          if (type !== "init") { slider.container.find('.clone').remove(); }
940          slider.container.append(methods.uniqueID(slider.slides.first().clone().addClass('clone')).attr('aria-hidden', 'true'))
941                          .prepend(methods.uniqueID(slider.slides.last().clone().addClass('clone')).attr('aria-hidden', 'true'));
942        }
943        slider.newSlides = $(slider.vars.selector, slider);
944
945        sliderOffset = (reverse) ? slider.count - 1 - slider.currentSlide + slider.cloneOffset : slider.currentSlide + slider.cloneOffset;
946        // VERTICAL:
947        if (vertical && !carousel) {
948          slider.container.height((slider.count + slider.cloneCount) * 200 + "%").css("position", "absolute").width("100%");
949          setTimeout(function(){
950            slider.newSlides.css({"display": "block"});
951            slider.doMath();
952            slider.viewport.height(slider.h);
953            slider.setProps(sliderOffset * slider.h, "init");
954          }, (type === "init") ? 100 : 0);
955        } else {
956          slider.container.width((slider.count + slider.cloneCount) * 200 + "%");
957          slider.setProps(sliderOffset * slider.computedW, "init");
958          setTimeout(function(){
959            slider.doMath();
960            slider.newSlides.css({"width": slider.computedW, "marginRight" : slider.computedM, "float": "left", "display": "block"});
961            // SMOOTH HEIGHT:
962            if (slider.vars.smoothHeight) { methods.smoothHeight(); }
963          }, (type === "init") ? 100 : 0);
964        }
965      } else { // FADE:
966        slider.slides.css({"width": "100%", "float": "left", "marginRight": "-100%", "position": "relative"});
967        if (type === "init") {
968          if (!touch) {
969            //slider.slides.eq(slider.currentSlide).fadeIn(slider.vars.animationSpeed, slider.vars.easing);
970            if (slider.vars.fadeFirstSlide == false) {
971              slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).css({"opacity": 1});
972            } else {
973              slider.slides.css({ "opacity": 0, "display": "block", "zIndex": 1 }).eq(slider.currentSlide).css({"zIndex": 2}).animate({"opacity": 1},slider.vars.animationSpeed,slider.vars.easing);
974            }
975          } else {
976            slider.slides.css({ "opacity": 0, "display": "block", "webkitTransition": "opacity " + slider.vars.animationSpeed / 1000 + "s ease", "zIndex": 1 }).eq(slider.currentSlide).css({ "opacity": 1, "zIndex": 2});
977          }
978        }
979        // SMOOTH HEIGHT:
980        if (slider.vars.smoothHeight) { methods.smoothHeight(); }
981      }
982      // !CAROUSEL:
983      // CANDIDATE: active slide
984      if (!carousel) { slider.slides.removeClass(namespace + "active-slide").eq(slider.currentSlide).addClass(namespace + "active-slide"); }
985
986      //FlexSlider: init() Callback
987      slider.vars.init(slider);
988    };
989
990    slider.doMath = function() {
991      var slide = slider.slides.first(),
992          slideMargin = slider.vars.itemMargin,
993          minItems = slider.vars.minItems,
994          maxItems = slider.vars.maxItems;
995
996      slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
997      slider.h = slide.height();
998      slider.boxPadding = slide.outerWidth() - slide.width();
999
1000      // CAROUSEL:
1001      if (carousel) {
1002        slider.itemT = slider.vars.itemWidth + slideMargin;
1003        slider.itemM = slideMargin;
1004        slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
1005        slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
1006        slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
1007                       (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
1008                       (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
1009
1010        slider.visible = Math.floor(slider.w/(slider.itemW));
1011        slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
1012        slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
1013        slider.last =  slider.pagingCount - 1;
1014        slider.limit = (slider.pagingCount === 1) ? 0 :
1015                       (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
1016      } else {
1017        slider.itemW = slider.w;
1018        slider.itemM = slideMargin;
1019        slider.pagingCount = slider.count;
1020        slider.last = slider.count - 1;
1021      }
1022      slider.computedW = slider.itemW - slider.boxPadding;
1023      slider.computedM = slider.itemM;
1024    };
1025
1026    slider.update = function(pos, action) {
1027      slider.doMath();
1028
1029      // update currentSlide and slider.animatingTo if necessary
1030      if (!carousel) {
1031        if (pos < slider.currentSlide) {
1032          slider.currentSlide += 1;
1033        } else if (pos <= slider.currentSlide && pos !== 0) {
1034          slider.currentSlide -= 1;
1035        }
1036        slider.animatingTo = slider.currentSlide;
1037      }
1038
1039      // update controlNav
1040      if (slider.vars.controlNav && !slider.manualControls) {
1041        if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
1042          methods.controlNav.update("add");
1043        } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
1044          if (carousel && slider.currentSlide > slider.last) {
1045            slider.currentSlide -= 1;
1046            slider.animatingTo -= 1;
1047          }
1048          methods.controlNav.update("remove", slider.last);
1049        }
1050      }
1051      // update directionNav
1052      if (slider.vars.directionNav) { methods.directionNav.update(); }
1053
1054    };
1055
1056    slider.addSlide = function(obj, pos) {
1057      var $obj = $(obj);
1058
1059      slider.count += 1;
1060      slider.last = slider.count - 1;
1061
1062      // append new slide
1063      if (vertical && reverse) {
1064        (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
1065      } else {
1066        (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
1067      }
1068
1069      // update currentSlide, animatingTo, controlNav, and directionNav
1070      slider.update(pos, "add");
1071
1072      // update slider.slides
1073      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1074      // re-setup the slider to accomdate new slide
1075      slider.setup();
1076
1077      //FlexSlider: added() Callback
1078      slider.vars.added(slider);
1079    };
1080    slider.removeSlide = function(obj) {
1081      var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
1082
1083      // update count
1084      slider.count -= 1;
1085      slider.last = slider.count - 1;
1086
1087      // remove slide
1088      if (isNaN(obj)) {
1089        $(obj, slider.slides).remove();
1090      } else {
1091        (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
1092      }
1093
1094      // update currentSlide, animatingTo, controlNav, and directionNav
1095      slider.doMath();
1096      slider.update(pos, "remove");
1097
1098      // update slider.slides
1099      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1100      // re-setup the slider to accomdate new slide
1101      slider.setup();
1102
1103      // FlexSlider: removed() Callback
1104      slider.vars.removed(slider);
1105    };
1106
1107    //FlexSlider: Initialize
1108    methods.init();
1109  };
1110
1111  // Ensure the slider isn't focussed if the window loses focus.
1112  $( window ).blur( function ( e ) {
1113    focused = false;

1744  this.elements.forEach( this.addElementImages, this );
1745};
1746
1747/**
1748 * @param {Node} element
1749 */
1750ImagesLoaded.prototype.addElementImages = function( elem ) {
1751  // filter siblings
1752  if ( elem.nodeName == 'IMG' ) {
1753    this.addImage( elem );
1754  }
1755  // get background image on element
1756  if ( this.options.background === true ) {
1757    this.addElementBackgroundImages( elem );
1758  }
1759
1760  // find children
1761  // no non-element nodes, #143
1762  var nodeType = elem.nodeType;
1763  if ( !nodeType || !elementNodeTypes[ nodeType ] ) {
1764    return;
1765  }
1766  var childImgs = elem.querySelectorAll('img');
1767  // concat childElems to filterFound array
1768  for ( var i=0; i < childImgs.length; i++ ) {
1769    var img = childImgs[i];
1770    this.addImage( img );
1771  }
1772
1773  // get child background images
1774  if ( typeof this.options.background == 'string' ) {
1775    var children = elem.querySelectorAll( this.options.background );
1776    for ( i=0; i < children.length; i++ ) {
1777      var child = children[i];
1778      this.addElementBackgroundImages( child );
1779    }
1780  }
1781};
1782
1783var elementNodeTypes = {
1784  1: true,
1785  9: true,
1786  11: true
1787};
1788
1789ImagesLoaded.prototype.addElementBackgroundImages = function( elem ) {
1790  var style = getComputedStyle( elem );
1791  if ( !style ) {
1792    // Firefox returns null if in a hidden iframe https://bugzil.la/548397
1793    return;
1794  }
1795  // get url inside url("...")
1796  var reURL = /url\((['"])?(.*?)\1\)/gi;
1797  var matches = reURL.exec( style.backgroundImage );
1798  while ( matches !== null ) {
1799    var url = matches && matches[2];
1800    if ( url ) {
1801      this.addBackground( url, elem );
1802    }
1803    matches = reURL.exec( style.backgroundImage );
1804  }
1805};
1806
1807/**
1808 * @param {Image} img
1809 */
1810ImagesLoaded.prototype.addImage = function( img ) {
1811  var loadingImage = new LoadingImage( img );
1812  this.images.push( loadingImage );
1813};
1814
1815ImagesLoaded.prototype.addBackground = function( url, elem ) {
1816  var background = new Background( url, elem );
1817  this.images.push( background );
1818};
1819
1820ImagesLoaded.prototype.check = function() {
1821  var _this = this;
1822  this.progressedCount = 0;
1823  this.hasAnyBroken = false;
1824  // complete if no images
1825  if ( !this.images.length ) {
1826    this.complete();
1827    return;
1828  }
1829
1830  function onProgress( image, elem, message ) {
1831    // HACK - Chrome triggers event before object properties have changed. #83
1832    setTimeout( function() {
1833      _this.progress( image, elem, message );
1834    });
1835  }
1836
1837  this.images.forEach( function( loadingImage ) {
1838    loadingImage.once( 'progress', onProgress );
1839    loadingImage.check();
1840  });
1841};
1842
1843ImagesLoaded.prototype.progress = function( image, elem, message ) {
1844  this.progressedCount++;
1845  this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded;
1846  // progress event
1847  this.emitEvent( 'progress', [ this, image, elem ] );
1848  if ( this.jqDeferred && this.jqDeferred.notify ) {
1849    this.jqDeferred.notify( this, image );
1850  }
1851  // check if completed
1852  if ( this.progressedCount == this.images.length ) {
1853    this.complete();
1854  }
1855
1856  if ( this.options.debug && console ) {
1857    console.log( 'progress: ' + message, image, elem );
1858  }
1859};
1860
1861ImagesLoaded.prototype.complete = function() {
1862  var eventName = this.hasAnyBroken ? 'fail' : 'done';
1863  this.isComplete = true;
1864  this.emitEvent( eventName, [ this ] );
1865  this.emitEvent( 'always', [ this ] );
1866  if ( this.jqDeferred ) {
1867    var jqMethod = this.hasAnyBroken ? 'reject' : 'resolve';
1868    this.jqDeferred[ jqMethod ]( this );
1869  }
1870};
1871
1872// --------------------------  -------------------------- //
1873
1874function LoadingImage( img ) {
1875  this.img = img;
1876}
1877
1878LoadingImage.prototype = Object.create( EvEmitter.prototype );
1879
1880LoadingImage.prototype.check = function() {
1881  // If complete is true and browser supports natural sizes,
1882  // try to check for image status manually.
1883  var isComplete = this.getIsImageComplete();
1884  if ( isComplete ) {
1885    // report based on naturalWidth
1886    this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
1887    return;
1888  }
1889
1890  // If none of the checks above matched, simulate loading on detached element.
1891  this.proxyImage = new Image();
1892  this.proxyImage.addEventListener( 'load', this );
1893  this.proxyImage.addEventListener( 'error', this );
1894  // bind to image as well for Firefox. #191
1895  this.img.addEventListener( 'load', this );
1896  this.img.addEventListener( 'error', this );
1897  this.proxyImage.src = this.img.src;
1898};
1899
1900LoadingImage.prototype.getIsImageComplete = function() {

2130// ----- updateJQuery ----- //
2131
2132// set $.bridget for v1 backwards compatibility
2133function updateJQuery( $ ) {
2134  if ( !$ || ( $ && $.bridget ) ) {
2135    return;
2136  }
2137  $.bridget = jQueryBridget;
2138}
2139
2140updateJQuery( jQuery || window.jQuery );
2141
2142// -----  ----- //
2143
2144return jQueryBridget;
2145
2146}));
2147
2148/**
2149 * EvEmitter v1.0.3
2150 * Lil' event emitter
2151 * MIT License
2152 */
2153
2154/* jshint unused: true, undef: true, strict: true */
2155
2156( function( global, factory ) {
2157  // universal module definition
2158  /* jshint strict: false */ /* globals define, module, window */
2159  if ( typeof define == 'function' && define.amd ) {
2160    // AMD - RequireJS
2161    define( 'ev-emitter/ev-emitter',factory );
2162  } else if ( typeof module == 'object' && module.exports ) {
2163    // CommonJS - Browserify, Webpack
2164    module.exports = factory();
2165  } else {
2166    // Browser globals
2167    global.EvEmitter = factory();
2168  }
2169
2170}( typeof window != 'undefined' ? window : this, function() {
2171
2172
2173
2174function EvEmitter() {}
2175
2176var proto = EvEmitter.prototype;
2177
2178proto.on = function( eventName, listener ) {
2179  if ( !eventName || !listener ) {
2180    return;
2181  }
2182  // set events hash
2183  var events = this._events = this._events || {};
2184  // set listeners array
2185  var listeners = events[ eventName ] = events[ eventName ] || [];
2186  // only add once
2187  if ( listeners.indexOf( listener ) == -1 ) {
2188    listeners.push( listener );
2189  }
2190
2191  return this;
2192};
2193
2194proto.once = function( eventName, listener ) {
2195  if ( !eventName || !listener ) {
2196    return;
2197  }
2198  // add event
2199  this.on( eventName, listener );
2200  // set once flag
2201  // set onceEvents hash
2202  var onceEvents = this._onceEvents = this._onceEvents || {};
2203  // set onceListeners object
2204  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};
2205  // set flag
2206  onceListeners[ listener ] = true;
2207
2208  return this;
2209};
2210
2211proto.off = function( eventName, listener ) {
2212  var listeners = this._events && this._events[ eventName ];
2213  if ( !listeners || !listeners.length ) {
2214    return;
2215  }
2216  var index = listeners.indexOf( listener );
2217  if ( index != -1 ) {
2218    listeners.splice( index, 1 );
2219  }
2220
2221  return this;
2222};
2223
2224proto.emitEvent = function( eventName, args ) {
2225  var listeners = this._events && this._events[ eventName ];
2226  if ( !listeners || !listeners.length ) {
2227    return;
2228  }
2229  var i = 0;
2230  var listener = listeners[i];
2231  args = args || [];
2232  // once stuff
2233  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];
2234
2235  while ( listener ) {
2236    var isOnce = onceListeners && onceListeners[ listener ];
2237    if ( isOnce ) {
2238      // remove listener
2239      // remove before trigger to prevent recursion
2240      this.off( eventName, listener );
2241      // unset once flag
2242      delete onceListeners[ listener ];
2243    }
2244    // trigger listener
2245    listener.apply( this, args );
2246    // get next listener
2247    i += isOnce ? 0 : 1;
2248    listener = listeners[i];
2249  }
2250
2251  return this;
2252};
2253
2254return EvEmitter;
2255
2256}));
2257
2258/*!
2259 * getSize v2.0.2
2260 * measure size of elements
2261 * MIT license
2262 */
2263
2264/*jshint browser: true, strict: true, undef: true, unused: true */
2265/*global define: false, module: false, console: false */
2266
2267( function( window, factory ) {
2268  'use strict';
2269
2270  if ( typeof define == 'function' && define.amd ) {
2271    // AMD
2272    define( 'get-size/get-size',[],function() {
2273      return factory();
2274    });
2275  } else if ( typeof module == 'object' && module.exports ) {
2276    // CommonJS
2277    module.exports = factory();
2278  } else {
2279    // browser global
2280    window.getSize = factory();
2281  }
2282
2283})( window, function factory() {
2284'use strict';
2285
2286// -------------------------- helpers -------------------------- //
2287
2288// get a number from a string, not a percentage
2289function getStyleSize( value ) {
2290  var num = parseFloat( value );
2291  // not a percent like '100%', and a number
2292  var isValid = value.indexOf('%') == -1 && !isNaN( num );
2293  return isValid && num;
2294}
2295
2296function noop() {}
2297
2298var logError = typeof console == 'undefined' ? noop :
2299  function( message ) {
2300    console.error( message );
2301  };
2302
2303// -------------------------- measurements -------------------------- //
2304
2305var measurements = [
2306  'paddingLeft',
2307  'paddingRight',
2308  'paddingTop',
2309  'paddingBottom',
2310  'marginLeft',
2311  'marginRight',
2312  'marginTop',
2313  'marginBottom',
2314  'borderLeftWidth',
2315  'borderRightWidth',
2316  'borderTopWidth',
2317  'borderBottomWidth'
2318];
2319
2320var measurementsLength = measurements.length;
2321
2322function getZeroSize() {
2323  var size = {
2324    width: 0,
2325    height: 0,
2326    innerWidth: 0,
2327    innerHeight: 0,
2328    outerWidth: 0,
2329    outerHeight: 0
2330  };
2331  for ( var i=0; i < measurementsLength; i++ ) {
2332    var measurement = measurements[i];
2333    size[ measurement ] = 0;
2334  }
2335  return size;
2336}
2337
2338// -------------------------- getStyle -------------------------- //
2339
2340/**
2341 * getStyle, get style of element, check for Firefox bug
2342 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
2343 */
2344function getStyle( elem ) {
2345  var style = getComputedStyle( elem );
2346  if ( !style ) {
2347    logError( 'Style returned ' + style +
2348      '. Are you running this code in a hidden iframe on Firefox? ' +
2349      'See http://bit.ly/getsizebug1' );
2350  }
2351  return style;
2352}
2353
2354// -------------------------- setup -------------------------- //
2355
2356var isSetup = false;
2357
2358var isBoxSizeOuter;
2359
2360/**
2361 * setup
2362 * check isBoxSizerOuter
2363 * do on first getSize() rather than on page load for Firefox bug
2364 */
2365function setup() {
2366  // setup once
2367  if ( isSetup ) {
2368    return;
2369  }
2370  isSetup = true;
2371
2372  // -------------------------- box sizing -------------------------- //
2373
2374  /**
2375   * WebKit measures the outer-width on style.width on border-box elems
2376   * IE & Firefox<29 measures the inner-width
2377   */
2378  var div = document.createElement('div');
2379  div.style.width = '200px';
2380  div.style.padding = '1px 2px 3px 4px';
2381  div.style.borderStyle = 'solid';
2382  div.style.borderWidth = '1px 2px 3px 4px';
2383  div.style.boxSizing = 'border-box';
2384
2385  var body = document.body || document.documentElement;
2386  body.appendChild( div );
2387  var style = getStyle( div );
2388
2389  getSize.isBoxSizeOuter = isBoxSizeOuter = getStyleSize( style.width ) == 200;
2390  body.removeChild( div );
2391
2392}
2393
2394// -------------------------- getSize -------------------------- //
2395
2396function getSize( elem ) {
2397  setup();
2398
2399  // use querySeletor if elem is string
2400  if ( typeof elem == 'string' ) {
2401    elem = document.querySelector( elem );
2402  }
2403
2404  // do not proceed on non-objects
2405  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
2406    return;
2407  }
2408
2409  var style = getStyle( elem );
2410
2411  // if hidden, everything is 0
2412  if ( style.display == 'none' ) {
2413    return getZeroSize();
2414  }
2415
2416  var size = {};
2417  size.width = elem.offsetWidth;
2418  size.height = elem.offsetHeight;
2419
2420  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
2421
2422  // get all measurements
2423  for ( var i=0; i < measurementsLength; i++ ) {
2424    var measurement = measurements[i];
2425    var value = style[ measurement ];
2426    var num = parseFloat( value );
2427    // any 'auto', 'medium' value will be 0
2428    size[ measurement ] = !isNaN( num ) ? num : 0;
2429  }
2430
2431  var paddingWidth = size.paddingLeft + size.paddingRight;
2432  var paddingHeight = size.paddingTop + size.paddingBottom;
2433  var marginWidth = size.marginLeft + size.marginRight;
2434  var marginHeight = size.marginTop + size.marginBottom;
2435  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
2436  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
2437
2438  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
2439
2440  // overwrite width and height if we can get it from style
2441  var styleWidth = getStyleSize( style.width );
2442  if ( styleWidth !== false ) {
2443    size.width = styleWidth +
2444      // add padding and border unless it's already including it
2445      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
2446  }
2447
2448  var styleHeight = getStyleSize( style.height );
2449  if ( styleHeight !== false ) {
2450    size.height = styleHeight +
2451      // add padding and border unless it's already including it
2452      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
2453  }
2454
2455  size.innerWidth = size.width - ( paddingWidth + borderWidth );
2456  size.innerHeight = size.height - ( paddingHeight + borderHeight );
2457
2458  size.outerWidth = size.width + marginWidth;
2459  size.outerHeight = size.height + marginHeight;
2460
2461  return size;
2462}
2463
2464return getSize;
2465
2466});
2467
2468/**
2469 * matchesSelector v2.0.1
2470 * matchesSelector( element, '.selector' )
2471 * MIT license
2472 */
2473
2474/*jshint browser: true, strict: true, undef: true, unused: true */
2475
2476( function( window, factory ) {
2477  /*global define: false, module: false */
2478  'use strict';
2479  // universal module definition
2480  if ( typeof define == 'function' && define.amd ) {
2481    // AMD
2482    define( 'desandro-matches-selector/matches-selector',factory );
2483  } else if ( typeof module == 'object' && module.exports ) {
2484    // CommonJS
2485    module.exports = factory();
2486  } else {
2487    // browser global
2488    window.matchesSelector = factory();
2489  }
2490
2491}( window, function factory() {
2492  'use strict';
2493
2494  var matchesMethod = ( function() {
2495    var ElemProto = Element.prototype;
2496    // check for the standard method name first
2497    if ( ElemProto.matches ) {
2498      return 'matches';
2499    }
2500    // check un-prefixed
2501    if ( ElemProto.matchesSelector ) {
2502      return 'matchesSelector';
2503    }
2504    // check vendor prefixes
2505    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
2506
2507    for ( var i=0; i < prefixes.length; i++ ) {
2508      var prefix = prefixes[i];
2509      var method = prefix + 'MatchesSelector';
2510      if ( ElemProto[ method ] ) {
2511        return method;
2512      }
2513    }
2514  })();
2515
2516  return function matchesSelector( elem, selector ) {
2517    return elem[ matchesMethod ]( selector );
2518  };
2519
2520}));
2521
2522/**
2523 * Fizzy UI utils v2.0.2
2524 * MIT license
2525 */
2526
2527/*jshint browser: true, undef: true, unused: true, strict: true */
2528
2529( function( window, factory ) {
2530  // universal module definition
2531  /*jshint strict: false */ /*globals define, module, require */
2532
2533  if ( typeof define == 'function' && define.amd ) {
2534    // AMD
2535    define( 'fizzy-ui-utils/utils',[
2536      'desandro-matches-selector/matches-selector'
2537    ], function( matchesSelector ) {
2538      return factory( window, matchesSelector );
2539    });
2540  } else if ( typeof module == 'object' && module.exports ) {
2541    // CommonJS
2542    module.exports = factory(
2543      window,
2544      require('desandro-matches-selector')
2545    );
2546  } else {
2547    // browser global
2548    window.fizzyUIUtils = factory(
2549      window,
2550      window.matchesSelector
2551    );
2552  }
2553
2554}( window, function factory( window, matchesSelector ) {
2555
2556
2557
2558var utils = {};
2559
2560// ----- extend ----- //
2561
2562// extends objects
2563utils.extend = function( a, b ) {
2564  for ( var prop in b ) {
2565    a[ prop ] = b[ prop ];
2566  }
2567  return a;
2568};
2569
2570// ----- modulo ----- //
2571
2572utils.modulo = function( num, div ) {
2573  return ( ( num % div ) + div ) % div;
2574};
2575
2576// ----- makeArray ----- //
2577
2578// turn element or nodeList into an array
2579utils.makeArray = function( obj ) {
2580  var ary = [];
2581  if ( Array.isArray( obj ) ) {
2582    // use object if already an array
2583    ary = obj;
2584  } else if ( obj && typeof obj.length == 'number' ) {
2585    // convert nodeList to array
2586    for ( var i=0; i < obj.length; i++ ) {
2587      ary.push( obj[i] );
2588    }
2589  } else {
2590    // array of single index
2591    ary.push( obj );
2592  }
2593  return ary;
2594};
2595
2596// ----- removeFrom ----- //
2597
2598utils.removeFrom = function( ary, obj ) {
2599  var index = ary.indexOf( obj );
2600  if ( index != -1 ) {
2601    ary.splice( index, 1 );
2602  }
2603};
2604
2605// ----- getParent ----- //
2606
2607utils.getParent = function( elem, selector ) {
2608  while ( elem != document.body ) {
2609    elem = elem.parentNode;
2610    if ( matchesSelector( elem, selector ) ) {
2611      return elem;
2612    }
2613  }
2614};
2615
2616// ----- getQueryElement ----- //
2617
2618// use element as selector string
2619utils.getQueryElement = function( elem ) {
2620  if ( typeof elem == 'string' ) {
2621    return document.querySelector( elem );
2622  }
2623  return elem;
2624};
2625
2626// ----- handleEvent ----- //
2627
2628// enable .ontype to trigger from .addEventListener( elem, 'type' )
2629utils.handleEvent = function( event ) {
2630  var method = 'on' + event.type;
2631  if ( this[ method ] ) {
2632    this[ method ]( event );
2633  }
2634};
2635
2636// ----- filterFindElements ----- //
2637
2638utils.filterFindElements = function( elems, selector ) {
2639  // make array of elems
2640  elems = utils.makeArray( elems );
2641  var ffElems = [];
2642
2643  elems.forEach( function( elem ) {
2644    // check that elem is an actual element
2645    if ( !( elem instanceof HTMLElement ) ) {
2646      return;
2647    }
2648    // add elem if no selector
2649    if ( !selector ) {
2650      ffElems.push( elem );
2651      return;
2652    }
2653    // filter & find items if we have a selector
2654    // filter
2655    if ( matchesSelector( elem, selector ) ) {
2656      ffElems.push( elem );
2657    }
2658    // find children
2659    var childElems = elem.querySelectorAll( selector );
2660    // concat childElems to filterFound array
2661    for ( var i=0; i < childElems.length; i++ ) {
2662      ffElems.push( childElems[i] );
2663    }
2664  });
2665
2666  return ffElems;
2667};
2668
2669// ----- debounceMethod ----- //
2670
2671utils.debounceMethod = function( _class, methodName, threshold ) {
2672  // original method
2673  var method = _class.prototype[ methodName ];
2674  var timeoutName = methodName + 'Timeout';
2675
2676  _class.prototype[ methodName ] = function() {
2677    var timeout = this[ timeoutName ];
2678    if ( timeout ) {
2679      clearTimeout( timeout );
2680    }
2681    var args = arguments;
2682
2683    var _this = this;
2684    this[ timeoutName ] = setTimeout( function() {
2685      method.apply( _this, args );
2686      delete _this[ timeoutName ];
2687    }, threshold || 100 );
2688  };
2689};
2690
2691// ----- docReady ----- //
2692
2693utils.docReady = function( callback ) {
2694  var readyState = document.readyState;
2695  if ( readyState == 'complete' || readyState == 'interactive' ) {
2696    callback();
2697  } else {
2698    document.addEventListener( 'DOMContentLoaded', callback );
2699  }
2700};
2701
2702// ----- htmlInit ----- //
2703
2704// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
2705utils.toDashed = function( str ) {
2706  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
2707    return $1 + '-' + $2;
2708  }).toLowerCase();
2709};
2710
2711var console = window.console;
2712/**
2713 * allow user to initialize classes via [data-namespace] or .js-namespace class
2714 * htmlInit( Widget, 'widgetName' )
2715 * options are parsed from data-namespace-options
2716 */
2717utils.htmlInit = function( WidgetClass, namespace ) {
2718  utils.docReady( function() {
2719    var dashedNamespace = utils.toDashed( namespace );
2720    var dataAttr = 'data-' + dashedNamespace;
2721    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
2722    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
2723    var elems = utils.makeArray( dataAttrElems )
2724      .concat( utils.makeArray( jsDashElems ) );
2725    var dataOptionsAttr = dataAttr + '-options';
2726    var jQuery = window.jQuery;
2727
2728    elems.forEach( function( elem ) {
2729      var attr = elem.getAttribute( dataAttr ) ||
2730        elem.getAttribute( dataOptionsAttr );
2731      var options;
2732      try {
2733        options = attr && JSON.parse( attr );
2734      } catch ( error ) {
2735        // log error, do not initialize
2736        if ( console ) {
2737          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
2738          ': ' + error );
2739        }
2740        return;
2741      }
2742      // initialize
2743      var instance = new WidgetClass( elem, options );
2744      // make available via $().data('layoutname')
2745      if ( jQuery ) {
2746        jQuery.data( elem, namespace, instance );
2747      }
2748    });
2749
2750  });
2751};
2752
2753// -----  ----- //
2754
2755return utils;
2756
2757}));
2758
2759/**
2760 * Outlayer Item
2761 */
2762
2763( function( window, factory ) {
2764  // universal module definition
2765  /* jshint strict: false */ /* globals define, module, require */
2766  if ( typeof define == 'function' && define.amd ) {
2767    // AMD - RequireJS
2768    define( 'outlayer/item',[
2769        'ev-emitter/ev-emitter',
2770        'get-size/get-size'
2771      ],
2772      factory
2773    );
2774  } else if ( typeof module == 'object' && module.exports ) {
2775    // CommonJS - Browserify, Webpack
2776    module.exports = factory(
2777      require('ev-emitter'),
2778      require('get-size')
2779    );
2780  } else {
2781    // browser global
2782    window.Outlayer = {};
2783    window.Outlayer.Item = factory(
2784      window.EvEmitter,
2785      window.getSize
2786    );
2787  }
2788
2789}( window, function factory( EvEmitter, getSize ) {
2790'use strict';
2791
2792// ----- helpers ----- //
2793
2794function isEmptyObj( obj ) {
2795  for ( var prop in obj ) {
2796    return false;
2797  }
2798  prop = null;
2799  return true;
2800}
2801
2802// -------------------------- CSS3 support -------------------------- //
2803
2804
2805var docElemStyle = document.documentElement.style;
2806
2807var transitionProperty = typeof docElemStyle.transition == 'string' ?
2808  'transition' : 'WebkitTransition';
2809var transformProperty = typeof docElemStyle.transform == 'string' ?
2810  'transform' : 'WebkitTransform';
2811
2812var transitionEndEvent = {
2813  WebkitTransition: 'webkitTransitionEnd',
2814  transition: 'transitionend'
2815}[ transitionProperty ];
2816
2817// cache all vendor properties that could have vendor prefix
2818var vendorProperties = {
2819  transform: transformProperty,
2820  transition: transitionProperty,
2821  transitionDuration: transitionProperty + 'Duration',
2822  transitionProperty: transitionProperty + 'Property',
2823  transitionDelay: transitionProperty + 'Delay'
2824};
2825
2826// -------------------------- Item -------------------------- //
2827
2828function Item( element, layout ) {
2829  if ( !element ) {
2830    return;
2831  }
2832
2833  this.element = element;
2834  // parent layout class, i.e. Masonry, Isotope, or Packery
2835  this.layout = layout;
2836  this.position = {
2837    x: 0,
2838    y: 0
2839  };
2840
2841  this._create();
2842}
2843
2844// inherit EvEmitter
2845var proto = Item.prototype = Object.create( EvEmitter.prototype );
2846proto.constructor = Item;
2847
2848proto._create = function() {
2849  // transition objects
2850  this._transn = {
2851    ingProperties: {},
2852    clean: {},
2853    onEnd: {}
2854  };
2855
2856  this.css({
2857    position: 'absolute'
2858  });
2859};
2860
2861// trigger specified handler for event type
2862proto.handleEvent = function( event ) {
2863  var method = 'on' + event.type;
2864  if ( this[ method ] ) {
2865    this[ method ]( event );
2866  }
2867};
2868
2869proto.getSize = function() {
2870  this.size = getSize( this.element );
2871};
2872
2873/**
2874 * apply CSS styles to element
2875 * @param {Object} style
2876 */
2877proto.css = function( style ) {
2878  var elemStyle = this.element.style;
2879
2880  for ( var prop in style ) {
2881    // use vendor property if available