https://unclenearest.com/wp-content/themes/unclenearest/lib/js/flickity.pkgd.js?ver=1.0

1/*!
2 * Flickity PACKAGED v2.0.8
3 * Touch, responsive, flickable carousels
4 *
5 * Licensed GPLv3 for open source use
6 * or Flickity Commercial License for commercial use
7 *
8 * http://flickity.metafizzy.co
9 * Copyright 2016 Metafizzy
10 */
11
12/**
13 * Bridget makes jQuery widgets
14 * v2.0.1
15 * MIT license
16 */
17
18/* jshint browser: true, strict: true, undef: true, unused: true */
19
20( function( window, factory ) {
21  // universal module definition
22  /*jshint strict: false */ /* globals define, module, require */
23  if ( typeof define == 'function' && define.amd ) {
24    // AMD
25    define( 'jquery-bridget/jquery-bridget',[ 'jquery' ], function( jQuery ) {
26      return factory( window, jQuery );
27    });
28  } else if ( typeof module == 'object' && module.exports ) {
29    // CommonJS
30    module.exports = factory(
31      window,
32      require('jquery')
33    );
34  } else {
35    // browser global
36    window.jQueryBridget = factory(
37      window,
38      window.jQuery
39    );
40  }
41
42}( window, function factory( window, jQuery ) {
43'use strict';
44
45// ----- utils ----- //
46
47var arraySlice = Array.prototype.slice;
48
49// helper function for logging errors
50// $.error breaks jQuery chaining
51var console = window.console;
52var logError = typeof console == 'undefined' ? function() {} :
53  function( message ) {
54    console.error( message );
55  };
56
57// ----- jQueryBridget ----- //
58
59function jQueryBridget( namespace, PluginClass, $ ) {
60  $ = $ || jQuery || window.jQuery;
61  if ( !$ ) {
62    return;
63  }
64
65  // add option method -> $().plugin('option', {...})
66  if ( !PluginClass.prototype.option ) {
67    // option setter
68    PluginClass.prototype.option = function( opts ) {
69      // bail out if not an object
70      if ( !$.isPlainObject( opts ) ){
71        return;
72      }
73      this.options = $.extend( true, this.options, opts );
74    };
75  }
76
77  // make jQuery plugin
78  $.fn[ namespace ] = function( arg0 /*, arg1 */ ) {
79    if ( typeof arg0 == 'string' ) {
80      // method call $().plugin( 'methodName', { options } )
81      // shift arguments by 1
82      var args = arraySlice.call( arguments, 1 );
83      return methodCall( this, arg0, args );
84    }
85    // just $().plugin({ options })
86    plainCall( this, arg0 );
87    return this;
88  };
89
90  // $().plugin('methodName')
91  function methodCall( $elems, methodName, args ) {
92    var returnValue;
93    var pluginMethodStr = '$().' + namespace + '("' + methodName + '")';
94
95    $elems.each( function( i, elem ) {
96      // get instance
97      var instance = $.data( elem, namespace );
98      if ( !instance ) {
99        logError( namespace + ' not initialized. Cannot call methods, i.e. ' +
100          pluginMethodStr );
101        return;
102      }
103
104      var method = instance[ methodName ];
105      if ( !method || methodName.charAt(0) == '_' ) {
106        logError( pluginMethodStr + ' is not a valid method' );
107        return;
108      }
109
110      // apply method, get return value
111      var value = method.apply( instance, args );
112      // set return value if value is returned, use only first value
113      returnValue = returnValue === undefined ? value : returnValue;
114    });
115
116    return returnValue !== undefined ? returnValue : $elems;
117  }
118
119  function plainCall( $elems, options ) {
120    $elems.each( function( i, elem ) {
121      var instance = $.data( elem, namespace );
122      if ( instance ) {
123        // set options & init
124        instance.option( options );
125        instance._init();
126      } else {
127        // initialize new instance
128        instance = new PluginClass( elem, options );
129        $.data( elem, namespace, instance );
130      }
131    });
132  }
133
134  updateJQuery( $ );
135
136}
137
138// ----- updateJQuery ----- //
139
140// set $.bridget for v1 backwards compatibility
141function updateJQuery( $ ) {
142  if ( !$ || ( $ && $.bridget ) ) {
143    return;
144  }
145  $.bridget = jQueryBridget;
146}
147
148updateJQuery( jQuery || window.jQuery );
149
150// -----  ----- //
151
152return jQueryBridget;
153
154}));
155
156/**
157 * EvEmitter v1.0.3
158 * Lil' event emitter
159 * MIT License
160 */
161
162/* jshint unused: true, undef: true, strict: true */
163
164( function( global, factory ) {
165  // universal module definition
166  /* jshint strict: false */ /* globals define, module, window */
167  if ( typeof define == 'function' && define.amd ) {
168    // AMD - RequireJS
169    define( 'ev-emitter/ev-emitter',factory );
170  } else if ( typeof module == 'object' && module.exports ) {
171    // CommonJS - Browserify, Webpack
172    module.exports = factory();
173  } else {
174    // Browser globals
175    global.EvEmitter = factory();
176  }
177
178}( typeof window != 'undefined' ? window : this, function() {
179
180
181
182function EvEmitter() {}
183
184var proto = EvEmitter.prototype;
185
186proto.on = function( eventName, listener ) {
187  if ( !eventName || !listener ) {
188    return;
189  }
190  // set events hash
191  var events = this._events = this._events || {};
192  // set listeners array
193  var listeners = events[ eventName ] = events[ eventName ] || [];
194  // only add once
195  if ( listeners.indexOf( listener ) == -1 ) {
196    listeners.push( listener );
197  }
198
199  return this;
200};
201
202proto.once = function( eventName, listener ) {
203  if ( !eventName || !listener ) {
204    return;
205  }
206  // add event
207  this.on( eventName, listener );
208  // set once flag
209  // set onceEvents hash
210  var onceEvents = this._onceEvents = this._onceEvents || {};
211  // set onceListeners object
212  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};
213  // set flag
214  onceListeners[ listener ] = true;
215
216  return this;
217};
218
219proto.off = function( eventName, listener ) {
220  var listeners = this._events && this._events[ eventName ];
221  if ( !listeners || !listeners.length ) {
222    return;
223  }
224  var index = listeners.indexOf( listener );
225  if ( index != -1 ) {
226    listeners.splice( index, 1 );
227  }
228
229  return this;
230};
231
232proto.emitEvent = function( eventName, args ) {
233  var listeners = this._events && this._events[ eventName ];
234  if ( !listeners || !listeners.length ) {
235    return;
236  }
237  var i = 0;
238  var listener = listeners[i];
239  args = args || [];
240  // once stuff
241  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];
242
243  while ( listener ) {
244    var isOnce = onceListeners && onceListeners[ listener ];
245    if ( isOnce ) {
246      // remove listener
247      // remove before trigger to prevent recursion
248      this.off( eventName, listener );
249      // unset once flag
250      delete onceListeners[ listener ];
251    }
252    // trigger listener
253    listener.apply( this, args );
254    // get next listener
255    i += isOnce ? 0 : 1;
256    listener = listeners[i];
257  }
258
259  return this;
260};
261
262return EvEmitter;
263
264}));
265
266/*!
267 * getSize v2.0.2
268 * measure size of elements
269 * MIT license
270 */
271
272/*jshint browser: true, strict: true, undef: true, unused: true */
273/*global define: false, module: false, console: false */
274
275( function( window, factory ) {
276  'use strict';
277
278  if ( typeof define == 'function' && define.amd ) {
279    // AMD
280    define( 'get-size/get-size',[],function() {
281      return factory();
282    });
283  } else if ( typeof module == 'object' && module.exports ) {
284    // CommonJS
285    module.exports = factory();
286  } else {
287    // browser global
288    window.getSize = factory();
289  }
290
291})( window, function factory() {
292'use strict';
293
294// -------------------------- helpers -------------------------- //
295
296// get a number from a string, not a percentage
297function getStyleSize( value ) {
298  var num = parseFloat( value );
299  // not a percent like '100%', and a number
300  var isValid = value.indexOf('%') == -1 && !isNaN( num );
301  return isValid && num;
302}
303
304function noop() {}
305
306var logError = typeof console == 'undefined' ? noop :
307  function( message ) {
308    console.error( message );
309  };
310
311// -------------------------- measurements -------------------------- //
312
313var measurements = [
314  'paddingLeft',
315  'paddingRight',
316  'paddingTop',
317  'paddingBottom',
318  'marginLeft',
319  'marginRight',
320  'marginTop',
321  'marginBottom',
322  'borderLeftWidth',
323  'borderRightWidth',
324  'borderTopWidth',
325  'borderBottomWidth'
326];
327
328var measurementsLength = measurements.length;
329
330function getZeroSize() {
331  var size = {
332    width: 0,
333    height: 0,
334    innerWidth: 0,
335    innerHeight: 0,
336    outerWidth: 0,
337    outerHeight: 0
338  };
339  for ( var i=0; i < measurementsLength; i++ ) {
340    var measurement = measurements[i];
341    size[ measurement ] = 0;
342  }
343  return size;
344}
345
346// -------------------------- getStyle -------------------------- //
347
348/**
349 * getStyle, get style of element, check for Firefox bug
350 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
351 */
352function getStyle( elem ) {
353  var style = getComputedStyle( elem );
354  if ( !style ) {
355    logError( 'Style returned ' + style +
356      '. Are you running this code in a hidden iframe on Firefox? ' +
357      'See http://bit.ly/getsizebug1' );
358  }
359  return style;
360}
361
362// -------------------------- setup -------------------------- //
363
364var isSetup = false;
365
366var isBoxSizeOuter;
367
368/**
369 * setup
370 * check isBoxSizerOuter
371 * do on first getSize() rather than on page load for Firefox bug
372 */
373function setup() {
374  // setup once
375  if ( isSetup ) {
376    return;
377  }
378  isSetup = true;
379
380  // -------------------------- box sizing -------------------------- //
381
382  /**
383   * WebKit measures the outer-width on style.width on border-box elems
384   * IE & Firefox<29 measures the inner-width
385   */
386  var div = document.createElement('div');
387  div.style.width = '200px';
388  div.style.padding = '1px 2px 3px 4px';
389  div.style.borderStyle = 'solid';
390  div.style.borderWidth = '1px 2px 3px 4px';
391  div.style.boxSizing = 'border-box';
392
393  var body = document.body || document.documentElement;
394  body.appendChild( div );
395  var style = getStyle( div );
396
397  getSize.isBoxSizeOuter = isBoxSizeOuter = getStyleSize( style.width ) == 200;
398  body.removeChild( div );
399
400}
401
402// -------------------------- getSize -------------------------- //
403
404function getSize( elem ) {
405  setup();
406
407  // use querySeletor if elem is string
408  if ( typeof elem == 'string' ) {
409    elem = document.querySelector( elem );
410  }
411
412  // do not proceed on non-objects
413  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
414    return;
415  }
416
417  var style = getStyle( elem );
418
419  // if hidden, everything is 0
420  if ( style.display == 'none' ) {
421    return getZeroSize();
422  }
423
424  var size = {};
425  size.width = elem.offsetWidth;
426  size.height = elem.offsetHeight;
427
428  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
429
430  // get all measurements
431  for ( var i=0; i < measurementsLength; i++ ) {
432    var measurement = measurements[i];
433    var value = style[ measurement ];
434    var num = parseFloat( value );
435    // any 'auto', 'medium' value will be 0
436    size[ measurement ] = !isNaN( num ) ? num : 0;
437  }
438
439  var paddingWidth = size.paddingLeft + size.paddingRight;
440  var paddingHeight = size.paddingTop + size.paddingBottom;
441  var marginWidth = size.marginLeft + size.marginRight;
442  var marginHeight = size.marginTop + size.marginBottom;
443  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
444  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
445
446  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
447
448  // overwrite width and height if we can get it from style
449  var styleWidth = getStyleSize( style.width );
450  if ( styleWidth !== false ) {
451    size.width = styleWidth +
452      // add padding and border unless it's already including it
453      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
454  }
455
456  var styleHeight = getStyleSize( style.height );
457  if ( styleHeight !== false ) {
458    size.height = styleHeight +
459      // add padding and border unless it's already including it
460      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
461  }
462
463  size.innerWidth = size.width - ( paddingWidth + borderWidth );
464  size.innerHeight = size.height - ( paddingHeight + borderHeight );
465
466  size.outerWidth = size.width + marginWidth;
467  size.outerHeight = size.height + marginHeight;
468
469  return size;
470}
471
472return getSize;
473
474});
475
476/**
477 * matchesSelector v2.0.2
478 * matchesSelector( element, '.selector' )
479 * MIT license
480 */
481
482/*jshint browser: true, strict: true, undef: true, unused: true */
483
484( function( window, factory ) {
485  /*global define: false, module: false */
486  'use strict';
487  // universal module definition
488  if ( typeof define == 'function' && define.amd ) {
489    // AMD
490    define( 'desandro-matches-selector/matches-selector',factory );
491  } else if ( typeof module == 'object' && module.exports ) {
492    // CommonJS
493    module.exports = factory();
494  } else {
495    // browser global
496    window.matchesSelector = factory();
497  }
498
499}( window, function factory() {
500  'use strict';
501
502  var matchesMethod = ( function() {
503    var ElemProto = window.Element.prototype;
504    // check for the standard method name first
505    if ( ElemProto.matches ) {
506      return 'matches';
507    }
508    // check un-prefixed
509    if ( ElemProto.matchesSelector ) {
510      return 'matchesSelector';
511    }
512    // check vendor prefixes
513    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
514
515    for ( var i=0; i < prefixes.length; i++ ) {
516      var prefix = prefixes[i];
517      var method = prefix + 'MatchesSelector';
518      if ( ElemProto[ method ] ) {
519        return method;
520      }
521    }
522  })();
523
524  return function matchesSelector( elem, selector ) {
525    return elem[ matchesMethod ]( selector );
526  };
527
528}));
529
530/**
531 * Fizzy UI utils v2.0.5
532 * MIT license
533 */
534
535/*jshint browser: true, undef: true, unused: true, strict: true */
536
537( function( window, factory ) {
538  // universal module definition
539  /*jshint strict: false */ /*globals define, module, require */
540
541  if ( typeof define == 'function' && define.amd ) {
542    // AMD
543    define( 'fizzy-ui-utils/utils',[
544      'desandro-matches-selector/matches-selector'
545    ], function( matchesSelector ) {
546      return factory( window, matchesSelector );
547    });
548  } else if ( typeof module == 'object' && module.exports ) {
549    // CommonJS
550    module.exports = factory(
551      window,
552      require('desandro-matches-selector')
553    );
554  } else {
555    // browser global
556    window.fizzyUIUtils = factory(
557      window,
558      window.matchesSelector
559    );
560  }
561
562}( window, function factory( window, matchesSelector ) {
563
564
565
566var utils = {};
567
568// ----- extend ----- //
569
570// extends objects
571utils.extend = function( a, b ) {
572  for ( var prop in b ) {
573    a[ prop ] = b[ prop ];
574  }
575  return a;
576};
577
578// ----- modulo ----- //
579
580utils.modulo = function( num, div ) {
581  return ( ( num % div ) + div ) % div;
582};
583
584// ----- makeArray ----- //
585
586// turn element or nodeList into an array
587utils.makeArray = function( obj ) {
588  var ary = [];
589  if ( Array.isArray( obj ) ) {
590    // use object if already an array
591    ary = obj;
592  } else if ( obj && typeof obj == 'object' &&
593    typeof obj.length == 'number' ) {
594    // convert nodeList to array
595    for ( var i=0; i < obj.length; i++ ) {
596      ary.push( obj[i] );
597    }
598  } else {
599    // array of single index
600    ary.push( obj );
601  }
602  return ary;
603};
604
605// ----- removeFrom ----- //
606
607utils.removeFrom = function( ary, obj ) {
608  var index = ary.indexOf( obj );
609  if ( index != -1 ) {
610    ary.splice( index, 1 );
611  }
612};
613
614// ----- getParent ----- //
615
616utils.getParent = function( elem, selector ) {
617  while ( elem.parentNode && elem != document.body ) {
618    elem = elem.parentNode;
619    if ( matchesSelector( elem, selector ) ) {
620      return elem;
621    }
622  }
623};
624
625// ----- getQueryElement ----- //
626
627// use element as selector string
628utils.getQueryElement = function( elem ) {
629  if ( typeof elem == 'string' ) {
630    return document.querySelector( elem );
631  }
632  return elem;
633};
634
635// ----- handleEvent ----- //
636
637// enable .ontype to trigger from .addEventListener( elem, 'type' )
638utils.handleEvent = function( event ) {
639  var method = 'on' + event.type;
640  if ( this[ method ] ) {
641    this[ method ]( event );
642  }
643};
644
645// ----- filterFindElements ----- //
646
647utils.filterFindElements = function( elems, selector ) {
648  // make array of elems
649  elems = utils.makeArray( elems );
650  var ffElems = [];
651

652  elems.forEach( function( elem ) {
653    // check that elem is an actual element
654    if ( !( elem instanceof HTMLElement ) ) {
655      return;
656    }
657    // add elem if no selector
658    if ( !selector ) {
659      ffElems.push( elem );
660      return;
661    }
662    // filter & find items if we have a selector
663    // filter
664    if ( matchesSelector( elem, selector ) ) {
665      ffElems.push( elem );
666    }
667    // find children
668    var childElems = elem.querySelectorAll( selector );
669    // concat childElems to filterFound array
670    for ( var i=0; i < childElems.length; i++ ) {
671      ffElems.push( childElems[i] );
672    }
673  });
674
675  return ffElems;
676};
677
678// ----- debounceMethod ----- //
679
680utils.debounceMethod = function( _class, methodName, threshold ) {
681  // original method
682  var method = _class.prototype[ methodName ];
683  var timeoutName = methodName + 'Timeout';
684
685  _class.prototype[ methodName ] = function() {
686    var timeout = this[ timeoutName ];
687    if ( timeout ) {
688      clearTimeout( timeout );
689    }
690    var args = arguments;
691
692    var _this = this;
693    this[ timeoutName ] = setTimeout( function() {
694      method.apply( _this, args );
695      delete _this[ timeoutName ];
696    }, threshold || 100 );
697  };
698};
699
700// ----- docReady ----- //
701
702utils.docReady = function( callback ) {
703  var readyState = document.readyState;
704  if ( readyState == 'complete' || readyState == 'interactive' ) {
705    // do async to allow for other scripts to run. metafizzy/flickity#441
706    setTimeout( callback );
707  } else {
708    document.addEventListener( 'DOMContentLoaded', callback );
709  }
710};
711
712// ----- htmlInit ----- //
713
714// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
715utils.toDashed = function( str ) {
716  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
717    return $1 + '-' + $2;
718  }).toLowerCase();
719};
720
721var console = window.console;
722/**
723 * allow user to initialize classes via [data-namespace] or .js-namespace class
724 * htmlInit( Widget, 'widgetName' )
725 * options are parsed from data-namespace-options
726 */
727utils.htmlInit = function( WidgetClass, namespace ) {
728  utils.docReady( function() {
729    var dashedNamespace = utils.toDashed( namespace );
730    var dataAttr = 'data-' + dashedNamespace;
731    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
732    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
733    var elems = utils.makeArray( dataAttrElems )
734      .concat( utils.makeArray( jsDashElems ) );
735    var dataOptionsAttr = dataAttr + '-options';
736    var jQuery = window.jQuery;
737
738    elems.forEach( function( elem ) {
739      var attr = elem.getAttribute( dataAttr ) ||
740        elem.getAttribute( dataOptionsAttr );
741      var options;
742      try {
743        options = attr && JSON.parse( attr );
744      } catch ( error ) {
745        // log error, do not initialize
746        if ( console ) {
747          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
748          ': ' + error );
749        }
750        return;
751      }
752      // initialize
753      var instance = new WidgetClass( elem, options );
754      // make available via $().data('namespace')
755      if ( jQuery ) {
756        jQuery.data( elem, namespace, instance );
757      }
758    });
759
760  });
761};
762
763// -----  ----- //
764
765return utils;
766
767}));
768
769// Flickity.Cell
770( function( window, factory ) {
771  // universal module definition
772  /* jshint strict: false */
773  if ( typeof define == 'function' && define.amd ) {
774    // AMD
775    define( 'flickity/js/cell',[
776      'get-size/get-size'
777    ], function( getSize ) {
778      return factory( window, getSize );
779    });
780  } else if ( typeof module == 'object' && module.exports ) {
781    // CommonJS
782    module.exports = factory(
783      window,
784      require('get-size')
785    );
786  } else {
787    // browser global
788    window.Flickity = window.Flickity || {};
789    window.Flickity.Cell = factory(
790      window,
791      window.getSize
792    );
793  }
794
795}( window, function factory( window, getSize ) {
796
797
798
799function Cell( elem, parent ) {
800  this.element = elem;
801  this.parent = parent;
802
803  this.create();
804}
805
806var proto = Cell.prototype;
807
808proto.create = function() {
809  this.element.style.position = 'absolute';
810  this.x = 0;
811  this.shift = 0;
812};
813
814proto.destroy = function() {
815  // reset style
816  this.element.style.position = '';
817  var side = this.parent.originSide;
818  this.element.style[ side ] = '';
819};
820
821proto.getSize = function() {
822  this.size = getSize( this.element );
823};
824
825proto.setPosition = function( x ) {
826  this.x = x;
827  this.updateTarget();
828  this.renderPosition( x );
829};
830
831// setDefaultTarget v1 method, backwards compatibility, remove in v3
832proto.updateTarget = proto.setDefaultTarget = function() {
833  var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight';
834  this.target = this.x + this.size[ marginProperty ] +
835    this.size.width * this.parent.cellAlign;
836};
837
838proto.renderPosition = function( x ) {
839  // render position of cell with in slider
840  var side = this.parent.originSide;
841  this.element.style[ side ] = this.parent.getPositionValue( x );
842};
843
844/**
845 * @param {Integer} factor - 0, 1, or -1
846**/
847proto.wrapShift = function( shift ) {
848  this.shift = shift;
849  this.renderPosition( this.x + this.parent.slideableWidth * shift );
850};
851
852proto.remove = function() {
853  this.element.parentNode.removeChild( this.element );
854};
855
856return Cell;
857
858}));
859
860// slide
861( function( window, factory ) {
862  // universal module definition
863  /* jshint strict: false */
864  if ( typeof define == 'function' && define.amd ) {
865    // AMD
866    define( 'flickity/js/slide',factory );
867  } else if ( typeof module == 'object' && module.exports ) {
868    // CommonJS
869    module.exports = factory();
870  } else {
871    // browser global
872    window.Flickity = window.Flickity || {};
873    window.Flickity.Slide = factory();
874  }
875
876}( window, function factory() {
877'use strict';
878
879function Slide( parent ) {
880  this.parent = parent;
881  this.isOriginLeft = parent.originSide == 'left';
882  this.cells = [];
883  this.outerWidth = 0;
884  this.height = 0;
885}
886
887var proto = Slide.prototype;
888
889proto.addCell = function( cell ) {
890  this.cells.push( cell );
891  this.outerWidth += cell.size.outerWidth;
892  this.height = Math.max( cell.size.outerHeight, this.height );
893  // first cell stuff
894  if ( this.cells.length == 1 ) {
895    this.x = cell.x; // x comes from first cell
896    var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight';
897    this.firstMargin = cell.size[ beginMargin ];
898  }
899};
900
901proto.updateTarget = function() {
902  var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft';
903  var lastCell = this.getLastCell();
904  var lastMargin = lastCell ? lastCell.size[ endMargin ] : 0;
905  var slideWidth = this.outerWidth - ( this.firstMargin + lastMargin );
906  this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign;
907};
908
909proto.getLastCell = function() {
910  return this.cells[ this.cells.length - 1 ];
911};
912
913proto.select = function() {
914  this.changeSelectedClass('add');
915};
916
917proto.unselect = function() {
918  this.changeSelectedClass('remove');
919};
920
921proto.changeSelectedClass = function( method ) {

922  this.cells.forEach( function( cell ) {
923    cell.element.classList[ method ]('is-selected');
924  });
925};
926
927proto.getCellElements = function() {
928  return this.cells.map( function( cell ) {
929    return cell.element;
930  });
931};
932
933return Slide;
934
935}));
936
937// animate
938( function( window, factory ) {
939  // universal module definition
940  /* jshint strict: false */
941  if ( typeof define == 'function' && define.amd ) {
942    // AMD
943    define( 'flickity/js/animate',[
944      'fizzy-ui-utils/utils'
945    ], function( utils ) {
946      return factory( window, utils );
947    });
948  } else if ( typeof module == 'object' && module.exports ) {
949    // CommonJS
950    module.exports = factory(
951      window,
952      require('fizzy-ui-utils')
953    );
954  } else {
955    // browser global
956    window.Flickity = window.Flickity || {};
957    window.Flickity.animatePrototype = factory(
958      window,
959      window.fizzyUIUtils
960    );
961  }
962
963}( window, function factory( window, utils ) {
964
965
966
967// -------------------------- requestAnimationFrame -------------------------- //
968
969// get rAF, prefixed, if present
970var requestAnimationFrame = window.requestAnimationFrame ||
971  window.webkitRequestAnimationFrame;
972
973// fallback to setTimeout
974var lastTime = 0;
975if ( !requestAnimationFrame )  {
976  requestAnimationFrame = function( callback ) {
977    var currTime = new Date().getTime();
978    var timeToCall = Math.max( 0, 16 - ( currTime - lastTime ) );
979    var id = setTimeout( callback, timeToCall );
980    lastTime = currTime + timeToCall;
981    return id;
982  };
983}
984
985// -------------------------- animate -------------------------- //
986
987var proto = {};
988
989proto.startAnimation = function() {
990  if ( this.isAnimating ) {
991    return;
992  }
993
994  this.isAnimating = true;
995  this.restingFrames = 0;
996  this.animate();
997};
998
999proto.animate = function() {
1000  this.applyDragForce();
1001  this.applySelectedAttraction();
1002
1003  var previousX = this.x;
1004
1005  this.integratePhysics();
1006  this.positionSlider();
1007  this.settle( previousX );
1008  // animate next frame
1009  if ( this.isAnimating ) {
1010    var _this = this;
1011    requestAnimationFrame( function animateFrame() {
1012      _this.animate();
1013    });
1014  }
1015};
1016
1017
1018var transformProperty = ( function () {
1019  var style = document.documentElement.style;
1020  if ( typeof style.transform == 'string' ) {
1021    return 'transform';
1022  }
1023  return 'WebkitTransform';
1024})();
1025
1026proto.positionSlider = function() {
1027  var x = this.x;
1028  // wrap position around
1029  if ( this.options.wrapAround && this.cells.length > 1 ) {
1030    x = utils.modulo( x, this.slideableWidth );
1031    x = x - this.slideableWidth;
1032    this.shiftWrapCells( x );
1033  }
1034
1035  x = x + this.cursorPosition;
1036  // reverse if right-to-left and using transform
1037  x = this.options.rightToLeft && transformProperty ? -x : x;
1038  var value = this.getPositionValue( x );
1039  // use 3D tranforms for hardware acceleration on iOS
1040  // but use 2D when settled, for better font-rendering
1041  this.slider.style[ transformProperty ] = this.isAnimating ?
1042    'translate3d(' + value + ',0,0)' : 'translateX(' + value + ')';
1043
1044  // scroll event
1045  var firstSlide = this.slides[0];
1046  if ( firstSlide ) {
1047    var positionX = -this.x - firstSlide.target;
1048    var progress = positionX / this.slidesWidth;
1049    this.dispatchEvent( 'scroll', null, [ progress, positionX ] );
1050  }
1051};
1052
1053proto.positionSliderAtSelected = function() {
1054  if ( !this.cells.length ) {
1055    return;
1056  }
1057  this.x = -this.selectedSlide.target;
1058  this.positionSlider();
1059};
1060
1061proto.getPositionValue = function( position ) {
1062  if ( this.options.percentPosition ) {
1063    // percent position, round to 2 digits, like 12.34%
1064    return ( Math.round( ( position / this.size.innerWidth ) * 10000 ) * 0.01 )+ '%';
1065  } else {
1066    // pixel positioning
1067    return Math.round( position ) + 'px';
1068  }
1069};
1070
1071proto.settle = function( previousX ) {
1072  // keep track of frames where x hasn't moved
1073  if ( !this.isPointerDown && Math.round( this.x * 100 ) == Math.round( previousX * 100 ) ) {
1074    this.restingFrames++;
1075  }
1076  // stop animating if resting for 3 or more frames
1077  if ( this.restingFrames > 2 ) {
1078    this.isAnimating = false;
1079    delete this.isFreeScrolling;
1080    // render position with translateX when settled
1081    this.positionSlider();
1082    this.dispatchEvent('settle');
1083  }
1084};
1085
1086proto.shiftWrapCells = function( x ) {
1087  // shift before cells
1088  var beforeGap = this.cursorPosition + x;
1089  this._shiftCells( this.beforeShiftCells, beforeGap, -1 );
1090  // shift after cells
1091  var afterGap = this.size.innerWidth - ( x + this.slideableWidth + this.cursorPosition );
1092  this._shiftCells( this.afterShiftCells, afterGap, 1 );
1093};
1094
1095proto._shiftCells = function( cells, gap, shift ) {
1096  for ( var i=0; i < cells.length; i++ ) {
1097    var cell = cells[i];
1098    var cellShift = gap > 0 ? shift : 0;
1099    cell.wrapShift( cellShift );
1100    gap -= cell.size.outerWidth;
1101  }
1102};
1103
1104proto._unshiftCells = function( cells ) {
1105  if ( !cells || !cells.length ) {
1106    return;
1107  }
1108  for ( var i=0; i < cells.length; i++ ) {
1109    cells[i].wrapShift( 0 );
1110  }
1111};
1112
1113// -------------------------- physics -------------------------- //
1114
1115proto.integratePhysics = function() {
1116  this.x += this.velocity;
1117  this.velocity *= this.getFrictionFactor();
1118};
1119
1120proto.applyForce = function( force ) {
1121  this.velocity += force;
1122};
1123
1124proto.getFrictionFactor = function() {
1125  return 1 - this.options[ this.isFreeScrolling ? 'freeScrollFriction' : 'friction' ];
1126};
1127
1128proto.getRestingPosition = function() {
1129  // my thanks to Steven Wittens, who simplified this math greatly
1130  return this.x + this.velocity / ( 1 - this.getFrictionFactor() );
1131};
1132
1133proto.applyDragForce = function() {
1134  if ( !this.isPointerDown ) {
1135    return;
1136  }
1137  // change the position to drag position by applying force
1138  var dragVelocity = this.dragX - this.x;
1139  var dragForce = dragVelocity - this.velocity;
1140  this.applyForce( dragForce );
1141};
1142
1143proto.applySelectedAttraction = function() {
1144  // do not attract if pointer down or no cells
1145  if ( this.isPointerDown || this.isFreeScrolling || !this.cells.length ) {
1146    return;
1147  }
1148  var distance = this.selectedSlide.target * -1 - this.x;
1149  var force = distance * this.options.selectedAttraction;
1150  this.applyForce( force );
1151};
1152
1153return proto;
1154
1155}));
1156
1157// Flickity main
1158( function( window, factory ) {
1159  // universal module definition
1160  /* jshint strict: false */
1161  if ( typeof define == 'function' && define.amd ) {
1162    // AMD
1163    define( 'flickity/js/flickity',[
1164      'ev-emitter/ev-emitter',
1165      'get-size/get-size',
1166      'fizzy-ui-utils/utils',
1167      './cell',
1168      './slide',
1169      './animate'
1170    ], function( EvEmitter, getSize, utils, Cell, Slide, animatePrototype ) {
1171      return factory( window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype );
1172    });
1173  } else if ( typeof module == 'object' && module.exports ) {
1174    // CommonJS
1175    module.exports = factory(
1176      window,
1177      require('ev-emitter'),
1178      require('get-size'),
1179      require('fizzy-ui-utils'),
1180      require('./cell'),
1181      require('./slide'),
1182      require('./animate')
1183    );
1184  } else {
1185    // browser global
1186    var _Flickity = window.Flickity;
1187
1188    window.Flickity = factory(
1189      window,
1190      window.EvEmitter,
1191      window.getSize,
1192      window.fizzyUIUtils,
1193      _Flickity.Cell,
1194      _Flickity.Slide,
1195      _Flickity.animatePrototype
1196    );
1197  }
1198
1199}( window, function factory( window, EvEmitter, getSize,
1200  utils, Cell, Slide, animatePrototype ) {
1201
1202
1203
1204// vars
1205var jQuery = window.jQuery;
1206var getComputedStyle = window.getComputedStyle;
1207var console = window.console;
1208
1209function moveElements( elems, toElem ) {
1210  elems = utils.makeArray( elems );
1211  while ( elems.length ) {
1212    toElem.appendChild( elems.shift() );
1213  }
1214}
1215
1216// -------------------------- Flickity -------------------------- //
1217
1218// globally unique identifiers
1219var GUID = 0;
1220// internal store of all Flickity intances
1221var instances = {};
1222
1223function Flickity( element, options ) {
1224  var queryElement = utils.getQueryElement( element );
1225  if ( !queryElement ) {
1226    if ( console ) {
1227      console.error( 'Bad element for Flickity: ' + ( queryElement || element ) );
1228    }
1229    return;
1230  }
1231  this.element = queryElement;
1232  // do not initialize twice on same element
1233  if ( this.element.flickityGUID ) {
1234    var instance = instances[ this.element.flickityGUID ];
1235    instance.option( options );
1236    return instance;
1237  }
1238
1239  // add jQuery
1240  if ( jQuery ) {
1241    this.$element = jQuery( this.element );
1242  }
1243  // options
1244  this.options = utils.extend( {}, this.constructor.defaults );
1245  this.option( options );
1246
1247  // kick things off
1248  this._create();
1249}
1250
1251Flickity.defaults = {
1252  accessibility: true,
1253  // adaptiveHeight: false,
1254  cellAlign: 'center',
1255  // cellSelector: undefined,

1256  // contain: false,
1257  freeScrollFriction: 0.075, // friction when free-scrolling
1258  friction: 0.28, // friction when selecting
1259  namespaceJQueryEvents: true,
1260  // initialIndex: 0,
1261  percentPosition: true,
1262  resize: true,
1263  selectedAttraction: 0.025,
1264  setGallerySize: true
1265  // watchCSS: false,
1266  // wrapAround: false
1267};
1268
1269// hash of methods triggered on _create()
1270Flickity.createMethods = [];
1271
1272var proto = Flickity.prototype;
1273// inherit EventEmitter
1274utils.extend( proto, EvEmitter.prototype );
1275
1276proto._create = function() {
1277  // add id for Flickity.data
1278  var id = this.guid = ++GUID;
1279  this.element.flickityGUID = id; // expando
1280  instances[ id ] = this; // associate via id
1281  // initial properties
1282  this.selectedIndex = 0;
1283  // how many frames slider has been in same position
1284  this.restingFrames = 0;
1285  // initial physics properties
1286  this.x = 0;
1287  this.velocity = 0;
1288  this.originSide = this.options.rightToLeft ? 'right' : 'left';
1289  // create viewport & slider
1290  this.viewport = document.createElement('div');
1291  this.viewport.className = 'flickity-viewport';
1292  this._createSlider();
1293
1294  if ( this.options.resize || this.options.watchCSS ) {
1295    window.addEventListener( 'resize', this );
1296  }
1297
1298  Flickity.createMethods.forEach( function( method ) {
1299    this[ method ]();
1300  }, this );
1301
1302  if ( this.options.watchCSS ) {
1303    this.watchCSS();
1304  } else {
1305    this.activate();
1306  }
1307
1308};
1309
1310/**
1311 * set options
1312 * @param {Object} opts
1313 */
1314proto.option = function( opts ) {
1315  utils.extend( this.options, opts );
1316};
1317
1318proto.activate = function() {
1319  if ( this.isActive ) {
1320    return;
1321  }
1322  this.isActive = true;
1323  this.element.classList.add('flickity-enabled');
1324  if ( this.options.rightToLeft ) {
1325    this.element.classList.add('flickity-rtl');
1326  }
1327
1328  this.getSize();
1329  // move initial cell elements so they can be loaded as cells
1330  var cellElems = this._filterFindCellElements( this.element.children );
1331  moveElements( cellElems, this.slider );
1332  this.viewport.appendChild( this.slider );
1333  this.element.appendChild( this.viewport );
1334  // get cells from children
1335  this.reloadCells();
1336
1337  if ( this.options.accessibility ) {
1338    // allow element to focusable
1339    this.element.tabIndex = 0;
1340    // listen for key presses
1341    this.element.addEventListener( 'keydown', this );
1342  }
1343
1344  this.emitEvent('activate');
1345
1346  var index;
1347  var initialIndex = this.options.initialIndex;
1348  if ( this.isInitActivated ) {
1349    index = this.selectedIndex;
1350  } else if ( initialIndex !== undefined ) {
1351    index = this.cells[ initialIndex ] ? initialIndex : 0;
1352  } else {
1353    index = 0;
1354  }
1355  // select instantly
1356  this.select( index, false, true );
1357  // flag for initial activation, for using initialIndex
1358  this.isInitActivated = true;
1359};
1360
1361// slider positions the cells
1362proto._createSlider = function() {
1363  // slider element does all the positioning
1364  var slider = document.createElement('div');
1365  slider.className = 'flickity-slider';
1366  slider.style[ this.originSide ] = 0;
1367  this.slider = slider;
1368};
1369
1370proto._filterFindCellElements = function( elems ) {
1371  return utils.filterFindElements( elems, this.options.cellSelector );
1372};
1373
1374// goes through all children
1375proto.reloadCells = function() {
1376  // collection of item elements
1377  this.cells = this._makeCells( this.slider.children );
1378  this.positionCells();
1379  this._getWrapShiftCells();
1380  this.setGallerySize();
1381};
1382
1383/**
1384 * turn elements into Flickity.Cells
1385 * @param {Array or NodeList or HTMLElement} elems
1386 * @returns {Array} items - collection of new Flickity Cells
1387 */
1388proto._makeCells = function( elems ) {
1389  var cellElems = this._filterFindCellElements( elems );
1390
1391  // create new Flickity for collection
1392  var cells = cellElems.map( function( cellElem ) {
1393    return new Cell( cellElem, this );
1394  }, this );
1395
1396  return cells;
1397};
1398
1399proto.getLastCell = function() {
1400  return this.cells[ this.cells.length - 1 ];
1401};
1402
1403proto.getLastSlide = function() {
1404  return this.slides[ this.slides.length - 1 ];
1405};
1406
1407// positions all cells
1408proto.positionCells = function() {
1409  // size all cells
1410  this._sizeCells( this.cells );
1411  // position all cells
1412  this._positionCells( 0 );
1413};
1414
1415/**
1416 * position certain cells
1417 * @param {Integer} index - which cell to start with
1418 */
1419proto._positionCells = function( index ) {
1420  index = index || 0;
1421  // also measure maxCellHeight
1422  // start 0 if positioning all cells
1423  this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
1424  var cellX = 0;
1425  // get cellX
1426  if ( index > 0 ) {
1427    var startCell = this.cells[ index - 1 ];
1428    cellX = startCell.x + startCell.size.outerWidth;
1429  }
1430  var len = this.cells.length;
1431  for ( var i=index; i < len; i++ ) {
1432    var cell = this.cells[i];
1433    cell.setPosition( cellX );
1434    cellX += cell.size.outerWidth;
1435    this.maxCellHeight = Math.max( cell.size.outerHeight, this.maxCellHeight );
1436  }
1437  // keep track of cellX for wrap-around
1438  this.slideableWidth = cellX;
1439  // slides
1440  this.updateSlides();
1441  // contain slides target
1442  this._containSlides();
1443  // update slidesWidth
1444  this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0;
1445};
1446
1447/**
1448 * cell.getSize() on multiple cells
1449 * @param {Array} cells
1450 */
1451proto._sizeCells = function( cells ) {

1452  cells.forEach( function( cell ) {
1453    cell.getSize();
1454  });
1455};
1456
1457// --------------------------  -------------------------- //
1458
1459proto.updateSlides = function() {
1460  this.slides = [];
1461  if ( !this.cells.length ) {
1462    return;
1463  }
1464
1465  var slide = new Slide( this );
1466  this.slides.push( slide );
1467  var isOriginLeft = this.originSide == 'left';
1468  var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
1469
1470  var canCellFit = this._getCanCellFit();
1471
1472  this.cells.forEach( function( cell, i ) {
1473    // just add cell if first cell in slide
1474    if ( !slide.cells.length ) {
1475      slide.addCell( cell );
1476      return;
1477    }
1478
1479    var slideWidth = ( slide.outerWidth - slide.firstMargin ) +
1480      ( cell.size.outerWidth - cell.size[ nextMargin ] );
1481
1482    if ( canCellFit.call( this, i, slideWidth ) ) {
1483      slide.addCell( cell );
1484    } else {
1485      // doesn't fit, new slide
1486      slide.updateTarget();
1487
1488      slide = new Slide( this );
1489      this.slides.push( slide );
1490      slide.addCell( cell );
1491    }
1492  }, this );
1493  // last slide
1494  slide.updateTarget();
1495  // update .selectedSlide
1496  this.updateSelectedSlide();
1497};
1498
1499proto._getCanCellFit = function() {
1500  var groupCells = this.options.groupCells;
1501  if ( !groupCells ) {
1502    return function() {
1503      return false;
1504    };
1505  } else if ( typeof groupCells == 'number' ) {
1506    // group by number. 3 -> [0,1,2], [3,4,5], ...
1507    var number = parseInt( groupCells, 10 );
1508    return function( i ) {
1509      return ( i % number ) !== 0;
1510    };
1511  }
1512  // default, group by width of slide
1513  // parse '75%
1514  var percentMatch = typeof groupCells == 'string' &&
1515    groupCells.match(/^(\d+)%$/);
1516  var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1;
1517  return function( i, slideWidth ) {
1518    return slideWidth <= ( this.size.innerWidth + 1 ) * percent;
1519  };
1520};
1521
1522// alias _init for jQuery plugin .flickity()
1523proto._init =
1524proto.reposition = function() {
1525  this.positionCells();
1526  this.positionSliderAtSelected();
1527};
1528
1529proto.getSize = function() {
1530  this.size = getSize( this.element );
1531  this.setCellAlign();
1532  this.cursorPosition = this.size.innerWidth * this.cellAlign;
1533};
1534
1535var cellAlignShorthands = {
1536  // cell align, then based on origin side
1537  center: {
1538    left: 0.5,
1539    right: 0.5
1540  },
1541  left: {
1542    left: 0,
1543    right: 1
1544  },
1545  right: {
1546    right: 0,
1547    left: 1
1548  }
1549};
1550
1551proto.setCellAlign = function() {
1552  var shorthand = cellAlignShorthands[ this.options.cellAlign ];
1553  this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign;
1554};
1555
1556proto.setGallerySize = function() {
1557  if ( this.options.setGallerySize ) {
1558    var height = this.options.adaptiveHeight && this.selectedSlide ?
1559      this.selectedSlide.height : this.maxCellHeight;
1560    this.viewport.style.height = height + 'px';
1561  }
1562};
1563
1564proto._getWrapShiftCells = function() {
1565  // only for wrap-around
1566  if ( !this.options.wrapAround ) {
1567    return;
1568  }
1569  // unshift previous cells
1570  this._unshiftCells( this.beforeShiftCells );
1571  this._unshiftCells( this.afterShiftCells );
1572  // get before cells
1573  // initial gap
1574  var gapX = this.cursorPosition;
1575  var cellIndex = this.cells.length - 1;
1576  this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 );
1577  // get after cells
1578  // ending gap between last cell and end of gallery viewport
1579  gapX = this.size.innerWidth - this.cursorPosition;
1580  // start cloning at first cell, working forwards
1581  this.afterShiftCells = this._getGapCells( gapX, 0, 1 );
1582};
1583
1584proto._getGapCells = function( gapX, cellIndex, increment ) {
1585  // keep adding cells until the cover the initial gap
1586  var cells = [];
1587  while ( gapX > 0 ) {
1588    var cell = this.cells[ cellIndex ];
1589    if ( !cell ) {
1590      break;
1591    }
1592    cells.push( cell );
1593    cellIndex += increment;
1594    gapX -= cell.size.outerWidth;
1595  }
1596  return cells;
1597};
1598
1599// ----- contain ----- //
1600
1601// contain cell targets so no excess sliding
1602proto._containSlides = function() {
1603  if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) {
1604    return;
1605  }
1606  var isRightToLeft = this.options.rightToLeft;
1607  var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
1608  var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
1609  var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ];
1610  // content is less than gallery size
1611  var isContentSmaller = contentWidth < this.size.innerWidth;
1612  // bounds
1613  var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ];
1614  var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign );
1615  // contain each cell target

