https://www.chongmd.com/wp-content/themes/fmBuildr2.0/assets/js/scripts.js?ver=1790673030

1/*!
2 * Flickity PACKAGED v2.0.5
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.1
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 = 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.3
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.length == 'number' ) {
593    // convert nodeList to array
594    for ( var i=0; i < obj.length; i++ ) {
595      ary.push( obj[i] );
596    }
597  } else {
598    // array of single index
599    ary.push( obj );
600  }
601  return ary;
602};
603
604// ----- removeFrom ----- //
605
606utils.removeFrom = function( ary, obj ) {
607  var index = ary.indexOf( obj );
608  if ( index != -1 ) {
609    ary.splice( index, 1 );
610  }
611};
612
613// ----- getParent ----- //
614
615utils.getParent = function( elem, selector ) {
616  while ( elem != document.body ) {
617    elem = elem.parentNode;
618    if ( matchesSelector( elem, selector ) ) {
619      return elem;
620    }
621  }
622};
623
624// ----- getQueryElement ----- //
625
626// use element as selector string
627utils.getQueryElement = function( elem ) {
628  if ( typeof elem == 'string' ) {
629    return document.querySelector( elem );
630  }
631  return elem;
632};
633
634// ----- handleEvent ----- //
635
636// enable .ontype to trigger from .addEventListener( elem, 'type' )
637utils.handleEvent = function( event ) {
638  var method = 'on' + event.type;
639  if ( this[ method ] ) {
640    this[ method ]( event );
641  }
642};
643
644// ----- filterFindElements ----- //
645
646utils.filterFindElements = function( elems, selector ) {
647  // make array of elems
648  elems = utils.makeArray( elems );
649  var ffElems = [];
650

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

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

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

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

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

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

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

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

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

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