https://www.fullers.co.nz/cassette.axd/asset/ContentFullers360/Scr…?9bf3772dbaaf2adaa51d554ff34f6e0e92f02263

1/*!
2 * Flickity PACKAGED v2.3.0
3 * Touch, responsive, flickable carousels
4 *
5 * Licensed GPLv3 for open source use
6 * or Flickity Commercial License for commercial use
7 *
8 * https://flickity.metafizzy.co
9 * Copyright 2015-2021 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.1.0
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  // copy over to avoid interference if .off() in listener
238  listeners = listeners.slice(0);
239  args = args || [];
240  // once stuff
241  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];
242
243  for ( var i=0; i < listeners.length; i++ ) {
244    var listener = listeners[i]
245    var isOnce = onceListeners && onceListeners[ listener ];
246    if ( isOnce ) {
247      // remove listener
248      // remove before trigger to prevent recursion
249      this.off( eventName, listener );
250      // unset once flag
251      delete onceListeners[ listener ];
252    }
253    // trigger listener
254    listener.apply( this, args );
255  }
256
257  return this;
258};
259
260proto.allOff = function() {
261  delete this._events;
262  delete this._onceEvents;
263};
264
265return EvEmitter;
266
267}));
268
269/*!
270 * getSize v2.0.3
271 * measure size of elements
272 * MIT license
273 */
274
275/* jshint browser: true, strict: true, undef: true, unused: true */
276/* globals console: false */
277
278( function( window, factory ) {
279  /* jshint strict: false */ /* globals define, module */
280  if ( typeof define == 'function' && define.amd ) {
281    // AMD
282    define( 'get-size/get-size',factory );
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 https://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   * Chrome & Safari measure the outer-width on style.width on border-box elems
384   * IE11 & 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  // round value for browser zoom. desandro/masonry#928
397  isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200;
398  getSize.isBoxSizeOuter = isBoxSizeOuter;
399
400  body.removeChild( div );
401}
402
403// -------------------------- getSize -------------------------- //
404
405function getSize( elem ) {
406  setup();
407
408  // use querySeletor if elem is string
409  if ( typeof elem == 'string' ) {
410    elem = document.querySelector( elem );
411  }
412
413  // do not proceed on non-objects
414  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
415    return;
416  }
417
418  var style = getStyle( elem );
419
420  // if hidden, everything is 0
421  if ( style.display == 'none' ) {
422    return getZeroSize();
423  }
424
425  var size = {};
426  size.width = elem.offsetWidth;
427  size.height = elem.offsetHeight;
428
429  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
430
431  // get all measurements
432  for ( var i=0; i < measurementsLength; i++ ) {
433    var measurement = measurements[i];
434    var value = style[ measurement ];
435    var num = parseFloat( value );
436    // any 'auto', 'medium' value will be 0
437    size[ measurement ] = !isNaN( num ) ? num : 0;
438  }
439
440  var paddingWidth = size.paddingLeft + size.paddingRight;
441  var paddingHeight = size.paddingTop + size.paddingBottom;
442  var marginWidth = size.marginLeft + size.marginRight;
443  var marginHeight = size.marginTop + size.marginBottom;
444  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
445  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
446
447  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
448
449  // overwrite width and height if we can get it from style
450  var styleWidth = getStyleSize( style.width );
451  if ( styleWidth !== false ) {
452    size.width = styleWidth +
453      // add padding and border unless it's already including it
454      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
455  }
456
457  var styleHeight = getStyleSize( style.height );
458  if ( styleHeight !== false ) {
459    size.height = styleHeight +
460      // add padding and border unless it's already including it
461      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
462  }
463
464  size.innerWidth = size.width - ( paddingWidth + borderWidth );
465  size.innerHeight = size.height - ( paddingHeight + borderHeight );
466
467  size.outerWidth = size.width + marginWidth;
468  size.outerHeight = size.height + marginHeight;
469
470  return size;
471}
472
473return getSize;
474
475});
476
477/**
478 * matchesSelector v2.0.2
479 * matchesSelector( element, '.selector' )
480 * MIT license
481 */
482
483/*jshint browser: true, strict: true, undef: true, unused: true */
484
485( function( window, factory ) {
486  /*global define: false, module: false */
487  'use strict';
488  // universal module definition
489  if ( typeof define == 'function' && define.amd ) {
490    // AMD
491    define( 'desandro-matches-selector/matches-selector',factory );
492  } else if ( typeof module == 'object' && module.exports ) {
493    // CommonJS
494    module.exports = factory();
495  } else {
496    // browser global
497    window.matchesSelector = factory();
498  }
499
500}( window, function factory() {
501  'use strict';
502
503  var matchesMethod = ( function() {
504    var ElemProto = window.Element.prototype;
505    // check for the standard method name first
506    if ( ElemProto.matches ) {
507      return 'matches';
508    }
509    // check un-prefixed
510    if ( ElemProto.matchesSelector ) {
511      return 'matchesSelector';
512    }
513    // check vendor prefixes
514    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
515
516    for ( var i=0; i < prefixes.length; i++ ) {
517      var prefix = prefixes[i];
518      var method = prefix + 'MatchesSelector';
519      if ( ElemProto[ method ] ) {
520        return method;
521      }
522    }
523  })();
524
525  return function matchesSelector( elem, selector ) {
526    return elem[ matchesMethod ]( selector );
527  };
528
529}));
530
531/**
532 * Fizzy UI utils v2.0.7
533 * MIT license
534 */
535
536/*jshint browser: true, undef: true, unused: true, strict: true */
537
538( function( window, factory ) {
539  // universal module definition
540  /*jshint strict: false */ /*globals define, module, require */
541
542  if ( typeof define == 'function' && define.amd ) {
543    // AMD
544    define( 'fizzy-ui-utils/utils',[
545      'desandro-matches-selector/matches-selector'
546    ], function( matchesSelector ) {
547      return factory( window, matchesSelector );
548    });
549  } else if ( typeof module == 'object' && module.exports ) {
550    // CommonJS
551    module.exports = factory(
552      window,
553      require('desandro-matches-selector')
554    );
555  } else {
556    // browser global
557    window.fizzyUIUtils = factory(
558      window,
559      window.matchesSelector
560    );
561  }
562
563}( window, function factory( window, matchesSelector ) {
564
565
566
567var utils = {};
568
569// ----- extend ----- //
570
571// extends objects
572utils.extend = function( a, b ) {
573  for ( var prop in b ) {
574    a[ prop ] = b[ prop ];
575  }
576  return a;
577};
578
579// ----- modulo ----- //
580
581utils.modulo = function( num, div ) {
582  return ( ( num % div ) + div ) % div;
583};
584
585// ----- makeArray ----- //
586
587var arraySlice = Array.prototype.slice;
588
589// turn element or nodeList into an array
590utils.makeArray = function( obj ) {
591  if ( Array.isArray( obj ) ) {
592    // use object if already an array
593    return obj;
594  }
595  // return empty array if undefined or null. #6
596  if ( obj === null || obj === undefined ) {
597    return [];
598  }
599
600  var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
601  if ( isArrayLike ) {
602    // convert nodeList to array
603    return arraySlice.call( obj );
604  }
605
606  // array of single index
607  return [ obj ];
608};
609
610// ----- removeFrom ----- //
611
612utils.removeFrom = function( ary, obj ) {
613  var index = ary.indexOf( obj );
614  if ( index != -1 ) {
615    ary.splice( index, 1 );
616  }
617};
618
619// ----- getParent ----- //
620
621utils.getParent = function( elem, selector ) {
622  while ( elem.parentNode && elem != document.body ) {
623    elem = elem.parentNode;
624    if ( matchesSelector( elem, selector ) ) {
625      return elem;
626    }
627  }
628};
629
630// ----- getQueryElement ----- //
631
632// use element as selector string
633utils.getQueryElement = function( elem ) {
634  if ( typeof elem == 'string' ) {
635    return document.querySelector( elem );
636  }
637  return elem;
638};
639
640// ----- handleEvent ----- //
641
642// enable .ontype to trigger from .addEventListener( elem, 'type' )
643utils.handleEvent = function( event ) {
644  var method = 'on' + event.type;
645  if ( this[ method ] ) {
646    this[ method ]( event );
647  }
648};
649
650// ----- filterFindElements ----- //
651
652utils.filterFindElements = function( elems, selector ) {
653  // make array of elems
654  elems = utils.makeArray( elems );
655  var ffElems = [];
656

657  elems.forEach( function( elem ) {
658    // check that elem is an actual element
659    if ( !( elem instanceof HTMLElement ) ) {
660      return;
661    }
662    // add elem if no selector
663    if ( !selector ) {
664      ffElems.push( elem );
665      return;
666    }
667    // filter & find items if we have a selector
668    // filter
669    if ( matchesSelector( elem, selector ) ) {
670      ffElems.push( elem );
671    }
672    // find children
673    var childElems = elem.querySelectorAll( selector );
674    // concat childElems to filterFound array
675    for ( var i=0; i < childElems.length; i++ ) {
676      ffElems.push( childElems[i] );
677    }
678  });
679
680  return ffElems;
681};
682
683// ----- debounceMethod ----- //
684
685utils.debounceMethod = function( _class, methodName, threshold ) {
686  threshold = threshold || 100;
687  // original method
688  var method = _class.prototype[ methodName ];
689  var timeoutName = methodName + 'Timeout';
690
691  _class.prototype[ methodName ] = function() {
692    var timeout = this[ timeoutName ];
693    clearTimeout( timeout );
694
695    var args = arguments;
696    var _this = this;
697    this[ timeoutName ] = setTimeout( function() {
698      method.apply( _this, args );
699      delete _this[ timeoutName ];
700    }, threshold );
701  };
702};
703
704// ----- docReady ----- //
705
706utils.docReady = function( callback ) {
707  var readyState = document.readyState;
708  if ( readyState == 'complete' || readyState == 'interactive' ) {
709    // do async to allow for other scripts to run. metafizzy/flickity#441
710    setTimeout( callback );
711  } else {
712    document.addEventListener( 'DOMContentLoaded', callback );
713  }
714};
715
716// ----- htmlInit ----- //
717
718// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
719utils.toDashed = function( str ) {
720  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
721    return $1 + '-' + $2;
722  }).toLowerCase();
723};
724
725var console = window.console;
726/**
727 * allow user to initialize classes via [data-namespace] or .js-namespace class
728 * htmlInit( Widget, 'widgetName' )
729 * options are parsed from data-namespace-options
730 */
731utils.htmlInit = function( WidgetClass, namespace ) {
732  utils.docReady( function() {
733    var dashedNamespace = utils.toDashed( namespace );
734    var dataAttr = 'data-' + dashedNamespace;
735    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
736    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
737    var elems = utils.makeArray( dataAttrElems )
738      .concat( utils.makeArray( jsDashElems ) );
739    var dataOptionsAttr = dataAttr + '-options';
740    var jQuery = window.jQuery;
741
742    elems.forEach( function( elem ) {
743      var attr = elem.getAttribute( dataAttr ) ||
744        elem.getAttribute( dataOptionsAttr );
745      var options;
746      try {
747        options = attr && JSON.parse( attr );
748      } catch ( error ) {
749        // log error, do not initialize
750        if ( console ) {
751          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
752          ': ' + error );
753        }
754        return;
755      }
756      // initialize
757      var instance = new WidgetClass( elem, options );
758      // make available via $().data('namespace')
759      if ( jQuery ) {
760        jQuery.data( elem, namespace, instance );
761      }
762    });
763
764  });
765};
766
767// -----  ----- //
768
769return utils;
770
771}));
772
773// Flickity.Cell
774( function( window, factory ) {
775  // universal module definition
776  if ( typeof define == 'function' && define.amd ) {
777    // AMD
778    define( 'flickity/js/cell',[
779      'get-size/get-size',
780    ], function( getSize ) {
781      return factory( window, getSize );
782    } );
783  } else if ( typeof module == 'object' && module.exports ) {
784    // CommonJS
785    module.exports = factory(
786        window,
787        require('get-size')
788    );
789  } else {
790    // browser global
791    window.Flickity = window.Flickity || {};
792    window.Flickity.Cell = factory(
793        window,
794        window.getSize
795    );
796  }
797
798}( window, function factory( window, getSize ) {
799
800
801
802function Cell( elem, parent ) {
803  this.element = elem;
804  this.parent = parent;
805
806  this.create();
807}
808
809var proto = Cell.prototype;
810
811proto.create = function() {
812  this.element.style.position = 'absolute';
813  this.element.setAttribute( 'aria-hidden', 'true' );
814  this.x = 0;
815  this.shift = 0;
816  this.element.style[ this.parent.originSide ] = 0;
817};
818
819proto.destroy = function() {
820  // reset style
821  this.unselect();
822  this.element.style.position = '';
823  var side = this.parent.originSide;
824  this.element.style[ side ] = '';
825  this.element.style.transform = '';
826  this.element.removeAttribute('aria-hidden');
827};
828
829proto.getSize = function() {
830  this.size = getSize( this.element );
831};
832
833proto.setPosition = function( x ) {
834  this.x = x;
835  this.updateTarget();
836  this.renderPosition( x );
837};

838
839// setDefaultTarget v1 method, backwards compatibility, remove in v3
840proto.updateTarget = proto.setDefaultTarget = function() {
841  var marginProperty = this.parent.originSide == 'left' ? 'marginLeft' : 'marginRight';
842  this.target = this.x + this.size[ marginProperty ] +
843    this.size.width * this.parent.cellAlign;
844};
845
846proto.renderPosition = function( x ) {
847  // render position of cell with in slider
848  var sideOffset = this.parent.originSide === 'left' ? 1 : -1;
849
850  var adjustedX = this.parent.options.percentPosition ?
851    x * sideOffset * ( this.parent.size.innerWidth / this.size.width ) :
852    x * sideOffset;
853
854  this.element.style.transform = 'translateX(' +
855    this.parent.getPositionValue( adjustedX ) + ')';
856};
857
858proto.select = function() {
859  this.element.classList.add('is-selected');
860  this.element.removeAttribute('aria-hidden');
861};
862
863proto.unselect = function() {
864  this.element.classList.remove('is-selected');
865  this.element.setAttribute( 'aria-hidden', 'true' );
866};
867
868/**
869 * @param {Integer} shift - 0, 1, or -1
870 */
871proto.wrapShift = function( shift ) {
872  this.shift = shift;
873  this.renderPosition( this.x + this.parent.slideableWidth * shift );
874};
875
876proto.remove = function() {
877  this.element.parentNode.removeChild( this.element );
878};
879
880return Cell;
881
882} ) );
883
884// slide
885( function( window, factory ) {
886  // universal module definition
887  if ( typeof define == 'function' && define.amd ) {
888    // AMD
889    define( 'flickity/js/slide',factory );
890  } else if ( typeof module == 'object' && module.exports ) {
891    // CommonJS
892    module.exports = factory();
893  } else {
894    // browser global
895    window.Flickity = window.Flickity || {};
896    window.Flickity.Slide = factory();
897  }
898
899}( window, function factory() {
900'use strict';
901
902function Slide( parent ) {
903  this.parent = parent;
904  this.isOriginLeft = parent.originSide == 'left';
905  this.cells = [];
906  this.outerWidth = 0;
907  this.height = 0;
908}
909
910var proto = Slide.prototype;
911
912proto.addCell = function( cell ) {
913  this.cells.push( cell );
914  this.outerWidth += cell.size.outerWidth;
915  this.height = Math.max( cell.size.outerHeight, this.height );
916  // first cell stuff
917  if ( this.cells.length == 1 ) {
918    this.x = cell.x; // x comes from first cell
919    var beginMargin = this.isOriginLeft ? 'marginLeft' : 'marginRight';
920    this.firstMargin = cell.size[ beginMargin ];
921  }
922};
923
924proto.updateTarget = function() {
925  var endMargin = this.isOriginLeft ? 'marginRight' : 'marginLeft';
926  var lastCell = this.getLastCell();
927  var lastMargin = lastCell ? lastCell.size[ endMargin ] : 0;
928  var slideWidth = this.outerWidth - ( this.firstMargin + lastMargin );
929  this.target = this.x + this.firstMargin + slideWidth * this.parent.cellAlign;
930};
931
932proto.getLastCell = function() {
933  return this.cells[ this.cells.length - 1 ];
934};
935
936proto.select = function() {
937  this.cells.forEach( function( cell ) {
938    cell.select();
939  } );
940};
941
942proto.unselect = function() {
943  this.cells.forEach( function( cell ) {
944    cell.unselect();
945  } );
946};
947
948proto.getCellElements = function() {
949  return this.cells.map( function( cell ) {
950    return cell.element;
951  } );
952};
953
954return Slide;
955
956} ) );
957
958// animate
959( function( window, factory ) {
960  // universal module definition
961  if ( typeof define == 'function' && define.amd ) {
962    // AMD
963    define( 'flickity/js/animate',[
964      'fizzy-ui-utils/utils',
965    ], function( utils ) {
966      return factory( window, utils );
967    } );
968  } else if ( typeof module == 'object' && module.exports ) {
969    // CommonJS
970    module.exports = factory(
971        window,
972        require('fizzy-ui-utils')
973    );
974  } else {
975    // browser global
976    window.Flickity = window.Flickity || {};
977    window.Flickity.animatePrototype = factory(
978        window,
979        window.fizzyUIUtils
980    );
981  }
982
983}( window, function factory( window, utils ) {
984
985
986
987// -------------------------- animate -------------------------- //
988
989var proto = {};
990
991proto.startAnimation = function() {
992  if ( this.isAnimating ) {
993    return;
994  }
995
996  this.isAnimating = true;
997  this.restingFrames = 0;
998  this.animate();
999};
1000
1001proto.animate = function() {
1002  this.applyDragForce();
1003  this.applySelectedAttraction();
1004
1005  var previousX = this.x;
1006
1007  this.integratePhysics();
1008  this.positionSlider();
1009  this.settle( previousX );
1010  // animate next frame
1011  if ( this.isAnimating ) {
1012    var _this = this;
1013    requestAnimationFrame( function animateFrame() {
1014      _this.animate();
1015    } );
1016  }
1017};
1018
1019proto.positionSlider = function() {
1020  var x = this.x;
1021  // wrap position around
1022  if ( this.options.wrapAround && this.cells.length > 1 ) {
1023    x = utils.modulo( x, this.slideableWidth );
1024    x -= this.slideableWidth;
1025    this.shiftWrapCells( x );
1026  }
1027
1028  this.setTranslateX( x, this.isAnimating );
1029  this.dispatchScrollEvent();
1030};
1031
1032proto.setTranslateX = function( x, is3d ) {
1033  x += this.cursorPosition;
1034  // reverse if right-to-left and using transform
1035  x = this.options.rightToLeft ? -x : x;
1036  var translateX = this.getPositionValue( x );
1037  // use 3D transforms for hardware acceleration on iOS
1038  // but use 2D when settled, for better font-rendering
1039  this.slider.style.transform = is3d ?
1040    'translate3d(' + translateX + ',0,0)' : 'translateX(' + translateX + ')';
1041};
1042
1043proto.dispatchScrollEvent = function() {
1044  var firstSlide = this.slides[0];
1045  if ( !firstSlide ) {
1046    return;
1047  }
1048  var positionX = -this.x - firstSlide.target;
1049  var progress = positionX / this.slidesWidth;
1050  this.dispatchEvent( 'scroll', null, [ progress, positionX ] );
1051};

1052
1053proto.positionSliderAtSelected = function() {
1054  if ( !this.cells.length ) {
1055    return;
1056  }
1057  this.x = -this.selectedSlide.target;
1058  this.velocity = 0; // stop wobble
1059  this.positionSlider();
1060};
1061
1062proto.getPositionValue = function( position ) {
1063  if ( this.options.percentPosition ) {
1064    // percent position, round to 2 digits, like 12.34%
1065    return ( Math.round( ( position / this.size.innerWidth ) * 10000 ) * 0.01 ) + '%';
1066  } else {
1067    // pixel positioning
1068    return Math.round( position ) + 'px';
1069  }
1070};
1071
1072proto.settle = function( previousX ) {
1073  // keep track of frames where x hasn't moved
1074  var isResting = !this.isPointerDown &&
1075      Math.round( this.x * 100 ) == Math.round( previousX * 100 );
1076  if ( isResting ) {
1077    this.restingFrames++;
1078  }
1079  // stop animating if resting for 3 or more frames
1080  if ( this.restingFrames > 2 ) {
1081    this.isAnimating = false;
1082    delete this.isFreeScrolling;
1083    // render position with translateX when settled
1084    this.positionSlider();
1085    this.dispatchEvent( 'settle', null, [ this.selectedIndex ] );
1086  }
1087};
1088
1089proto.shiftWrapCells = function( x ) {
1090  // shift before cells
1091  var beforeGap = this.cursorPosition + x;
1092  this._shiftCells( this.beforeShiftCells, beforeGap, -1 );
1093  // shift after cells
1094  var afterGap = this.size.innerWidth - ( x + this.slideableWidth + this.cursorPosition );
1095  this._shiftCells( this.afterShiftCells, afterGap, 1 );
1096};
1097
1098proto._shiftCells = function( cells, gap, shift ) {
1099  for ( var i = 0; i < cells.length; i++ ) {
1100    var cell = cells[i];
1101    var cellShift = gap > 0 ? shift : 0;
1102    cell.wrapShift( cellShift );
1103    gap -= cell.size.outerWidth;
1104  }
1105};
1106
1107proto._unshiftCells = function( cells ) {
1108  if ( !cells || !cells.length ) {
1109    return;
1110  }
1111  for ( var i = 0; i < cells.length; i++ ) {
1112    cells[i].wrapShift( 0 );
1113  }
1114};
1115
1116// -------------------------- physics -------------------------- //
1117
1118proto.integratePhysics = function() {
1119  this.x += this.velocity;
1120  this.velocity *= this.getFrictionFactor();
1121};
1122
1123proto.applyForce = function( force ) {
1124  this.velocity += force;
1125};
1126
1127proto.getFrictionFactor = function() {
1128  return 1 - this.options[ this.isFreeScrolling ? 'freeScrollFriction' : 'friction' ];
1129};
1130
1131proto.getRestingPosition = function() {
1132  // my thanks to Steven Wittens, who simplified this math greatly
1133  return this.x + this.velocity / ( 1 - this.getFrictionFactor() );
1134};
1135
1136proto.applyDragForce = function() {
1137  if ( !this.isDraggable || !this.isPointerDown ) {
1138    return;
1139  }
1140  // change the position to drag position by applying force
1141  var dragVelocity = this.dragX - this.x;
1142  var dragForce = dragVelocity - this.velocity;
1143  this.applyForce( dragForce );
1144};
1145
1146proto.applySelectedAttraction = function() {
1147  // do not attract if pointer down or no slides
1148  var dragDown = this.isDraggable && this.isPointerDown;
1149  if ( dragDown || this.isFreeScrolling || !this.slides.length ) {
1150    return;
1151  }
1152  var distance = this.selectedSlide.target * -1 - this.x;
1153  var force = distance * this.options.selectedAttraction;
1154  this.applyForce( force );
1155};
1156
1157return proto;
1158
1159} ) );
1160
1161// Flickity main
1162/* eslint-disable max-params */
1163( function( window, factory ) {
1164  // universal module definition
1165  if ( typeof define == 'function' && define.amd ) {
1166    // AMD
1167    define( 'flickity/js/flickity',[
1168      'ev-emitter/ev-emitter',
1169      'get-size/get-size',
1170      'fizzy-ui-utils/utils',
1171      './cell',
1172      './slide',
1173      './animate',
1174    ], function( EvEmitter, getSize, utils, Cell, Slide, animatePrototype ) {
1175      return factory( window, EvEmitter, getSize, utils, Cell, Slide, animatePrototype );
1176    } );
1177  } else if ( typeof module == 'object' && module.exports ) {
1178    // CommonJS
1179    module.exports = factory(
1180        window,
1181        require('ev-emitter'),
1182        require('get-size'),
1183        require('fizzy-ui-utils'),
1184        require('./cell'),
1185        require('./slide'),
1186        require('./animate')
1187    );
1188  } else {
1189    // browser global
1190    var _Flickity = window.Flickity;
1191
1192    window.Flickity = factory(
1193        window,
1194        window.EvEmitter,
1195        window.getSize,
1196        window.fizzyUIUtils,
1197        _Flickity.Cell,
1198        _Flickity.Slide,
1199        _Flickity.animatePrototype
1200    );
1201  }
1202
1203}( window, function factory( window, EvEmitter, getSize,
1204    utils, Cell, Slide, animatePrototype ) {
1205
1206/* eslint-enable max-params */
1207
1208
1209// vars
1210var jQuery = window.jQuery;
1211var getComputedStyle = window.getComputedStyle;
1212var console = window.console;
1213
1214function moveElements( elems, toElem ) {
1215  elems = utils.makeArray( elems );
1216  while ( elems.length ) {
1217    toElem.appendChild( elems.shift() );
1218  }
1219}
1220
1221// -------------------------- Flickity -------------------------- //
1222
1223// globally unique identifiers
1224var GUID = 0;

1225// internal store of all Flickity intances
1226var instances = {};
1227
1228function Flickity( element, options ) {
1229  var queryElement = utils.getQueryElement( element );
1230  if ( !queryElement ) {
1231    if ( console ) {
1232      console.error( 'Bad element for Flickity: ' + ( queryElement || element ) );
1233    }
1234    return;
1235  }
1236  this.element = queryElement;
1237  // do not initialize twice on same element
1238  if ( this.element.flickityGUID ) {
1239    var instance = instances[ this.element.flickityGUID ];
1240    if ( instance ) instance.option( options );
1241    return instance;
1242  }
1243
1244  // add jQuery
1245  if ( jQuery ) {
1246    this.$element = jQuery( this.element );
1247  }
1248  // options
1249  this.options = utils.extend( {}, this.constructor.defaults );
1250  this.option( options );
1251
1252  // kick things off
1253  this._create();
1254}
1255
1256Flickity.defaults = {
1257  accessibility: true,
1258  // adaptiveHeight: false,
1259  cellAlign: 'center',
1260  // cellSelector: undefined,
1261  // contain: false,
1262  freeScrollFriction: 0.075, // friction when free-scrolling
1263  friction: 0.28, // friction when selecting
1264  namespaceJQueryEvents: true,
1265  // initialIndex: 0,
1266  percentPosition: true,
1267  resize: true,
1268  selectedAttraction: 0.025,
1269  setGallerySize: true,
1270  // watchCSS: false,
1271  // wrapAround: false
1272};
1273
1274// hash of methods triggered on _create()
1275Flickity.createMethods = [];
1276
1277var proto = Flickity.prototype;
1278// inherit EventEmitter
1279utils.extend( proto, EvEmitter.prototype );
1280
1281proto._create = function() {
1282  // add id for Flickity.data
1283  var id = this.guid = ++GUID;
1284  this.element.flickityGUID = id; // expando
1285  instances[ id ] = this; // associate via id
1286  // initial properties
1287  this.selectedIndex = 0;
1288  // how many frames slider has been in same position
1289  this.restingFrames = 0;
1290  // initial physics properties
1291  this.x = 0;
1292  this.velocity = 0;
1293  this.originSide = this.options.rightToLeft ? 'right' : 'left';
1294  // create viewport & slider
1295  this.viewport = document.createElement('div');
1296  this.viewport.className = 'flickity-viewport';
1297  this._createSlider();
1298
1299  if ( this.options.resize || this.options.watchCSS ) {
1300    window.addEventListener( 'resize', this );
1301  }
1302
1303  // add listeners from on option
1304  for ( var eventName in this.options.on ) {
1305    var listener = this.options.on[ eventName ];
1306    this.on( eventName, listener );
1307  }
1308
1309  Flickity.createMethods.forEach( function( method ) {
1310    this[ method ]();
1311  }, this );
1312
1313  if ( this.options.watchCSS ) {
1314    this.watchCSS();
1315  } else {
1316    this.activate();
1317  }
1318
1319};
1320
1321/**
1322 * set options
1323 * @param {Object} opts - options to extend
1324 */
1325proto.option = function( opts ) {
1326  utils.extend( this.options, opts );
1327};
1328
1329proto.activate = function() {
1330  if ( this.isActive ) {
1331    return;
1332  }
1333  this.isActive = true;
1334  this.element.classList.add('flickity-enabled');
1335  if ( this.options.rightToLeft ) {
1336    this.element.classList.add('flickity-rtl');
1337  }
1338
1339  this.getSize();
1340  // move initial cell elements so they can be loaded as cells
1341  var cellElems = this._filterFindCellElements( this.element.children );
1342  moveElements( cellElems, this.slider );
1343  this.viewport.appendChild( this.slider );
1344  this.element.appendChild( this.viewport );
1345  // get cells from children
1346  this.reloadCells();
1347
1348  if ( this.options.accessibility ) {
1349    // allow element to focusable
1350    this.element.tabIndex = 0;
1351    // listen for key presses
1352    this.element.addEventListener( 'keydown', this );
1353  }
1354
1355  this.emitEvent('activate');
1356  this.selectInitialIndex();
1357  // flag for initial activation, for using initialIndex
1358  this.isInitActivated = true;
1359  // ready event. #493
1360  this.dispatchEvent('ready');
1361};
1362
1363// slider positions the cells
1364proto._createSlider = function() {
1365  // slider element does all the positioning
1366  var slider = document.createElement('div');
1367  slider.className = 'flickity-slider';
1368  slider.style[ this.originSide ] = 0;
1369  this.slider = slider;
1370};
1371
1372proto._filterFindCellElements = function( elems ) {
1373  return utils.filterFindElements( elems, this.options.cellSelector );
1374};
1375
1376// goes through all children
1377proto.reloadCells = function() {
1378  // collection of item elements
1379  this.cells = this._makeCells( this.slider.children );
1380  this.positionCells();

1381  this._getWrapShiftCells();
1382  this.setGallerySize();
1383};
1384
1385/**
1386 * turn elements into Flickity.Cells
1387 * @param {[Array, NodeList, HTMLElement]} elems - elements to make into cells
1388 * @returns {Array} items - collection of new Flickity Cells
1389 */
1390proto._makeCells = function( elems ) {
1391  var cellElems = this._filterFindCellElements( elems );
1392
1393  // create new Flickity for collection
1394  var cells = cellElems.map( function( cellElem ) {
1395    return new Cell( cellElem, this );
1396  }, this );
1397
1398  return cells;
1399};
1400
1401proto.getLastCell = function() {
1402  return this.cells[ this.cells.length - 1 ];
1403};
1404
1405proto.getLastSlide = function() {
1406  return this.slides[ this.slides.length - 1 ];
1407};
1408
1409// positions all cells
1410proto.positionCells = function() {
1411  // size all cells
1412  this._sizeCells( this.cells );
1413  // position all cells
1414  this._positionCells( 0 );
1415};
1416
1417/**
1418 * position certain cells
1419 * @param {Integer} index - which cell to start with
1420 */
1421proto._positionCells = function( index ) {
1422  index = index || 0;
1423  // also measure maxCellHeight
1424  // start 0 if positioning all cells
1425  this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
1426  var cellX = 0;
1427  // get cellX
1428  if ( index > 0 ) {
1429    var startCell = this.cells[ index - 1 ];
1430    cellX = startCell.x + startCell.size.outerWidth;
1431  }
1432  var len = this.cells.length;
1433  for ( var i = index; i < len; i++ ) {
1434    var cell = this.cells[i];
1435    cell.setPosition( cellX );
1436    cellX += cell.size.outerWidth;
1437    this.maxCellHeight = Math.max( cell.size.outerHeight, this.maxCellHeight );
1438  }
1439  // keep track of cellX for wrap-around
1440  this.slideableWidth = cellX;
1441  // slides
1442  this.updateSlides();
1443  // contain slides target
1444  this._containSlides();
1445  // update slidesWidth
1446  this.slidesWidth = len ? this.getLastSlide().target - this.slides[0].target : 0;
1447};
1448
1449/**
1450 * cell.getSize() on multiple cells
1451 * @param {Array} cells - cells to size
1452 */
1453proto._sizeCells = function( cells ) {
1454  cells.forEach( function( cell ) {
1455    cell.getSize();
1456  } );
1457};
1458
1459// --------------------------  -------------------------- //
1460
1461proto.updateSlides = function() {
1462  this.slides = [];
1463  if ( !this.cells.length ) {
1464    return;
1465  }
1466
1467  var slide = new Slide( this );
1468  this.slides.push( slide );
1469  var isOriginLeft = this.originSide == 'left';
1470  var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
1471
1472  var canCellFit = this._getCanCellFit();
1473
1474  this.cells.forEach( function( cell, i ) {
1475    // just add cell if first cell in slide
1476    if ( !slide.cells.length ) {
1477      slide.addCell( cell );
1478      return;
1479    }
1480
1481    var slideWidth = ( slide.outerWidth - slide.firstMargin ) +
1482      ( cell.size.outerWidth - cell.size[ nextMargin ] );
1483
1484    if ( canCellFit.call( this, i, slideWidth ) ) {
1485      slide.addCell( cell );
1486    } else {
1487      // doesn't fit, new slide
1488      slide.updateTarget();
1489
1490      slide = new Slide( this );
1491      this.slides.push( slide );
1492      slide.addCell( cell );
1493    }
1494  }, this );
1495  // last slide
1496  slide.updateTarget();
1497  // update .selectedSlide
1498  this.updateSelectedSlide();
1499};
1500
1501proto._getCanCellFit = function() {
1502  var groupCells = this.options.groupCells;
1503  if ( !groupCells ) {
1504    return function() {
1505      return false;
1506    };
1507  } else if ( typeof groupCells == 'number' ) {
1508    // group by number. 3 -> [0,1,2], [3,4,5], ...
1509    var number = parseInt( groupCells, 10 );
1510    return function( i ) {
1511      return ( i % number ) !== 0;
1512    };
1513  }
1514  // default, group by width of slide
1515  // parse '75%
1516  var percentMatch = typeof groupCells == 'string' &&
1517    groupCells.match( /^(\d+)%$/ );
1518  var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1;
1519  return function( i, slideWidth ) {
1520    /* eslint-disable-next-line no-invalid-this */
1521    return slideWidth <= ( this.size.innerWidth + 1 ) * percent;
1522  };
1523};
1524
1525// alias _init for jQuery plugin .flickity()
1526proto._init =
1527proto.reposition = function() {
1528  this.positionCells();
1529  this.positionSliderAtSelected();
1530};
1531
1532proto.getSize = function() {
1533  this.size = getSize( this.element );
1534  this.setCellAlign();
1535  this.cursorPosition = this.size.innerWidth * this.cellAlign;
1536};
1537
1538var cellAlignShorthands = {
1539  // cell align, then based on origin side
1540  center: {
1541    left: 0.5,
1542    right: 0.5,
1543  },
1544  left: {
1545    left: 0,
1546    right: 1,
1547  },
1548  right: {
1549    right: 0,
1550    left: 1,
1551  },
1552};
1553
1554proto.setCellAlign = function() {
1555  var shorthand = cellAlignShorthands[ this.options.cellAlign ];
1556  this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign;
1557};
1558
1559proto.setGallerySize = function() {
1560  if ( this.options.setGallerySize ) {
1561    var height = this.options.adaptiveHeight && this.selectedSlide ?
1562      this.selectedSlide.height : this.maxCellHeight;
1563    this.viewport.style.height = height + 'px';
1564  }
1565};
1566
1567proto._getWrapShiftCells = function() {
1568  // only for wrap-around
1569  if ( !this.options.wrapAround ) {
1570    return;
1571  }
1572  // unshift previous cells
1573  this._unshiftCells( this.beforeShiftCells );
1574  this._unshiftCells( this.afterShiftCells );
1575  // get before cells
1576  // initial gap
1577  var gapX = this.cursorPosition;
1578  var cellIndex = this.cells.length - 1;
1579  this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 );
1580  // get after cells
1581  // ending gap between last cell and end of gallery viewport

1582  gapX = this.size.innerWidth - this.cursorPosition;
1583  // start cloning at first cell, working forwards
1584  this.afterShiftCells = this._getGapCells( gapX, 0, 1 );
1585};
1586
1587proto._getGapCells = function( gapX, cellIndex, increment ) {
1588  // keep adding cells until the cover the initial gap
1589  var cells = [];
1590  while ( gapX > 0 ) {
1591    var cell = this.cells[ cellIndex ];
1592    if ( !cell ) {
1593      break;
1594    }
1595    cells.push( cell );
1596    cellIndex += increment;
1597    gapX -= cell.size.outerWidth;
1598  }
1599  return cells;
1600};
1601
1602// ----- contain ----- //
1603
1604// contain cell targets so no excess sliding
1605proto._containSlides = function() {
1606  if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) {
1607    return;
1608  }
1609  var isRightToLeft = this.options.rightToLeft;
1610  var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
1611  var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
1612  var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ];
1613  // content is less than gallery size
1614  var isContentSmaller = contentWidth < this.size.innerWidth;
1615  // bounds
1616  var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ];
1617  var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign );
1618  // contain each cell target
1619  this.slides.forEach( function( slide ) {
1620    if ( isContentSmaller ) {
1621      // all cells fit inside gallery
1622      slide.target = contentWidth * this.cellAlign;
1623    } else {
1624      // contain to bounds
1625      slide.target = Math.max( slide.target, beginBound );
1626      slide.target = Math.min( slide.target, endBound );
1627    }
1628  }, this );
1629};
1630
1631// -----  ----- //
1632
1633/**
1634 * emits events via eventEmitter and jQuery events
1635 * @param {String} type - name of event
1636 * @param {Event} event - original event
1637 * @param {Array} args - extra arguments
1638 */
1639proto.dispatchEvent = function( type, event, args ) {
1640  var emitArgs = event ? [ event ].concat( args ) : args;
1641  this.emitEvent( type, emitArgs );
1642
1643  if ( jQuery && this.$element ) {
1644    // default trigger with type if no event
1645    type += this.options.namespaceJQueryEvents ? '.flickity' : '';
1646    var $event = type;
1647    if ( event ) {
1648      // create jQuery event
1649      var jQEvent = new jQuery.Event( event );
1650      jQEvent.type = type;
1651      $event = jQEvent;
1652    }
1653    this.$element.trigger( $event, args );
1654  }
1655};
1656
1657// -------------------------- select -------------------------- //
1658
1659/**
1660 * @param {Integer} index - index of the slide
1661 * @param {Boolean} isWrap - will wrap-around to last/first if at the end
1662 * @param {Boolean} isInstant - will immediately set position at selected cell
1663 */
1664proto.select = function( index, isWrap, isInstant ) {
1665  if ( !this.isActive ) {
1666    return;
1667  }
1668  index = parseInt( index, 10 );
1669  this._wrapSelect( index );
1670
1671  if ( this.options.wrapAround || isWrap ) {
1672    index = utils.modulo( index, this.slides.length );
1673  }
1674  // bail if invalid index
1675  if ( !this.slides[ index ] ) {
1676    return;
1677  }
1678  var prevIndex = this.selectedIndex;
1679  this.selectedIndex = index;
1680  this.updateSelectedSlide();
1681  if ( isInstant ) {
1682    this.positionSliderAtSelected();
1683  } else {
1684    this.startAnimation();
1685  }
1686  if ( this.options.adaptiveHeight ) {
1687    this.setGallerySize();
1688  }
1689  // events
1690  this.dispatchEvent( 'select', null, [ index ] );
1691  // change event if new index
1692  if ( index != prevIndex ) {
1693    this.dispatchEvent( 'change', null, [ index ] );
1694  }
1695  // old v1 event name, remove in v3
1696  this.dispatchEvent('cellSelect');
1697};
1698
1699// wraps position for wrapAround, to move to closest slide. #113
1700proto._wrapSelect = function( index ) {
1701  var len = this.slides.length;
1702  var isWrapping = this.options.wrapAround && len > 1;
1703  if ( !isWrapping ) {
1704    return index;
1705  }
1706  var wrapIndex = utils.modulo( index, len );
1707  // go to shortest
1708  var delta = Math.abs( wrapIndex - this.selectedIndex );
1709  var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex );
1710  var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex );
1711  if ( !this.isDragSelect && backWrapDelta < delta ) {
1712    index += len;
1713  } else if ( !this.isDragSelect && forewardWrapDelta < delta ) {
1714    index -= len;
1715  }
1716  // wrap position so slider is within normal area
1717  if ( index < 0 ) {
1718    this.x -= this.slideableWidth;
1719  } else if ( index >= len ) {
1720    this.x += this.slideableWidth;
1721  }
1722};
1723
1724proto.previous = function( isWrap, isInstant ) {
1725  this.select( this.selectedIndex - 1, isWrap, isInstant );
1726};
1727
1728proto.next = function( isWrap, isInstant ) {
1729  this.select( this.selectedIndex + 1, isWrap, isInstant );
1730};
1731
1732proto.updateSelectedSlide = function() {
1733  var slide = this.slides[ this.selectedIndex ];
1734  // selectedIndex could be outside of slides, if triggered before resize()
1735  if ( !slide ) {
1736    return;
1737  }
1738  // unselect previous selected slide
1739  this.unselectSelectedSlide();
1740  // update new selected slide
1741  this.selectedSlide = slide;
1742  slide.select();
1743  this.selectedCells = slide.cells;
1744  this.selectedElements = slide.getCellElements();
1745  // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility
1746  // Remove in v3?
1747  this.selectedCell = slide.cells[0];
1748  this.selectedElement = this.selectedElements[0];
1749};
1750
1751proto.unselectSelectedSlide = function() {
1752  if ( this.selectedSlide ) {
1753    this.selectedSlide.unselect();
1754  }
1755};
1756
1757proto.selectInitialIndex = function() {
1758  var initialIndex = this.options.initialIndex;
1759  // already activated, select previous selectedIndex
1760  if ( this.isInitActivated ) {
1761    this.select( this.selectedIndex, false, true );
1762    return;
1763  }
1764  // select with selector string
1765  if ( initialIndex && typeof initialIndex == 'string' ) {
1766    var cell = this.queryCell( initialIndex );
1767    if ( cell ) {
1768      this.selectCell( initialIndex, false, true );
1769      return;
1770    }
1771  }
1772
1773  var index = 0;
1774  // select with number
1775  if ( initialIndex && this.slides[ initialIndex ] ) {
1776    index = initialIndex;
1777  }
1778  // select instantly
1779  this.select( index, false, true );
1780};
1781
1782/**
1783 * select slide from number or cell element
1784 * @param {[Element, Number]} value - zero-based index or element to select
1785 * @param {Boolean} isWrap - enables wrapping around for extra index
1786 * @param {Boolean} isInstant - disables slide animation
1787 */
1788proto.selectCell = function( value, isWrap, isInstant ) {
1789  // get cell
1790  var cell = this.queryCell( value );
1791  if ( !cell ) {
1792    return;
1793  }
1794
1795  var index = this.getCellSlideIndex( cell );
1796  this.select( index, isWrap, isInstant );
1797};
1798
1799proto.getCellSlideIndex = function( cell ) {
1800  // get index of slides that has cell
1801  for ( var i = 0; i < this.slides.length; i++ ) {
1802    var slide = this.slides[i];

1803    var index = slide.cells.indexOf( cell );
1804    if ( index != -1 ) {
1805      return i;
1806    }
1807  }
1808};
1809
1810// -------------------------- get cells -------------------------- //
1811
1812/**
1813 * get Flickity.Cell, given an Element
1814 * @param {Element} elem - matching cell element
1815 * @returns {Flickity.Cell} cell - matching cell
1816 */
1817proto.getCell = function( elem ) {
1818  // loop through cells to get the one that matches
1819  for ( var i = 0; i < this.cells.length; i++ ) {
1820    var cell = this.cells[i];
1821    if ( cell.element == elem ) {
1822      return cell;
1823    }
1824  }
1825};
1826
1827/**
1828 * get collection of Flickity.Cells, given Elements
1829 * @param {[Element, Array, NodeList]} elems - multiple elements
1830 * @returns {Array} cells - Flickity.Cells
1831 */
1832proto.getCells = function( elems ) {
1833  elems = utils.makeArray( elems );
1834  var cells = [];
1835  elems.forEach( function( elem ) {
1836    var cell = this.getCell( elem );
1837    if ( cell ) {
1838      cells.push( cell );
1839    }
1840  }, this );
1841  return cells;
1842};
1843
1844/**
1845 * get cell elements
1846 * @returns {Array} cellElems
1847 */
1848proto.getCellElements = function() {
1849  return this.cells.map( function( cell ) {
1850    return cell.element;
1851  } );
1852};
1853
1854/**
1855 * get parent cell from an element
1856 * @param {Element} elem - child element
1857 * @returns {Flickit.Cell} cell - parent cell
1858 */
1859proto.getParentCell = function( elem ) {
1860  // first check if elem is cell
1861  var cell = this.getCell( elem );
1862  if ( cell ) {
1863    return cell;
1864  }
1865  // try to get parent cell elem
1866  elem = utils.getParent( elem, '.flickity-slider > *' );
1867  return this.getCell( elem );
1868};
1869
1870/**
1871 * get cells adjacent to a slide
1872 * @param {Integer} adjCount - number of adjacent slides
1873 * @param {Integer} index - index of slide to start
1874 * @returns {Array} cells - array of Flickity.Cells
1875 */
1876proto.getAdjacentCellElements = function( adjCount, index ) {
1877  if ( !adjCount ) {
1878    return this.selectedSlide.getCellElements();
1879  }
1880  index = index === undefined ? this.selectedIndex : index;
1881
1882  var len = this.slides.length;
1883  if ( 1 + ( adjCount * 2 ) >= len ) {
1884    return this.getCellElements();
1885  }
1886
1887  var cellElems = [];
1888  for ( var i = index - adjCount; i <= index + adjCount; i++ ) {
1889    var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i;
1890    var slide = this.slides[ slideIndex ];
1891    if ( slide ) {
1892      cellElems = cellElems.concat( slide.getCellElements() );
1893    }
1894  }
1895  return cellElems;
1896};
1897
1898/**
1899 * select slide from number or cell element
1900 * @param {[Element, String, Number]} selector - element, selector string, or index
1901 * @returns {Flickity.Cell} - matching cell
1902 */
1903proto.queryCell = function( selector ) {
1904  if ( typeof selector == 'number' ) {
1905    // use number as index
1906    return this.cells[ selector ];
1907  }
1908  if ( typeof selector == 'string' ) {
1909    // do not select invalid selectors from hash: #123, #/. #791
1910    if ( selector.match( /^[#.]?[\d/]/ ) ) {
1911      return;
1912    }
1913    // use string as selector, get element
1914    selector = this.element.querySelector( selector );
1915  }
1916  // get cell from element
1917  return this.getCell( selector );
1918};
1919
1920// -------------------------- events -------------------------- //
1921
1922proto.uiChange = function() {
1923  this.emitEvent('uiChange');
1924};
1925
1926// keep focus on element when child UI elements are clicked
1927proto.childUIPointerDown = function( event ) {
1928  // HACK iOS does not allow touch events to bubble up?!
1929  if ( event.type != 'touchstart' ) {
1930    event.preventDefault();
1931  }
1932  this.focus();
1933};
1934
1935// ----- resize ----- //
1936
1937proto.onresize = function() {
1938  this.watchCSS();
1939  this.resize();
1940};
1941
1942utils.debounceMethod( Flickity, 'onresize', 150 );
1943
1944proto.resize = function() {
1945  // #1177 disable resize behavior when animating or dragging for iOS 15
1946  if ( !this.isActive || this.isAnimating || this.isDragging ) {
1947    return;
1948  }
1949  this.getSize();
1950  // wrap values
1951  if ( this.options.wrapAround ) {
1952    this.x = utils.modulo( this.x, this.slideableWidth );
1953  }
1954  this.positionCells();
1955  this._getWrapShiftCells();
1956  this.setGallerySize();
1957  this.emitEvent('resize');
1958  // update selected index for group slides, instant
1959  // TODO: position can be lost between groups of various numbers
1960  var selectedElement = this.selectedElements && this.selectedElements[0];
1961  this.selectCell( selectedElement, false, true );
1962};
1963
1964// watches the :after property, activates/deactivates
1965proto.watchCSS = function() {
1966  var watchOption = this.options.watchCSS;
1967  if ( !watchOption ) {
1968    return;
1969  }
1970
1971  var afterContent = getComputedStyle( this.element, ':after' ).content;
1972  // activate if :after { content: 'flickity' }
1973  if ( afterContent.indexOf('flickity') != -1 ) {
1974    this.activate();
1975  } else {
1976    this.deactivate();
1977  }
1978};
1979
1980// ----- keydown ----- //
1981
1982// go previous/next if left/right keys pressed
1983proto.onkeydown = function( event ) {

1984  // only work if element is in focus
1985  var isNotFocused = document.activeElement && document.activeElement != this.element;
1986  if ( !this.options.accessibility || isNotFocused ) {
1987    return;
1988  }
1989
1990  var handler = Flickity.keyboardHandlers[ event.keyCode ];
1991  if ( handler ) {
1992    handler.call( this );
1993  }
1994};
1995
1996Flickity.keyboardHandlers = {
1997  // left arrow
1998  37: function() {
1999    var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
2000    this.uiChange();
2001    this[ leftMethod ]();
2002  },
2003  // right arrow
2004  39: function() {
2005    var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
2006    this.uiChange();
2007    this[ rightMethod ]();
2008  },
2009};
2010
2011// ----- focus ----- //
2012
2013proto.focus = function() {
2014  // TODO remove scrollTo once focus options gets more support
2015  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus ...
2016  //    #Browser_compatibility
2017  var prevScrollY = window.pageYOffset;
2018  this.element.focus({ preventScroll: true });
2019  // hack to fix scroll jump after focus, #76
2020  if ( window.pageYOffset != prevScrollY ) {
2021    window.scrollTo( window.pageXOffset, prevScrollY );
2022  }
2023};
2024
2025// -------------------------- destroy -------------------------- //
2026
2027// deactivate all Flickity functionality, but keep stuff available
2028proto.deactivate = function() {
2029  if ( !this.isActive ) {
2030    return;
2031  }
2032  this.element.classList.remove('flickity-enabled');
2033  this.element.classList.remove('flickity-rtl');
2034  this.unselectSelectedSlide();
2035  // destroy cells
2036  this.cells.forEach( function( cell ) {
2037    cell.destroy();
2038  } );
2039  this.element.removeChild( this.viewport );
2040  // move child elements back into element
2041  moveElements( this.slider.children, this.element );
2042  if ( this.options.accessibility ) {
2043    this.element.removeAttribute('tabIndex');
2044    this.element.removeEventListener( 'keydown', this );
2045  }
2046  // set flags
2047  this.isActive = false;
2048  this.emitEvent('deactivate');
2049};
2050
2051proto.destroy = function() {
2052  this.deactivate();
2053  window.removeEventListener( 'resize', this );
2054  this.allOff();
2055  this.emitEvent('destroy');
2056  if ( jQuery && this.$element ) {
2057    jQuery.removeData( this.element, 'flickity' );
2058  }
2059  delete this.element.flickityGUID;
2060  delete instances[ this.guid ];
2061};
2062
2063// -------------------------- prototype -------------------------- //
2064
2065utils.extend( proto, animatePrototype );
2066
2067// -------------------------- extras -------------------------- //
2068
2069/**
2070 * get Flickity instance from element
2071 * @param {[Element, String]} elem - element or selector string
2072 * @returns {Flickity} - Flickity instance
2073 */
2074Flickity.data = function( elem ) {
2075  elem = utils.getQueryElement( elem );
2076  var id = elem && elem.flickityGUID;
2077  return id && instances[ id ];
2078};
2079
2080utils.htmlInit( Flickity, 'flickity' );
2081
2082if ( jQuery && jQuery.bridget ) {
2083  jQuery.bridget( 'flickity', Flickity );
2084}
2085
2086// set internal jQuery, for Webpack + jQuery v3, #478
2087Flickity.setJQuery = function( jq ) {
2088  jQuery = jq;
2089};
2090
2091Flickity.Cell = Cell;
2092Flickity.Slide = Slide;
2093
2094return Flickity;
2095
2096} ) );
2097
2098/*!
2099 * Unipointer v2.4.0
2100 * base class for doing one thing with pointer event
2101 * MIT license
2102 */
2103
2104/*jshint browser: true, undef: true, unused: true, strict: true */
2105
2106( function( window, factory ) {
2107  // universal module definition
2108  /* jshint strict: false */ /*global define, module, require */
2109  if ( typeof define == 'function' && define.amd ) {
2110    // AMD
2111    define( 'unipointer/unipointer',[
2112      'ev-emitter/ev-emitter'
2113    ], function( EvEmitter ) {
2114      return factory( window, EvEmitter );
2115    });
2116  } else if ( typeof module == 'object' && module.exports ) {
2117    // CommonJS
2118    module.exports = factory(
2119      window,
2120      require('ev-emitter')
2121    );
2122  } else {
2123    // browser global
2124    window.Unipointer = factory(
2125      window,
2126      window.EvEmitter
2127    );
2128  }
2129
2130}( window, function factory( window, EvEmitter ) {
2131
2132
2133
2134function noop() {}
2135
2136function Unipointer() {}
2137
2138// inherit EvEmitter
2139var proto = Unipointer.prototype = Object.create( EvEmitter.prototype );
2140
2141proto.bindStartEvent = function( elem ) {
2142  this._bindStartEvent( elem, true );
2143};
2144
2145proto.unbindStartEvent = function( elem ) {
2146  this._bindStartEvent( elem, false );
2147};
2148
2149/**
2150 * Add or remove start event
2151 * @param {Boolean} isAdd - remove if falsey
2152 */
2153proto._bindStartEvent = function( elem, isAdd ) {
2154  // munge isAdd, default to true
2155  isAdd = isAdd === undefined ? true : isAdd;

2156  var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener';
2157
2158  // default to mouse events
2159  var startEvent = 'mousedown';
2160  if ( 'ontouchstart' in window ) {
2161    // HACK prefer Touch Events as you can preventDefault on touchstart to
2162    // disable scroll in iOS & mobile Chrome metafizzy/flickity#1177
2163    startEvent = 'touchstart';
2164  } else if ( window.PointerEvent ) {
2165    // Pointer Events
2166    startEvent = 'pointerdown';
2167  }
2168  elem[ bindMethod ]( startEvent, this );
2169};
2170
2171// trigger handler methods for events
2172proto.handleEvent = function( event ) {
2173  var method = 'on' + event.type;
2174  if ( this[ method ] ) {
2175    this[ method ]( event );
2176  }
2177};
2178
2179// returns the touch that we're keeping track of
2180proto.getTouch = function( touches ) {
2181  for ( var i=0; i < touches.length; i++ ) {
2182    var touch = touches[i];
2183    if ( touch.identifier == this.pointerIdentifier ) {
2184      return touch;
2185    }
2186  }
2187};
2188
2189// ----- start event ----- //
2190
2191proto.onmousedown = function( event ) {
2192  // dismiss clicks from right or middle buttons
2193  var button = event.button;
2194  if ( button && ( button !== 0 && button !== 1 ) ) {
2195    return;
2196  }
2197  this._pointerDown( event, event );
2198};
2199
2200proto.ontouchstart = function( event ) {
2201  this._pointerDown( event, event.changedTouches[0] );
2202};
2203
2204proto.onpointerdown = function( event ) {
2205  this._pointerDown( event, event );
2206};
2207
2208/**
2209 * pointer start
2210 * @param {Event} event
2211 * @param {Event or Touch} pointer
2212 */
2213proto._pointerDown = function( event, pointer ) {
2214  // dismiss right click and other pointers
2215  // button = 0 is okay, 1-4 not
2216  if ( event.button || this.isPointerDown ) {
2217    return;
2218  }
2219
2220  this.isPointerDown = true;
2221  // save pointer identifier to match up touch events
2222  this.pointerIdentifier = pointer.pointerId !== undefined ?
2223    // pointerId for pointer events, touch.indentifier for touch events
2224    pointer.pointerId : pointer.identifier;
2225
2226  this.pointerDown( event, pointer );
2227};
2228
2229proto.pointerDown = function( event, pointer ) {
2230  this._bindPostStartEvents( event );
2231  this.emitEvent( 'pointerDown', [ event, pointer ] );
2232};
2233
2234// hash of events to be bound after start event
2235var postStartEvents = {
2236  mousedown: [ 'mousemove', 'mouseup' ],
2237  touchstart: [ 'touchmove', 'touchend', 'touchcancel' ],
2238  pointerdown: [ 'pointermove', 'pointerup', 'pointercancel' ],
2239};
2240
2241proto._bindPostStartEvents = function( event ) {
2242  if ( !event ) {
2243    return;
2244  }
2245  // get proper events to match start event
2246  var events = postStartEvents[ event.type ];
2247  // bind events to node
2248  events.forEach( function( eventName ) {
2249    window.addEventListener( eventName, this );
2250  }, this );
2251  // save these arguments
2252  this._boundPointerEvents = events;
2253};
2254
2255proto._unbindPostStartEvents = function() {
2256  // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug)
2257  if ( !this._boundPointerEvents ) {
2258    return;
2259  }
2260  this._boundPointerEvents.forEach( function( eventName ) {
2261    window.removeEventListener( eventName, this );
2262  }, this );
2263
2264  delete this._boundPointerEvents;
2265};
2266
2267// ----- move event ----- //
2268
2269proto.onmousemove = function( event ) {
2270  this._pointerMove( event, event );
2271};
2272
2273proto.onpointermove = function( event ) {
2274  if ( event.pointerId == this.pointerIdentifier ) {
2275    this._pointerMove( event, event );
2276  }
2277};
2278
2279proto.ontouchmove = function( event ) {
2280  var touch = this.getTouch( event.changedTouches );
2281  if ( touch ) {
2282    this._pointerMove( event, touch );
2283  }
2284};
2285
2286/**
2287 * pointer move
2288 * @param {Event} event
2289 * @param {Event or Touch} pointer
2290 * @private
2291 */
2292proto._pointerMove = function( event, pointer ) {
2293  this.pointerMove( event, pointer );
2294};
2295
2296// public
2297proto.pointerMove = function( event, pointer ) {
2298  this.emitEvent( 'pointerMove', [ event, pointer ] );
2299};
2300
2301// ----- end event ----- //
2302
2303
2304proto.onmouseup = function( event ) {
2305  this._pointerUp( event, event );
2306};
2307
2308proto.onpointerup = function( event ) {
2309  if ( event.pointerId == this.pointerIdentifier ) {
2310    this._pointerUp( event, event );
2311  }
2312};
2313
2314proto.ontouchend = function( event ) {
2315  var touch = this.getTouch( event.changedTouches );
2316  if ( touch ) {
2317    this._pointerUp( event, touch );
2318  }
2319};
2320
2321/**
2322 * pointer up
2323 * @param {Event} event
2324 * @param {Event or Touch} pointer
2325 * @private
2326 */
2327proto._pointerUp = function( event, pointer ) {
2328  this._pointerDone();
2329  this.pointerUp( event, pointer );
2330};
2331
2332// public
2333proto.pointerUp = function( event, pointer ) {
2334  this.emitEvent( 'pointerUp', [ event, pointer ] );
2335};

2336
2337// ----- pointer done ----- //
2338
2339// triggered on pointer up & pointer cancel
2340proto._pointerDone = function() {
2341  this._pointerReset();
2342  this._unbindPostStartEvents();
2343  this.pointerDone();
2344};
2345
2346proto._pointerReset = function() {
2347  // reset properties
2348  this.isPointerDown = false;
2349  delete this.pointerIdentifier;
2350};
2351
2352proto.pointerDone = noop;
2353
2354// ----- pointer cancel ----- //
2355
2356proto.onpointercancel = function( event ) {
2357  if ( event.pointerId == this.pointerIdentifier ) {
2358    this._pointerCancel( event, event );
2359  }
2360};
2361
2362proto.ontouchcancel = function( event ) {
2363  var touch = this.getTouch( event.changedTouches );
2364  if ( touch ) {
2365    this._pointerCancel( event, touch );
2366  }
2367};
2368
2369/**
2370 * pointer cancel
2371 * @param {Event} event
2372 * @param {Event or Touch} pointer
2373 * @private
2374 */
2375proto._pointerCancel = function( event, pointer ) {
2376  this._pointerDone();
2377  this.pointerCancel( event, pointer );
2378};
2379
2380// public
2381proto.pointerCancel = function( event, pointer ) {
2382  this.emitEvent( 'pointerCancel', [ event, pointer ] );
2383};
2384
2385// -----  ----- //
2386
2387// utility function for getting x/y coords from event
2388Unipointer.getPointerPoint = function( pointer ) {
2389  return {
2390    x: pointer.pageX,
2391    y: pointer.pageY
2392  };
2393};
2394
2395// -----  ----- //
2396
2397return Unipointer;
2398
2399}));
2400
2401/*!
2402 * Unidragger v2.4.0
2403 * Draggable base class
2404 * MIT license
2405 */
2406
2407/*jshint browser: true, unused: true, undef: true, strict: true */
2408
2409( function( window, factory ) {
2410  // universal module definition
2411  /*jshint strict: false */ /*globals define, module, require */
2412
2413  if ( typeof define == 'function' && define.amd ) {
2414    // AMD
2415    define( 'unidragger/unidragger',[
2416      'unipointer/unipointer'
2417    ], function( Unipointer ) {
2418      return factory( window, Unipointer );
2419    });
2420  } else if ( typeof module == 'object' && module.exports ) {
2421    // CommonJS
2422    module.exports = factory(
2423      window,
2424      require('unipointer')
2425    );
2426  } else {
2427    // browser global
2428    window.Unidragger = factory(
2429      window,
2430      window.Unipointer
2431    );
2432  }
2433
2434}( window, function factory( window, Unipointer ) {
2435
2436
2437
2438// -------------------------- Unidragger -------------------------- //
2439
2440function Unidragger() {}
2441
2442// inherit Unipointer & EvEmitter
2443var proto = Unidragger.prototype = Object.create( Unipointer.prototype );
2444
2445// ----- bind start ----- //
2446
2447proto.bindHandles = function() {
2448  this._bindHandles( true );
2449};
2450
2451proto.unbindHandles = function() {
2452  this._bindHandles( false );
2453};
2454
2455/**
2456 * Add or remove start event
2457 * @param {Boolean} isAdd
2458 */
2459proto._bindHandles = function( isAdd ) {
2460  // munge isAdd, default to true
2461  isAdd = isAdd === undefined ? true : isAdd;

2462  // bind each handle
2463  var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener';
2464  var touchAction = isAdd ? this._touchActionValue : '';
2465  for ( var i=0; i < this.handles.length; i++ ) {
2466    var handle = this.handles[i];
2467    this._bindStartEvent( handle, isAdd );
2468    handle[ bindMethod ]( 'click', this );
2469    // touch-action: none to override browser touch gestures. metafizzy/flickity#540
2470    if ( window.PointerEvent ) {
2471      handle.style.touchAction = touchAction;
2472    }
2473  }
2474};
2475
2476// prototype so it can be overwriteable by Flickity
2477proto._touchActionValue = 'none';
2478
2479// ----- start event ----- //
2480
2481/**
2482 * pointer start
2483 * @param {Event} event
2484 * @param {Event or Touch} pointer
2485 */
2486proto.pointerDown = function( event, pointer ) {
2487  var isOkay = this.okayPointerDown( event );
2488  if ( !isOkay ) {
2489    return;
2490  }
2491  // track start event position
2492  // Safari 9 overrides pageX and pageY. These values needs to be copied. flickity#842
2493  this.pointerDownPointer = {
2494    pageX: pointer.pageX,
2495    pageY: pointer.pageY,
2496  };
2497
2498  event.preventDefault();
2499  this.pointerDownBlur();
2500  // bind move and end events
2501  this._bindPostStartEvents( event );
2502  this.emitEvent( 'pointerDown', [ event, pointer ] );
2503};
2504
2505// nodes that have text fields
2506var cursorNodes = {
2507  TEXTAREA: true,
2508  INPUT: true,
2509  SELECT: true,
2510  OPTION: true,
2511};
2512
2513// input types that do not have text fields
2514var clickTypes = {
2515  radio: true,
2516  checkbox: true,
2517  button: true,
2518  submit: true,
2519  image: true,
2520  file: true,
2521};
2522
2523// dismiss inputs with text fields. flickity#403, flickity#404
2524proto.okayPointerDown = function( event ) {
2525  var isCursorNode = cursorNodes[ event.target.nodeName ];
2526  var isClickType = clickTypes[ event.target.type ];
2527  var isOkay = !isCursorNode || isClickType;
2528  if ( !isOkay ) {
2529    this._pointerReset();
2530  }
2531  return isOkay;
2532};
2533
2534// kludge to blur previously focused input
2535proto.pointerDownBlur = function() {
2536  var focused = document.activeElement;
2537  // do not blur body for IE10, metafizzy/flickity#117
2538  var canBlur = focused && focused.blur && focused != document.body;
2539  if ( canBlur ) {
2540    focused.blur();
2541  }
2542};
2543
2544// ----- move event ----- //
2545
2546/**
2547 * drag move
2548 * @param {Event} event
2549 * @param {Event or Touch} pointer
2550 */
2551proto.pointerMove = function( event, pointer ) {
2552  var moveVector = this._dragPointerMove( event, pointer );
2553  this.emitEvent( 'pointerMove', [ event, pointer, moveVector ] );
2554  this._dragMove( event, pointer, moveVector );
2555};
2556
2557// base pointer move logic
2558proto._dragPointerMove = function( event, pointer ) {
2559  var moveVector = {
2560    x: pointer.pageX - this.pointerDownPointer.pageX,
2561    y: pointer.pageY - this.pointerDownPointer.pageY
2562  };
2563  // start drag if pointer has moved far enough to start drag
2564  if ( !this.isDragging && this.hasDragStarted( moveVector ) ) {
2565    this._dragStart( event, pointer );
2566  }
2567  return moveVector;
2568};
2569
2570// condition if pointer has moved far enough to start drag
2571proto.hasDragStarted = function( moveVector ) {
2572  return Math.abs( moveVector.x ) > 3 || Math.abs( moveVector.y ) > 3;
2573};
2574
2575// ----- end event ----- //
2576
2577/**
2578 * pointer up
2579 * @param {Event} event
2580 * @param {Event or Touch} pointer
2581 */
2582proto.pointerUp = function( event, pointer ) {
2583  this.emitEvent( 'pointerUp', [ event, pointer ] );
2584  this._dragPointerUp( event, pointer );
2585};
2586
2587proto._dragPointerUp = function( event, pointer ) {
2588  if ( this.isDragging ) {
2589    this._dragEnd( event, pointer );
2590  } else {
2591    // pointer didn't move enough for drag to start
2592    this._staticClick( event, pointer );
2593  }
2594};
2595
2596// -------------------------- drag -------------------------- //
2597
2598// dragStart
2599proto._dragStart = function( event, pointer ) {
2600  this.isDragging = true;
2601  // prevent clicks

2602  this.isPreventingClicks = true;
2603  this.dragStart( event, pointer );
2604};
2605
2606proto.dragStart = function( event, pointer ) {
2607  this.emitEvent( 'dragStart', [ event, pointer ] );
2608};
2609
2610// dragMove
2611proto._dragMove = function( event, pointer, moveVector ) {
2612  // do not drag if not dragging yet
2613  if ( !this.isDragging ) {
2614    return;
2615  }
2616
2617  this.dragMove( event, pointer, moveVector );
2618};
2619
2620proto.dragMove = function( event, pointer, moveVector ) {
2621  event.preventDefault();
2622  this.emitEvent( 'dragMove', [ event, pointer, moveVector ] );
2623};
2624
2625// dragEnd
2626proto._dragEnd = function( event, pointer ) {
2627  // set flags
2628  this.isDragging = false;
2629  // re-enable clicking async
2630  setTimeout( function() {
2631    delete this.isPreventingClicks;
2632  }.bind( this ) );
2633
2634  this.dragEnd( event, pointer );
2635};
2636
2637proto.dragEnd = function( event, pointer ) {
2638  this.emitEvent( 'dragEnd', [ event, pointer ] );
2639};
2640
2641// ----- onclick ----- //
2642
2643// handle all clicks and prevent clicks when dragging
2644proto.onclick = function( event ) {

2645  if ( this.isPreventingClicks ) {
2646    event.preventDefault();
2647  }
2648};
2649
2650// ----- staticClick ----- //
2651
2652// triggered after pointer down & up with no/tiny movement
2653proto._staticClick = function( event, pointer ) {
2654  // ignore emulated mouse up clicks
2655  if ( this.isIgnoringMouseUp && event.type == 'mouseup' ) {
2656    return;
2657  }
2658
2659  this.staticClick( event, pointer );
2660
2661  // set flag for emulated clicks 300ms after touchend
2662  if ( event.type != 'mouseup' ) {
2663    this.isIgnoringMouseUp = true;
2664    // reset flag after 300ms
2665    setTimeout( function() {
2666      delete this.isIgnoringMouseUp;
2667    }.bind( this ), 400 );
2668  }
2669};
2670
2671proto.staticClick = function( event, pointer ) {
2672  this.emitEvent( 'staticClick', [ event, pointer ] );
2673};
2674
2675// ----- utils ----- //
2676
2677Unidragger.getPointerPoint = Unipointer.getPointerPoint;
2678
2679// -----  ----- //
2680
2681return Unidragger;
2682
2683}));
2684
2685// drag
2686( function( window, factory ) {
2687  // universal module definition
2688  if ( typeof define == 'function' && define.amd ) {
2689    // AMD
2690    define( 'flickity/js/drag',[
2691      './flickity',
2692      'unidragger/unidragger',
2693      'fizzy-ui-utils/utils',
2694    ], function( Flickity, Unidragger, utils ) {
2695      return factory( window, Flickity, Unidragger, utils );
2696    } );
2697  } else if ( typeof module == 'object' && module.exports ) {
2698    // CommonJS
2699    module.exports = factory(
2700        window,
2701        require('./flickity'),
2702        require('unidragger'),
2703        require('fizzy-ui-utils')
2704    );
2705  } else {
2706    // browser global
2707    window.Flickity = factory(
2708        window,
2709        window.Flickity,
2710        window.Unidragger,
2711        window.fizzyUIUtils
2712    );
2713  }
2714
2715}( window, function factory( window, Flickity, Unidragger, utils ) {
2716
2717
2718
2719// ----- defaults ----- //
2720
2721utils.extend( Flickity.defaults, {
2722  draggable: '>1',
2723  dragThreshold: 3,
2724} );
2725
2726// ----- create ----- //
2727
2728Flickity.createMethods.push('_createDrag');
2729
2730// -------------------------- drag prototype -------------------------- //
2731
2732var proto = Flickity.prototype;
2733utils.extend( proto, Unidragger.prototype );
2734proto._touchActionValue = 'pan-y';
2735
2736// --------------------------  -------------------------- //
2737
2738proto._createDrag = function() {
2739  this.on( 'activate', this.onActivateDrag );
2740  this.on( 'uiChange', this._uiChangeDrag );
2741  this.on( 'deactivate', this.onDeactivateDrag );
2742  this.on( 'cellChange', this.updateDraggable );
2743  // TODO updateDraggable on resize? if groupCells & slides change
2744};
2745
2746proto.onActivateDrag = function() {
2747  this.handles = [ this.viewport ];
2748  this.bindHandles();
2749  this.updateDraggable();
2750};
2751
2752proto.onDeactivateDrag = function() {
2753  this.unbindHandles();
2754  this.element.classList.remove('is-draggable');
2755};