1616  this.slides.forEach( function( slide ) {
1617    if ( isContentSmaller ) {
1618      // all cells fit inside gallery
1619      slide.target = contentWidth * this.cellAlign;
1620    } else {
1621      // contain to bounds
1622      slide.target = Math.max( slide.target, beginBound );
1623      slide.target = Math.min( slide.target, endBound );
1624    }
1625  }, this );
1626};
1627
1628// -----  ----- //
1629
1630/**
1631 * emits events via eventEmitter and jQuery events
1632 * @param {String} type - name of event
1633 * @param {Event} event - original event
1634 * @param {Array} args - extra arguments
1635 */
1636proto.dispatchEvent = function( type, event, args ) {
1637  var emitArgs = event ? [ event ].concat( args ) : args;
1638  this.emitEvent( type, emitArgs );
1639
1640  if ( jQuery && this.$element ) {
1641    // default trigger with type if no event
1642    type += this.options.namespaceJQueryEvents ? '.flickity' : '';
1643    var $event = type;
1644    if ( event ) {
1645      // create jQuery event
1646      var jQEvent = jQuery.Event( event );
1647      jQEvent.type = type;
1648      $event = jQEvent;
1649    }
1650    this.$element.trigger( $event, args );
1651  }
1652};
1653
1654// -------------------------- select -------------------------- //
1655
1656/**
1657 * @param {Integer} index - index of the slide
1658 * @param {Boolean} isWrap - will wrap-around to last/first if at the end
1659 * @param {Boolean} isInstant - will immediately set position at selected cell
1660 */
1661proto.select = function( index, isWrap, isInstant ) {
1662  if ( !this.isActive ) {
1663    return;
1664  }
1665  index = parseInt( index, 10 );
1666  this._wrapSelect( index );
1667
1668  if ( this.options.wrapAround || isWrap ) {
1669    index = utils.modulo( index, this.slides.length );
1670  }
1671  // bail if invalid index
1672  if ( !this.slides[ index ] ) {
1673    return;
1674  }
1675  this.selectedIndex = index;
1676  this.updateSelectedSlide();
1677  if ( isInstant ) {
1678    this.positionSliderAtSelected();
1679  } else {
1680    this.startAnimation();
1681  }
1682  if ( this.options.adaptiveHeight ) {
1683    this.setGallerySize();
1684  }
1685
1686  this.dispatchEvent('select');
1687  // old v1 event name, remove in v3
1688  this.dispatchEvent('cellSelect');
1689};
1690
1691// wraps position for wrapAround, to move to closest slide. #113
1692proto._wrapSelect = function( index ) {
1693  var len = this.slides.length;
1694  var isWrapping = this.options.wrapAround && len > 1;
1695  if ( !isWrapping ) {
1696    return index;
1697  }
1698  var wrapIndex = utils.modulo( index, len );
1699  // go to shortest
1700  var delta = Math.abs( wrapIndex - this.selectedIndex );
1701  var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex );
1702  var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex );
1703  if ( !this.isDragSelect && backWrapDelta < delta ) {
1704    index += len;
1705  } else if ( !this.isDragSelect && forewardWrapDelta < delta ) {
1706    index -= len;
1707  }
1708  // wrap position so slider is within normal area
1709  if ( index < 0 ) {
1710    this.x -= this.slideableWidth;
1711  } else if ( index >= len ) {
1712    this.x += this.slideableWidth;
1713  }
1714};
1715
1716proto.previous = function( isWrap, isInstant ) {
1717  this.select( this.selectedIndex - 1, isWrap, isInstant );
1718};
1719
1720proto.next = function( isWrap, isInstant ) {
1721  this.select( this.selectedIndex + 1, isWrap, isInstant );
1722};
1723
1724proto.updateSelectedSlide = function() {
1725  var slide = this.slides[ this.selectedIndex ];
1726  // selectedIndex could be outside of slides, if triggered before resize()
1727  if ( !slide ) {
1728    return;
1729  }
1730  // unselect previous selected slide
1731  this.unselectSelectedSlide();
1732  // update new selected slide
1733  this.selectedSlide = slide;
1734  slide.select();
1735  this.selectedCells = slide.cells;
1736  this.selectedElements = slide.getCellElements();
1737  // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility
1738  // Remove in v3?
1739  this.selectedCell = slide.cells[0];
1740  this.selectedElement = this.selectedElements[0];
1741};
1742
1743proto.unselectSelectedSlide = function() {
1744  if ( this.selectedSlide ) {
1745    this.selectedSlide.unselect();
1746  }
1747};
1748
1749/**
1750 * select slide from number or cell element
1751 * @param {Element or Number} elem
1752 */
1753proto.selectCell = function( value, isWrap, isInstant ) {
1754  // get cell
1755  var cell;
1756  if ( typeof value == 'number' ) {
1757    cell = this.cells[ value ];
1758  } else {
1759    // use string as selector
1760    if ( typeof value == 'string' ) {
1761      value = this.element.querySelector( value );
1762    }
1763    // get cell from element
1764    cell = this.getCell( value );
1765  }
1766  // select slide that has cell
1767  for ( var i=0; cell && i < this.slides.length; i++ ) {
1768    var slide = this.slides[i];
1769    var index = slide.cells.indexOf( cell );
1770    if ( index != -1 ) {
1771      this.select( i, isWrap, isInstant );
1772      return;
1773    }
1774  }
1775};
1776
1777// -------------------------- get cells -------------------------- //
1778
1779/**
1780 * get Flickity.Cell, given an Element
1781 * @param {Element} elem
1782 * @returns {Flickity.Cell} item
1783 */
1784proto.getCell = function( elem ) {
1785  // loop through cells to get the one that matches
1786  for ( var i=0; i < this.cells.length; i++ ) {
1787    var cell = this.cells[i];
1788    if ( cell.element == elem ) {
1789      return cell;
1790    }
1791  }
1792};
1793
1794/**
1795 * get collection of Flickity.Cells, given Elements
1796 * @param {Element, Array, NodeList} elems
1797 * @returns {Array} cells - Flickity.Cells
1798 */
1799proto.getCells = function( elems ) {
1800  elems = utils.makeArray( elems );
1801  var cells = [];

1802  elems.forEach( function( elem ) {
1803    var cell = this.getCell( elem );
1804    if ( cell ) {
1805      cells.push( cell );
1806    }
1807  }, this );
1808  return cells;
1809};
1810
1811/**
1812 * get cell elements
1813 * @returns {Array} cellElems
1814 */
1815proto.getCellElements = function() {
1816  return this.cells.map( function( cell ) {
1817    return cell.element;
1818  });
1819};
1820
1821/**
1822 * get parent cell from an element
1823 * @param {Element} elem
1824 * @returns {Flickit.Cell} cell
1825 */
1826proto.getParentCell = function( elem ) {
1827  // first check if elem is cell
1828  var cell = this.getCell( elem );
1829  if ( cell ) {
1830    return cell;
1831  }
1832  // try to get parent cell elem
1833  elem = utils.getParent( elem, '.flickity-slider > *' );
1834  return this.getCell( elem );
1835};
1836
1837/**
1838 * get cells adjacent to a slide
1839 * @param {Integer} adjCount - number of adjacent slides
1840 * @param {Integer} index - index of slide to start
1841 * @returns {Array} cells - array of Flickity.Cells
1842 */
1843proto.getAdjacentCellElements = function( adjCount, index ) {
1844  if ( !adjCount ) {
1845    return this.selectedSlide.getCellElements();
1846  }
1847  index = index === undefined ? this.selectedIndex : index;
1848
1849  var len = this.slides.length;
1850  if ( 1 + ( adjCount * 2 ) >= len ) {
1851    return this.getCellElements();
1852  }
1853
1854  var cellElems = [];
1855  for ( var i = index - adjCount; i <= index + adjCount ; i++ ) {
1856    var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i;
1857    var slide = this.slides[ slideIndex ];
1858    if ( slide ) {
1859      cellElems = cellElems.concat( slide.getCellElements() );
1860    }
1861  }
1862  return cellElems;
1863};
1864
1865// -------------------------- events -------------------------- //
1866
1867proto.uiChange = function() {
1868  this.emitEvent('uiChange');
1869};
1870
1871proto.childUIPointerDown = function( event ) {
1872  this.emitEvent( 'childUIPointerDown', [ event ] );
1873};
1874
1875// ----- resize ----- //
1876
1877proto.onresize = function() {
1878  this.watchCSS();
1879  this.resize();
1880};
1881
1882utils.debounceMethod( Flickity, 'onresize', 150 );
1883
1884proto.resize = function() {
1885  if ( !this.isActive ) {
1886    return;
1887  }
1888  this.getSize();
1889  // wrap values
1890  if ( this.options.wrapAround ) {
1891    this.x = utils.modulo( this.x, this.slideableWidth );
1892  }
1893  this.positionCells();
1894  this._getWrapShiftCells();
1895  this.setGallerySize();
1896  this.emitEvent('resize');
1897  // update selected index for group slides, instant
1898  // TODO: position can be lost between groups of various numbers
1899  var selectedElement = this.selectedElements && this.selectedElements[0];
1900  this.selectCell( selectedElement, false, true );
1901};
1902
1903// watches the :after property, activates/deactivates
1904proto.watchCSS = function() {
1905  var watchOption = this.options.watchCSS;
1906  if ( !watchOption ) {
1907    return;
1908  }
1909
1910  var afterContent = getComputedStyle( this.element, ':after' ).content;
1911  // activate if :after { content: 'flickity' }
1912  if ( afterContent.indexOf('flickity') != -1 ) {
1913    this.activate();
1914  } else {
1915    this.deactivate();
1916  }
1917};
1918
1919// ----- keydown ----- //
1920
1921// go previous/next if left/right keys pressed
1922proto.onkeydown = function( event ) {
1923  // only work if element is in focus
1924  if ( !this.options.accessibility ||
1925    ( document.activeElement && document.activeElement != this.element ) ) {
1926    return;
1927  }
1928
1929  if ( event.keyCode == 37 ) {
1930    // go left
1931    var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
1932    this.uiChange();
1933    this[ leftMethod ]();
1934  } else if ( event.keyCode == 39 ) {
1935    // go right
1936    var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
1937    this.uiChange();
1938    this[ rightMethod ]();
1939  }
1940};
1941
1942// -------------------------- destroy -------------------------- //
1943
1944// deactivate all Flickity functionality, but keep stuff available
1945proto.deactivate = function() {
1946  if ( !this.isActive ) {
1947    return;
1948  }
1949  this.element.classList.remove('flickity-enabled');
1950  this.element.classList.remove('flickity-rtl');
1951  // destroy cells
1952  this.cells.forEach( function( cell ) {
1953    cell.destroy();
1954  });
1955  this.unselectSelectedSlide();
1956  this.element.removeChild( this.viewport );
1957  // move child elements back into element
1958  moveElements( this.slider.children, this.element );
1959  if ( this.options.accessibility ) {
1960    this.element.removeAttribute('tabIndex');
1961    this.element.removeEventListener( 'keydown', this );
1962  }
1963  // set flags
1964  this.isActive = false;

1965  this.emitEvent('deactivate');
1966};
1967
1968proto.destroy = function() {
1969  this.deactivate();
1970  window.removeEventListener( 'resize', this );
1971  this.emitEvent('destroy');
1972  if ( jQuery && this.$element ) {
1973    jQuery.removeData( this.element, 'flickity' );
1974  }
1975  delete this.element.flickityGUID;
1976  delete instances[ this.guid ];
1977};
1978
1979// -------------------------- prototype -------------------------- //
1980
1981utils.extend( proto, animatePrototype );
1982
1983// -------------------------- extras -------------------------- //
1984
1985/**
1986 * get Flickity instance from element
1987 * @param {Element} elem
1988 * @returns {Flickity}
1989 */
1990Flickity.data = function( elem ) {
1991  elem = utils.getQueryElement( elem );
1992  var id = elem && elem.flickityGUID;
1993  return id && instances[ id ];
1994};
1995
1996utils.htmlInit( Flickity, 'flickity' );
1997
1998if ( jQuery && jQuery.bridget ) {
1999  jQuery.bridget( 'flickity', Flickity );
2000}
2001
2002// set internal jQuery, for Webpack + jQuery v3, #478
2003Flickity.setJQuery = function( jq ) {
2004  jQuery = jq;
2005};
2006
2007Flickity.Cell = Cell;
2008
2009return Flickity;
2010
2011}));
2012
2013/*!
2014 * Unipointer v2.2.0
2015 * base class for doing one thing with pointer event
2016 * MIT license
2017 */
2018
2019/*jshint browser: true, undef: true, unused: true, strict: true */
2020
2021( function( window, factory ) {
2022  // universal module definition
2023  /* jshint strict: false */ /*global define, module, require */
2024  if ( typeof define == 'function' && define.amd ) {
2025    // AMD
2026    define( 'unipointer/unipointer',[
2027      'ev-emitter/ev-emitter'
2028    ], function( EvEmitter ) {
2029      return factory( window, EvEmitter );
2030    });
2031  } else if ( typeof module == 'object' && module.exports ) {
2032    // CommonJS
2033    module.exports = factory(
2034      window,
2035      require('ev-emitter')
2036    );
2037  } else {
2038    // browser global
2039    window.Unipointer = factory(
2040      window,
2041      window.EvEmitter
2042    );
2043  }
2044
2045}( window, function factory( window, EvEmitter ) {
2046
2047
2048
2049function noop() {}
2050
2051function Unipointer() {}
2052
2053// inherit EvEmitter
2054var proto = Unipointer.prototype = Object.create( EvEmitter.prototype );
2055
2056proto.bindStartEvent = function( elem ) {
2057  this._bindStartEvent( elem, true );
2058};
2059
2060proto.unbindStartEvent = function( elem ) {
2061  this._bindStartEvent( elem, false );
2062};
2063
2064/**
2065 * works as unbinder, as you can ._bindStart( false ) to unbind
2066 * @param {Boolean} isBind - will unbind if falsey
2067 */
2068proto._bindStartEvent = function( elem, isBind ) {
2069  // munge isBind, default to true
2070  isBind = isBind === undefined ? true : !!isBind;
2071  var bindMethod = isBind ? 'addEventListener' : 'removeEventListener';
2072
2073  if ( window.PointerEvent ) {
2074    // Pointer Events. Chrome 55, IE11, Edge 14
2075    elem[ bindMethod ]( 'pointerdown', this );
2076  } else {
2077    // listen for both, for devices like Chrome Pixel
2078    elem[ bindMethod ]( 'mousedown', this );
2079    elem[ bindMethod ]( 'touchstart', this );
2080  }
2081};
2082
2083// trigger handler methods for events
2084proto.handleEvent = function( event ) {
2085  var method = 'on' + event.type;
2086  if ( this[ method ] ) {
2087    this[ method ]( event );
2088  }
2089};
2090
2091// returns the touch that we're keeping track of
2092proto.getTouch = function( touches ) {
2093  for ( var i=0; i < touches.length; i++ ) {
2094    var touch = touches[i];
2095    if ( touch.identifier == this.pointerIdentifier ) {
2096      return touch;
2097    }
2098  }
2099};
2100
2101// ----- start event ----- //
2102
2103proto.onmousedown = function( event ) {
2104  // dismiss clicks from right or middle buttons
2105  var button = event.button;
2106  if ( button && ( button !== 0 && button !== 1 ) ) {
2107    return;
2108  }
2109  this._pointerDown( event, event );
2110};
2111
2112proto.ontouchstart = function( event ) {
2113  this._pointerDown( event, event.changedTouches[0] );
2114};
2115
2116proto.onpointerdown = function( event ) {
2117  this._pointerDown( event, event );
2118};
2119
2120/**
2121 * pointer start
2122 * @param {Event} event
2123 * @param {Event or Touch} pointer
2124 */
2125proto._pointerDown = function( event, pointer ) {
2126  // dismiss other pointers
2127  if ( this.isPointerDown ) {
2128    return;
2129  }
2130
2131  this.isPointerDown = true;
2132  // save pointer identifier to match up touch events
2133  this.pointerIdentifier = pointer.pointerId !== undefined ?
2134    // pointerId for pointer events, touch.indentifier for touch events
2135    pointer.pointerId : pointer.identifier;
2136
2137  this.pointerDown( event, pointer );
2138};
2139
2140proto.pointerDown = function( event, pointer ) {
2141  this._bindPostStartEvents( event );
2142  this.emitEvent( 'pointerDown', [ event, pointer ] );
2143};
2144
2145// hash of events to be bound after start event
2146var postStartEvents = {

2147  mousedown: [ 'mousemove', 'mouseup' ],
2148  touchstart: [ 'touchmove', 'touchend', 'touchcancel' ],
2149  pointerdown: [ 'pointermove', 'pointerup', 'pointercancel' ],
2150};
2151
2152proto._bindPostStartEvents = function( event ) {
2153  if ( !event ) {
2154    return;
2155  }
2156  // get proper events to match start event
2157  var events = postStartEvents[ event.type ];
2158  // bind events to node
2159  events.forEach( function( eventName ) {
2160    window.addEventListener( eventName, this );
2161  }, this );
2162  // save these arguments
2163  this._boundPointerEvents = events;
2164};
2165
2166proto._unbindPostStartEvents = function() {
2167  // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug)
2168  if ( !this._boundPointerEvents ) {
2169    return;
2170  }
2171  this._boundPointerEvents.forEach( function( eventName ) {
2172    window.removeEventListener( eventName, this );
2173  }, this );
2174
2175  delete this._boundPointerEvents;
2176};
2177
2178// ----- move event ----- //
2179
2180proto.onmousemove = function( event ) {
2181  this._pointerMove( event, event );
2182};
2183
2184proto.onpointermove = function( event ) {
2185  if ( event.pointerId == this.pointerIdentifier ) {
2186    this._pointerMove( event, event );
2187  }
2188};
2189
2190proto.ontouchmove = function( event ) {
2191  var touch = this.getTouch( event.changedTouches );
2192  if ( touch ) {
2193    this._pointerMove( event, touch );
2194  }
2195};
2196
2197/**
2198 * pointer move
2199 * @param {Event} event
2200 * @param {Event or Touch} pointer
2201 * @private
2202 */
2203proto._pointerMove = function( event, pointer ) {
2204  this.pointerMove( event, pointer );
2205};
2206
2207// public
2208proto.pointerMove = function( event, pointer ) {
2209  this.emitEvent( 'pointerMove', [ event, pointer ] );
2210};
2211
2212// ----- end event ----- //
2213
2214
2215proto.onmouseup = function( event ) {
2216  this._pointerUp( event, event );
2217};
2218
2219proto.onpointerup = function( event ) {
2220  if ( event.pointerId == this.pointerIdentifier ) {
2221    this._pointerUp( event, event );
2222  }
2223};
2224
2225proto.ontouchend = function( event ) {
2226  var touch = this.getTouch( event.changedTouches );
2227  if ( touch ) {
2228    this._pointerUp( event, touch );
2229  }
2230};
2231
2232/**
2233 * pointer up
2234 * @param {Event} event
2235 * @param {Event or Touch} pointer
2236 * @private
2237 */
2238proto._pointerUp = function( event, pointer ) {
2239  this._pointerDone();
2240  this.pointerUp( event, pointer );
2241};
2242
2243// public
2244proto.pointerUp = function( event, pointer ) {
2245  this.emitEvent( 'pointerUp', [ event, pointer ] );
2246};
2247
2248// ----- pointer done ----- //
2249
2250// triggered on pointer up & pointer cancel
2251proto._pointerDone = function() {
2252  // reset properties
2253  this.isPointerDown = false;
2254  delete this.pointerIdentifier;
2255  // remove events
2256  this._unbindPostStartEvents();
2257  this.pointerDone();
2258};
2259
2260proto.pointerDone = noop;
2261
2262// ----- pointer cancel ----- //
2263
2264proto.onpointercancel = function( event ) {
2265  if ( event.pointerId == this.pointerIdentifier ) {
2266    this._pointerCancel( event, event );
2267  }
2268};
2269
2270proto.ontouchcancel = function( event ) {
2271  var touch = this.getTouch( event.changedTouches );
2272  if ( touch ) {
2273    this._pointerCancel( event, touch );
2274  }
2275};
2276
2277/**
2278 * pointer cancel
2279 * @param {Event} event
2280 * @param {Event or Touch} pointer
2281 * @private
2282 */
2283proto._pointerCancel = function( event, pointer ) {
2284  this._pointerDone();
2285  this.pointerCancel( event, pointer );
2286};
2287
2288// public
2289proto.pointerCancel = function( event, pointer ) {
2290  this.emitEvent( 'pointerCancel', [ event, pointer ] );
2291};
2292
2293// -----  ----- //
2294
2295// utility function for getting x/y coords from event
2296Unipointer.getPointerPoint = function( pointer ) {
2297  return {
2298    x: pointer.pageX,
2299    y: pointer.pageY
2300  };
2301};
2302
2303// -----  ----- //
2304
2305return Unipointer;
2306
2307}));
2308
2309/*!
2310 * Unidragger v2.2.2
2311 * Draggable base class
2312 * MIT license
2313 */
2314
2315/*jshint browser: true, unused: true, undef: true, strict: true */
2316
2317( function( window, factory ) {
2318  // universal module definition
2319  /*jshint strict: false */ /*globals define, module, require */
2320
2321  if ( typeof define == 'function' && define.amd ) {
2322    // AMD
2323    define( 'unidragger/unidragger',[
2324      'unipointer/unipointer'
2325    ], function( Unipointer ) {
2326      return factory( window, Unipointer );
2327    });
2328  } else if ( typeof module == 'object' && module.exports ) {
2329    // CommonJS
2330    module.exports = factory(
2331      window,
2332      require('unipointer')
2333    );
2334  } else {
2335    // browser global
2336    window.Unidragger = factory(
2337      window,
2338      window.Unipointer
2339    );
2340  }
2341
2342}( window, function factory( window, Unipointer ) {
2343
2344
2345
2346// -------------------------- Unidragger -------------------------- //
2347
2348function Unidragger() {}
2349
2350// inherit Unipointer & EvEmitter
2351var proto = Unidragger.prototype = Object.create( Unipointer.prototype );
2352
2353// ----- bind start ----- //
2354
2355proto.bindHandles = function() {
2356  this._bindHandles( true );
2357};
2358
2359proto.unbindHandles = function() {
2360  this._bindHandles( false );
2361};
2362
2363/**
2364 * works as unbinder, as you can .bindHandles( false ) to unbind
2365 * @param {Boolean} isBind - will unbind if falsey
2366 */
2367proto._bindHandles = function( isBind ) {
2368  // munge isBind, default to true
2369  isBind = isBind === undefined ? true : !!isBind;
2370  // bind each handle
2371  var bindMethod = isBind ? 'addEventListener' : 'removeEventListener';
2372  for ( var i=0; i < this.handles.length; i++ ) {
2373    var handle = this.handles[i];
2374    this._bindStartEvent( handle, isBind );
2375    handle[ bindMethod ]( 'click', this );
2376    // touch-action: none to override browser touch gestures
2377    // metafizzy/flickity#540
2378    if ( window.PointerEvent ) {
2379      handle.style.touchAction = isBind ? 'none' : '';
2380    }
2381  }
2382};
2383
2384// ----- start event ----- //
2385
2386/**
2387 * pointer start
2388 * @param {Event} event
2389 * @param {Event or Touch} pointer
2390 */
2391proto.pointerDown = function( event, pointer ) {
2392  // dismiss range sliders
2393  if ( event.target.nodeName == 'INPUT' && event.target.type == 'range' ) {
2394    // reset pointerDown logic
2395    this.isPointerDown = false;

2396    delete this.pointerIdentifier;
2397    return;
2398  }
2399
2400  this._dragPointerDown( event, pointer );
2401  // kludge to blur focused inputs in dragger
2402  var focused = document.activeElement;
2403  if ( focused && focused.blur ) {
2404    focused.blur();
2405  }
2406  // bind move and end events
2407  this._bindPostStartEvents( event );
2408  this.emitEvent( 'pointerDown', [ event, pointer ] );
2409};
2410
2411// base pointer down logic
2412proto._dragPointerDown = function( event, pointer ) {
2413  // track to see when dragging starts
2414  this.pointerDownPoint = Unipointer.getPointerPoint( pointer );
2415
2416  var canPreventDefault = this.canPreventDefaultOnPointerDown( event, pointer );
2417  if ( canPreventDefault ) {
2418    event.preventDefault();
2419  }
2420};
2421
2422// overwriteable method so Flickity can prevent for scrolling
2423proto.canPreventDefaultOnPointerDown = function( event ) {
2424  // prevent default, unless touchstart or <select>
2425  return event.target.nodeName != 'SELECT';
2426};
2427
2428// ----- move event ----- //
2429
2430/**
2431 * drag move
2432 * @param {Event} event
2433 * @param {Event or Touch} pointer
2434 */
2435proto.pointerMove = function( event, pointer ) {
2436  var moveVector = this._dragPointerMove( event, pointer );
2437  this.emitEvent( 'pointerMove', [ event, pointer, moveVector ] );
2438  this._dragMove( event, pointer, moveVector );
2439};
2440
2441// base pointer move logic
2442proto._dragPointerMove = function( event, pointer ) {
2443  var movePoint = Unipointer.getPointerPoint( pointer );
2444  var moveVector = {
2445    x: movePoint.x - this.pointerDownPoint.x,
2446    y: movePoint.y - this.pointerDownPoint.y
2447  };
2448  // start drag if pointer has moved far enough to start drag
2449  if ( !this.isDragging && this.hasDragStarted( moveVector ) ) {
2450    this._dragStart( event, pointer );
2451  }
2452  return moveVector;
2453};
2454
2455// condition if pointer has moved far enough to start drag
2456proto.hasDragStarted = function( moveVector ) {
2457  return Math.abs( moveVector.x ) > 3 || Math.abs( moveVector.y ) > 3;
2458};
2459
2460
2461// ----- end event ----- //
2462
2463/**
2464 * pointer up
2465 * @param {Event} event
2466 * @param {Event or Touch} pointer
2467 */
2468proto.pointerUp = function( event, pointer ) {
2469  this.emitEvent( 'pointerUp', [ event, pointer ] );
2470  this._dragPointerUp( event, pointer );
2471};
2472
2473proto._dragPointerUp = function( event, pointer ) {
2474  if ( this.isDragging ) {
2475    this._dragEnd( event, pointer );
2476  } else {
2477    // pointer didn't move enough for drag to start
2478    this._staticClick( event, pointer );
2479  }
2480};
2481
2482// -------------------------- drag -------------------------- //
2483
2484// dragStart
2485proto._dragStart = function( event, pointer ) {
2486  this.isDragging = true;
2487  this.dragStartPoint = Unipointer.getPointerPoint( pointer );
2488  // prevent clicks

2489  this.isPreventingClicks = true;
2490
2491  this.dragStart( event, pointer );
2492};
2493
2494proto.dragStart = function( event, pointer ) {
2495  this.emitEvent( 'dragStart', [ event, pointer ] );
2496};
2497
2498// dragMove
2499proto._dragMove = function( event, pointer, moveVector ) {
2500  // do not drag if not dragging yet
2501  if ( !this.isDragging ) {
2502    return;
2503  }
2504
2505  this.dragMove( event, pointer, moveVector );
2506};
2507
2508proto.dragMove = function( event, pointer, moveVector ) {
2509  event.preventDefault();
2510  this.emitEvent( 'dragMove', [ event, pointer, moveVector ] );
2511};
2512
2513// dragEnd
2514proto._dragEnd = function( event, pointer ) {
2515  // set flags
2516  this.isDragging = false;
2517  // re-enable clicking async
2518  setTimeout( function() {
2519    delete this.isPreventingClicks;
2520  }.bind( this ) );
2521
2522  this.dragEnd( event, pointer );
2523};
2524
2525proto.dragEnd = function( event, pointer ) {
2526  this.emitEvent( 'dragEnd', [ event, pointer ] );
2527};
2528
2529// ----- onclick ----- //
2530
2531// handle all clicks and prevent clicks when dragging
2532proto.onclick = function( event ) {
2533  if ( this.isPreventingClicks ) {
2534    event.preventDefault();
2535  }
2536};
2537
2538// ----- staticClick ----- //
2539
2540// triggered after pointer down & up with no/tiny movement
2541proto._staticClick = function( event, pointer ) {
2542  // ignore emulated mouse up clicks
2543  if ( this.isIgnoringMouseUp && event.type == 'mouseup' ) {
2544    return;
2545  }
2546
2547  // allow click in <input>s and <textarea>s
2548  var nodeName = event.target.nodeName;
2549  if ( nodeName == 'INPUT' || nodeName == 'TEXTAREA' ) {
2550    event.target.focus();
2551  }
2552  this.staticClick( event, pointer );
2553
2554  // set flag for emulated clicks 300ms after touchend
2555  if ( event.type != 'mouseup' ) {
2556    this.isIgnoringMouseUp = true;
2557    // reset flag after 300ms
2558    setTimeout( function() {
2559      delete this.isIgnoringMouseUp;
2560    }.bind( this ), 400 );
2561  }
2562};
2563
2564proto.staticClick = function( event, pointer ) {
2565  this.emitEvent( 'staticClick', [ event, pointer ] );
2566};
2567
2568// ----- utils ----- //
2569
2570Unidragger.getPointerPoint = Unipointer.getPointerPoint;
2571
2572// -----  ----- //
2573
2574return Unidragger;
2575
2576}));
2577
2578// drag
2579( function( window, factory ) {
2580  // universal module definition
2581  /* jshint strict: false */
2582  if ( typeof define == 'function' && define.amd ) {
2583    // AMD
2584    define( 'flickity/js/drag',[
2585      './flickity',
2586      'unidragger/unidragger',
2587      'fizzy-ui-utils/utils'
2588    ], function( Flickity, Unidragger, utils ) {
2589      return factory( window, Flickity, Unidragger, utils );
2590    });
2591  } else if ( typeof module == 'object' && module.exports ) {
2592    // CommonJS
2593    module.exports = factory(
2594      window,
2595      require('./flickity'),
2596      require('unidragger'),
2597      require('fizzy-ui-utils')
2598    );
2599  } else {
2600    // browser global
2601    window.Flickity = factory(
2602      window,
2603      window.Flickity,
2604      window.Unidragger,
2605      window.fizzyUIUtils
2606    );
2607  }
2608
2609}( window, function factory( window, Flickity, Unidragger, utils ) {
2610
2611
2612
2613// ----- defaults ----- //
2614
2615utils.extend( Flickity.defaults, {
2616  draggable: true,
2617  dragThreshold: 3,
2618});
2619
2620// ----- create ----- //
2621
2622Flickity.createMethods.push('_createDrag');
2623
2624// -------------------------- drag prototype -------------------------- //
2625
2626var proto = Flickity.prototype;
2627utils.extend( proto, Unidragger.prototype );
2628
2629// --------------------------  -------------------------- //
2630
2631var isTouch = 'createTouch' in document;
2632var isTouchmoveScrollCanceled = false;
2633
2634proto._createDrag = function() {
2635  this.on( 'activate', this.bindDrag );
2636  this.on( 'uiChange', this._uiChangeDrag );
2637  this.on( 'childUIPointerDown', this._childUIPointerDownDrag );
2638  this.on( 'deactivate', this.unbindDrag );
2639  // HACK - add seemingly innocuous handler to fix iOS 10 scroll behavior
2640  // #457, RubaXa/Sortable#973
2641  if ( isTouch && !isTouchmoveScrollCanceled ) {
2642    window.addEventListener( 'touchmove', function() {});
2643    isTouchmoveScrollCanceled = true;
2644  }
2645};
2646
2647proto.bindDrag = function() {
2648  if ( !this.options.draggable || this.isDragBound ) {
2649    return;
2650  }
2651  this.element.classList.add('is-draggable');
2652  this.handles = [ this.viewport ];
2653  this.bindHandles();
2654  this.isDragBound = true;
2655};
2656
2657proto.unbindDrag = function() {
2658  if ( !this.isDragBound ) {
2659    return;
2660  }
2661  this.element.classList.remove('is-draggable');
2662  this.unbindHandles();
2663  delete this.isDragBound;
2664};
2665
2666proto._uiChangeDrag = function() {
2667  delete this.isFreeScrolling;
2668};
2669
2670proto._childUIPointerDownDrag = function( event ) {
2671  event.preventDefault();
2672  this.pointerDownFocus( event );
2673};
2674
2675// -------------------------- pointer events -------------------------- //
2676
2677// nodes that have text fields
2678var cursorNodes = {
2679  TEXTAREA: true,
2680  INPUT: true,
2681  OPTION: true,
2682};
2683
2684// input types that do not have text fields
2685var clickTypes = {
2686  radio: true,
2687  checkbox: true,
2688  button: true,
2689  submit: true,
2690  image: true,
2691  file: true,
2692};
2693
2694proto.pointerDown = function( event, pointer ) {
2695  // dismiss inputs with text fields. #403, #404
2696  var isCursorInput = cursorNodes[ event.target.nodeName ] &&
2697    !clickTypes[ event.target.type ];
2698  if ( isCursorInput ) {
2699    // reset pointerDown logic
2700    this.isPointerDown = false;