https://rectorarosadeves.cl/wp-content/themes/salient/js/build/third-party/flickity.min.js?ver=2.2.2

1/*!
2 * Flickity PACKAGED v2.1.2
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-2018 Metafizzy

9
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      

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

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

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

1514  cells.forEach( function( cell ) {
1515    cell.getSize();
1516  });
1517};
1518
1519// --------------------------  -------------------------- //
1520
1521proto.updateSlides = function() {
1522  this.slides = [];
1523  if ( !this.cells.length ) {
1524    return;
1525  }
1526
1527  var slide = new Slide( this );
1528  this.slides.push( slide );
1529  var isOriginLeft = this.originSide == 'left';
1530  var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
1531
1532  var canCellFit = this._getCanCellFit();
1533
1534  this.cells.forEach( function( cell, i ) {
1535    // just add cell if first cell in slide
1536    if ( !slide.cells.length ) {
1537      slide.addCell( cell );
1538      return;
1539    }
1540
1541    var slideWidth = ( slide.outerWidth - slide.firstMargin ) +
1542      ( cell.size.outerWidth - cell.size[ nextMargin ] );
1543
1544    if ( canCellFit.call( this, i, slideWidth ) ) {
1545      slide.addCell( cell );
1546    } else {
1547      // doesn't fit, new slide
1548      slide.updateTarget();
1549
1550      slide = new Slide( this );
1551      this.slides.push( slide );
1552      slide.addCell( cell );
1553    }
1554  }, this );
1555  // last slide
1556  slide.updateTarget();
1557  // update .selectedSlide
1558  this.updateSelectedSlide();
1559};
1560
1561proto._getCanCellFit = function() {
1562  var groupCells = this.options.groupCells;
1563  if ( !groupCells ) {
1564    return function() {
1565      return false;
1566    };
1567  } else if ( typeof groupCells == 'number' ) {
1568    // group by number. 3 -> [0,1,2], [3,4,5], ...
1569    var number = parseInt( groupCells, 10 );
1570    return function( i ) {
1571      return ( i % number ) !== 0;
1572    };
1573  }
1574  // default, group by width of slide
1575  // parse '75%
1576  var percentMatch = typeof groupCells == 'string' &&
1577    groupCells.match(/^(\d+)%$/);
1578  var percent = percentMatch ? parseInt( percentMatch[1], 10 ) / 100 : 1;
1579  return function( i, slideWidth ) {
1580    return slideWidth <= ( this.size.innerWidth + 1 ) * percent;
1581  };
1582};
1583
1584// alias _init for jQuery plugin .flickity()
1585proto._init =
1586proto.reposition = function() {
1587  this.positionCells();
1588  this.positionSliderAtSelected();
1589};
1590
1591proto.getSize = function() {
1592  this.size = getSize( this.element );
1593  this.setCellAlign();
1594  this.cursorPosition = this.size.innerWidth * this.cellAlign;
1595};
1596
1597var cellAlignShorthands = {
1598  // cell align, then based on origin side
1599  center: {
1600    left: 0.5,
1601    right: 0.5
1602  },
1603  left: {
1604    left: 0,
1605    right: 1
1606  },
1607  right: {
1608    right: 0,
1609    left: 1
1610  }
1611};
1612
1613proto.setCellAlign = function() {
1614  var shorthand = cellAlignShorthands[ this.options.cellAlign ];
1615  this.cellAlign = shorthand ? shorthand[ this.originSide ] : this.options.cellAlign;
1616};
1617
1618proto.setGallerySize = function() {
1619  if ( this.options.setGallerySize ) {
1620    var height = this.options.adaptiveHeight && this.selectedSlide ?
1621      this.selectedSlide.height : this.maxCellHeight;
1622    this.viewport.style.height = height + 'px';
1623  }
1624};
1625
1626proto._getWrapShiftCells = function() {
1627  // only for wrap-around
1628  if ( !this.options.wrapAround ) {
1629    return;
1630  }
1631  // unshift previous cells
1632  this._unshiftCells( this.beforeShiftCells );
1633  this._unshiftCells( this.afterShiftCells );
1634  // get before cells
1635  // initial gap
1636  var gapX = this.cursorPosition;
1637  var cellIndex = this.cells.length - 1;
1638  this.beforeShiftCells = this._getGapCells( gapX, cellIndex, -1 );
1639  // get after cells
1640  // ending gap between last cell and end of gallery viewport
1641  gapX = this.size.innerWidth - this.cursorPosition;
1642  // start cloning at first cell, working forwards
1643  this.afterShiftCells = this._getGapCells( gapX, 0, 1 );
1644};
1645
1646proto._getGapCells = function( gapX, cellIndex, increment ) {
1647  // keep adding cells until the cover the initial gap
1648  var cells = [];
1649  while ( gapX > 0 ) {
1650    var cell = this.cells[ cellIndex ];
1651    if ( !cell ) {
1652      break;
1653    }
1654    cells.push( cell );
1655    cellIndex += increment;
1656    gapX -= cell.size.outerWidth;
1657  }
1658  return cells;
1659};
1660
1661// ----- contain ----- //
1662
1663// contain cell targets so no excess sliding
1664proto._containSlides = function() {
1665  if ( !this.options.contain || this.options.wrapAround || !this.cells.length ) {
1666    return;
1667  }
1668  var isRightToLeft = this.options.rightToLeft;
1669  var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
1670  var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
1671  var contentWidth = this.slideableWidth - this.getLastCell().size[ endMargin ];
1672  // content is less than gallery size
1673  var isContentSmaller = contentWidth < this.size.innerWidth;
1674  // bounds
1675  var beginBound = this.cursorPosition + this.cells[0].size[ beginMargin ];
1676  var endBound = contentWidth - this.size.innerWidth * ( 1 - this.cellAlign );
1677  // contain each cell target

1678  this.slides.forEach( function( slide ) {
1679    if ( isContentSmaller ) {
1680      // all cells fit inside gallery
1681      slide.target = contentWidth * this.cellAlign;
1682    } else {
1683      // contain to bounds
1684      slide.target = Math.max( slide.target, beginBound );
1685      slide.target = Math.min( slide.target, endBound );
1686    }
1687  }, this );
1688};
1689
1690// -----  ----- //
1691
1692/**
1693 * emits events via eventEmitter and jQuery events
1694 * @param {String} type - name of event
1695 * @param {Event} event - original event
1696 * @param {Array} args - extra arguments
1697 */
1698proto.dispatchEvent = function( type, event, args ) {
1699  var emitArgs = event ? [ event ].concat( args ) : args;
1700  this.emitEvent( type, emitArgs );
1701
1702  if ( jQuery && this.$element ) {
1703    // default trigger with type if no event
1704    type += this.options.namespaceJQueryEvents ? '.flickity' : '';
1705    var $event = type;
1706    if ( event ) {
1707      // create jQuery event
1708      var jQEvent = new jQuery.Event( event );
1709      jQEvent.type = type;
1710      $event = jQEvent;
1711    }
1712    this.$element.trigger( $event, args );
1713  }
1714};
1715
1716// -------------------------- select -------------------------- //
1717
1718/**
1719 * @param {Integer} index - index of the slide
1720 * @param {Boolean} isWrap - will wrap-around to last/first if at the end
1721 * @param {Boolean} isInstant - will immediately set position at selected cell
1722 */
1723proto.select = function( index, isWrap, isInstant ) {
1724  if ( !this.isActive ) {
1725    return;
1726  }
1727  index = parseInt( index, 10 );
1728  this._wrapSelect( index );
1729
1730  if ( this.options.wrapAround || isWrap ) {
1731    index = utils.modulo( index, this.slides.length );
1732  }
1733  // bail if invalid index
1734  if ( !this.slides[ index ] ) {
1735    return;
1736  }
1737  var prevIndex = this.selectedIndex;
1738  this.selectedIndex = index;
1739  this.updateSelectedSlide();
1740  if ( isInstant ) {
1741    this.positionSliderAtSelected();
1742  } else {
1743    this.startAnimation();
1744  }
1745  if ( this.options.adaptiveHeight ) {
1746    this.setGallerySize();
1747  }
1748  // events
1749  this.dispatchEvent( 'select', null, [ index ] );
1750  // change event if new index
1751  if ( index != prevIndex ) {
1752    this.dispatchEvent( 'change', null, [ index ] );
1753  }
1754  // old v1 event name, remove in v3
1755  this.dispatchEvent('cellSelect');
1756};
1757
1758// wraps position for wrapAround, to move to closest slide. #113
1759proto._wrapSelect = function( index ) {
1760  var len = this.slides.length;
1761  var isWrapping = this.options.wrapAround && len > 1;
1762  if ( !isWrapping ) {
1763    return index;
1764  }
1765  var wrapIndex = utils.modulo( index, len );
1766  // go to shortest
1767  var delta = Math.abs( wrapIndex - this.selectedIndex );
1768  var backWrapDelta = Math.abs( ( wrapIndex + len ) - this.selectedIndex );
1769  var forewardWrapDelta = Math.abs( ( wrapIndex - len ) - this.selectedIndex );
1770  if ( !this.isDragSelect && backWrapDelta < delta ) {
1771    index += len;
1772  } else if ( !this.isDragSelect && forewardWrapDelta < delta ) {
1773    index -= len;
1774  }
1775  // wrap position so slider is within normal area
1776  if ( index < 0 ) {
1777    this.x -= this.slideableWidth;
1778  } else if ( index >= len ) {
1779    this.x += this.slideableWidth;
1780  }
1781};
1782
1783proto.previous = function( isWrap, isInstant ) {
1784  this.select( this.selectedIndex - 1, isWrap, isInstant );
1785};
1786
1787proto.next = function( isWrap, isInstant ) {
1788  this.select( this.selectedIndex + 1, isWrap, isInstant );
1789};
1790
1791proto.updateSelectedSlide = function() {
1792  var slide = this.slides[ this.selectedIndex ];
1793  // selectedIndex could be outside of slides, if triggered before resize()
1794  if ( !slide ) {
1795    return;
1796  }
1797  // unselect previous selected slide
1798  this.unselectSelectedSlide();
1799  // update new selected slide
1800  this.selectedSlide = slide;
1801  slide.select();
1802  this.selectedCells = slide.cells;
1803  this.selectedElements = slide.getCellElements();
1804  // HACK: selectedCell & selectedElement is first cell in slide, backwards compatibility
1805  // Remove in v3?
1806  this.selectedCell = slide.cells[0];
1807  this.selectedElement = this.selectedElements[0];
1808};
1809
1810proto.unselectSelectedSlide = function() {
1811  if ( this.selectedSlide ) {
1812    this.selectedSlide.unselect();
1813  }
1814};
1815
1816/**
1817 * select slide from number or cell element
1818 * @param {Element or Number} elem
1819 */
1820proto.selectCell = function( value, isWrap, isInstant ) {
1821  // get cell
1822  var cell = this.queryCell( value );
1823  if ( !cell ) {
1824    return;
1825  }
1826
1827  var index = this.getCellSlideIndex( cell );
1828  this.select( index, isWrap, isInstant );
1829};
1830
1831proto.getCellSlideIndex = function( cell ) {
1832  // get index of slides that has cell
1833  for ( var i=0; i < this.slides.length; i++ ) {
1834    var slide = this.slides[i];
1835    var index = slide.cells.indexOf( cell );
1836    if ( index != -1 ) {
1837      return i;
1838    }
1839  }
1840};
1841
1842// -------------------------- get cells -------------------------- //
1843
1844/**
1845 * get Flickity.Cell, given an Element
1846 * @param {Element} elem
1847 * @returns {Flickity.Cell} item
1848 */
1849proto.getCell = function( elem ) {
1850  // loop through cells to get the one that matches
1851  for ( var i=0; i < this.cells.length; i++ ) {
1852    var cell = this.cells[i];
1853    if ( cell.element == elem ) {
1854      return cell;
1855    }
1856  }
1857};
1858
1859/**
1860 * get collection of Flickity.Cells, given Elements
1861 * @param {Element, Array, NodeList} elems
1862 * @returns {Array} cells - Flickity.Cells
1863 */
1864proto.getCells = function( elems ) {
1865  elems = utils.makeArray( elems );
1866  var cells = [];

1867  elems.forEach( function( elem ) {
1868    var cell = this.getCell( elem );
1869    if ( cell ) {
1870      cells.push( cell );
1871    }
1872  }, this );
1873  return cells;
1874};
1875
1876/**
1877 * get cell elements
1878 * @returns {Array} cellElems
1879 */
1880proto.getCellElements = function() {
1881  return this.cells.map( function( cell ) {
1882    return cell.element;
1883  });
1884};
1885
1886/**
1887 * get parent cell from an element
1888 * @param {Element} elem
1889 * @returns {Flickit.Cell} cell
1890 */
1891proto.getParentCell = function( elem ) {
1892  // first check if elem is cell
1893  var cell = this.getCell( elem );
1894  if ( cell ) {
1895    return cell;
1896  }
1897  // try to get parent cell elem
1898  elem = utils.getParent( elem, '.flickity-slider > *' );
1899  return this.getCell( elem );
1900};
1901
1902/**
1903 * get cells adjacent to a slide
1904 * @param {Integer} adjCount - number of adjacent slides
1905 * @param {Integer} index - index of slide to start
1906 * @returns {Array} cells - array of Flickity.Cells
1907 */
1908proto.getAdjacentCellElements = function( adjCount, index ) {
1909  if ( !adjCount ) {
1910    return this.selectedSlide.getCellElements();
1911  }
1912  index = index === undefined ? this.selectedIndex : index;
1913
1914  var len = this.slides.length;
1915  if ( 1 + ( adjCount * 2 ) >= len ) {
1916    return this.getCellElements();
1917  }
1918
1919  var cellElems = [];
1920  for ( var i = index - adjCount; i <= index + adjCount ; i++ ) {
1921    var slideIndex = this.options.wrapAround ? utils.modulo( i, len ) : i;
1922    var slide = this.slides[ slideIndex ];
1923    if ( slide ) {
1924      cellElems = cellElems.concat( slide.getCellElements() );
1925    }
1926  }
1927  return cellElems;
1928};
1929
1930/**
1931 * select slide from number or cell element
1932 * @param {Element, Selector String, or Number} selector
1933 */
1934proto.queryCell = function( selector ) {
1935  if ( typeof selector == 'number' ) {
1936    // use number as index
1937    return this.cells[ selector ];
1938  }
1939  if ( typeof selector == 'string' ) {
1940    // use string as selector, get element
1941    selector = this.element.querySelector( selector );
1942  }
1943  // get cell from element
1944  return this.getCell( selector );
1945};
1946
1947// -------------------------- events -------------------------- //
1948
1949proto.uiChange = function() {
1950  this.emitEvent('uiChange');
1951};
1952
1953proto.childUIPointerDown = function( event ) {
1954  this.emitEvent( 'childUIPointerDown', [ event ] );
1955};
1956
1957// ----- resize ----- //
1958
1959proto.onresize = function() {
1960  this.watchCSS();
1961  this.resize();
1962};
1963
1964utils.debounceMethod( Flickity, 'onresize', 150 );
1965
1966proto.resize = function() {
1967  /* nectar addition to check for this.isAnimating for iOS15 fix  */
1968
1969  if ( !this.isActive || this.isAnimating ) {
1970    return;
1971  }
1972  this.getSize();
1973  // wrap values
1974  if ( this.options.wrapAround ) {
1975    this.x = utils.modulo( this.x, this.slideableWidth );
1976  }
1977  this.positionCells();
1978  this._getWrapShiftCells();
1979  this.setGallerySize();
1980  this.emitEvent('resize');
1981  // update selected index for group slides, instant
1982  // TODO: position can be lost between groups of various numbers
1983  var selectedElement = this.selectedElements && this.selectedElements[0];
1984  this.selectCell( selectedElement, false, true );
1985};
1986
1987// watches the :after property, activates/deactivates
1988proto.watchCSS = function() {
1989  var watchOption = this.options.watchCSS;
1990  if ( !watchOption ) {
1991    return;
1992  }
1993
1994  var afterContent = getComputedStyle( this.element, ':after' ).content;
1995  // activate if :after { content: 'flickity' }
1996  if ( afterContent.indexOf('flickity') != -1 ) {
1997    this.activate();
1998  } else {
1999    this.deactivate();
2000  }
2001};
2002
2003// ----- keydown ----- //
2004
2005// go previous/next if left/right keys pressed
2006proto.onkeydown = function( event ) {
2007  // only work if element is in focus
2008  var isNotFocused = document.activeElement && document.activeElement != this.element;
2009  if ( !this.options.accessibility ||isNotFocused ) {
2010    return;
2011  }
2012
2013  var handler = Flickity.keyboardHandlers[ event.keyCode ];
2014  if ( handler ) {
2015    handler.call( this );
2016  }
2017};
2018
2019Flickity.keyboardHandlers = {
2020  // left arrow
2021  37: function() {
2022    var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
2023    this.uiChange();
2024    this[ leftMethod ]();
2025  },
2026  // right arrow
2027  39: function() {
2028    var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
2029    this.uiChange();
2030    this[ rightMethod ]();
2031  },
2032};
2033
2034// ----- focus ----- //
2035
2036proto.focus = function() {
2037  // TODO remove scrollTo once focus options gets more support
2038  // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#Browser_compatibility
2039  var prevScrollY = window.pageYOffset;
2040  this.element.focus({ preventScroll: true });
2041  // hack to fix scroll jump after focus, #76
2042  if ( window.pageYOffset != prevScrollY && prevScrollY > 10 ) { // nectar addition - iframe fix
2043    window.scrollTo( window.pageXOffset, prevScrollY );
2044  }
2045};
2046
2047// -------------------------- destroy -------------------------- //
2048
2049// deactivate all Flickity functionality, but keep stuff available
2050proto.deactivate = function() {
2051  if ( !this.isActive ) {
2052    return;
2053  }
2054  this.element.classList.remove('flickity-enabled');
2055  this.element.classList.remove('flickity-rtl');
2056  this.unselectSelectedSlide();
2057  // destroy cells

2058  this.cells.forEach( function( cell ) {
2059    cell.destroy();
2060  });
2061  this.element.removeChild( this.viewport );
2062  // move child elements back into element
2063  moveElements( this.slider.children, this.element );
2064  if ( this.options.accessibility ) {
2065    this.element.removeAttribute('tabIndex');
2066    this.element.removeEventListener( 'keydown', this );
2067  }
2068  // set flags
2069  this.isActive = false;
2070  this.emitEvent('deactivate');
2071};
2072
2073proto.destroy = function() {
2074  this.deactivate();
2075  window.removeEventListener( 'resize', this );
2076  this.emitEvent('destroy');
2077  if ( jQuery && this.$element ) {
2078    jQuery.removeData( this.element, 'flickity' );
2079  }
2080  delete this.element.flickityGUID;
2081  delete instances[ this.guid ];
2082};
2083
2084// -------------------------- prototype -------------------------- //
2085
2086utils.extend( proto, animatePrototype );
2087
2088// -------------------------- extras -------------------------- //
2089
2090/**
2091 * get Flickity instance from element
2092 * @param {Element} elem
2093 * @returns {Flickity}
2094 */
2095Flickity.data = function( elem ) {
2096  elem = utils.getQueryElement( elem );
2097  var id = elem && elem.flickityGUID;
2098  return id && instances[ id ];
2099};
2100
2101utils.htmlInit( Flickity, 'flickity' );
2102
2103if ( jQuery && jQuery.bridget ) {
2104  jQuery.bridget( 'flickity', Flickity );
2105}
2106
2107// set internal jQuery, for Webpack + jQuery v3, #478
2108Flickity.setJQuery = function( jq ) {
2109  jQuery = jq;
2110};
2111
2112Flickity.Cell = Cell;
2113Flickity.Slide = Slide;
2114
2115return Flickity;
2116
2117}));
2118
2119/*!
2120 * Unipointer v2.3.0
2121 * base class for doing one thing with pointer event
2122 * MIT license
2123 */
2124
2125/*jshint browser: true, undef: true, unused: true, strict: true */
2126
2127( function( window, factory ) {
2128  // universal module definition
2129  /* jshint strict: false */ /*global define, module, require */
2130  if ( typeof define == 'function' && define.amd ) {
2131    // AMD
2132    define( 'unipointer/unipointer',[
2133      'ev-emitter/ev-emitter'
2134    ], function( EvEmitter ) {
2135      return factory( window, EvEmitter );
2136    });
2137  } else if ( typeof module == 'object' && module.exports ) {
2138    // CommonJS
2139    module.exports = factory(
2140      window,
2141      require('ev-emitter')
2142    );
2143  } else {
2144    // browser global
2145    window.Unipointer = factory(
2146      window,
2147      window.EvEmitter
2148    );
2149  }
2150
2151}( window, function factory( window, EvEmitter ) {
2152
2153
2154
2155function noop() {}
2156
2157function Unipointer() {}
2158
2159// inherit EvEmitter
2160var proto = Unipointer.prototype = Object.create( EvEmitter.prototype );
2161
2162proto.bindStartEvent = function( elem ) {
2163  this._bindStartEvent( elem, true );
2164};
2165
2166proto.unbindStartEvent = function( elem ) {
2167  this._bindStartEvent( elem, false );
2168};
2169
2170/**
2171 * Add or remove start event
2172 * @param {Boolean} isAdd - remove if falsey
2173 */
2174proto._bindStartEvent = function( elem, isAdd ) {
2175  // munge isAdd, default to true
2176  isAdd = isAdd === undefined ? true : isAdd;
2177  var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener';
2178
2179  // default to mouse events
2180  var startEvent = 'mousedown';
2181  if ( window.PointerEvent ) {
2182    // Pointer Events
2183    startEvent = 'pointerdown';
2184  } else if ( 'ontouchstart' in window ) {
2185    // Touch Events. iOS Safari
2186    startEvent = 'touchstart';
2187  }
2188  elem[ bindMethod ]( startEvent, this );
2189};
2190
2191// trigger handler methods for events
2192proto.handleEvent = function( event ) {
2193  var method = 'on' + event.type;
2194  if ( this[ method ] ) {
2195    this[ method ]( event );
2196  }
2197};
2198
2199// returns the touch that we're keeping track of
2200proto.getTouch = function( touches ) {
2201  for ( var i=0; i < touches.length; i++ ) {
2202    var touch = touches[i];
2203    if ( touch.identifier == this.pointerIdentifier ) {
2204      return touch;
2205    }
2206  }
2207};
2208
2209// ----- start event ----- //
2210
2211proto.onmousedown = function( event ) {
2212  // dismiss clicks from right or middle buttons
2213  var button = event.button;
2214  if ( button && ( button !== 0 && button !== 1 ) ) {
2215    return;
2216  }
2217  this._pointerDown( event, event );
2218};
2219
2220proto.ontouchstart = function( event ) {
2221  this._pointerDown( event, event.changedTouches[0] );
2222};
2223
2224proto.onpointerdown = function( event ) {
2225  this._pointerDown( event, event );
2226};
2227
2228/**
2229 * pointer start
2230 * @param {Event} event
2231 * @param {Event or Touch} pointer
2232 */
2233proto._pointerDown = function( event, pointer ) {
2234  // dismiss right click and other pointers
2235  // button = 0 is okay, 1-4 not
2236  if ( event.button || this.isPointerDown ) {
2237    return;
2238  }
2239
2240  this.isPointerDown = true;
2241  // save pointer identifier to match up touch events
2242  this.pointerIdentifier = pointer.pointerId !== undefined ?
2243    // pointerId for pointer events, touch.indentifier for touch events
2244    pointer.pointerId : pointer.identifier;
2245
2246  this.pointerDown( event, pointer );
2247};
2248
2249proto.pointerDown = function( event, pointer ) {
2250  this._bindPostStartEvents( event );
2251  this.emitEvent( 'pointerDown', [ event, pointer ] );
2252};
2253
2254// hash of events to be bound after start event
2255var postStartEvents = {
2256  mousedown: [ 'mousemove', 'mouseup' ],
2257  touchstart: [ 'touchmove', 'touchend', 'touchcancel' ],
2258  pointerdown: [ 'pointermove', 'pointerup', 'pointercancel' ],
2259};
2260
2261proto._bindPostStartEvents = function( event ) {
2262  if ( !event ) {
2263    return;
2264  }
2265  // get proper events to match start event
2266  var events = postStartEvents[ event.type ];
2267  // bind events to node
2268  events.forEach( function( eventName ) {
2269    window.addEventListener( eventName, this );
2270  }, this );
2271  // save these arguments
2272  this._boundPointerEvents = events;
2273};
2274
2275proto._unbindPostStartEvents = function() {
2276  // check for _boundEvents, in case dragEnd triggered twice (old IE8 bug)
2277  if ( !this._boundPointerEvents ) {
2278    return;
2279  }
2280  this._boundPointerEvents.forEach( function( eventName ) {
2281    window.removeEventListener( eventName, this );
2282  }, this );
2283
2284  delete this._boundPointerEvents;
2285};
2286
2287// ----- move event ----- //
2288
2289proto.onmousemove = function( event ) {
2290  this._pointerMove( event, event );
2291};
2292
2293proto.onpointermove = function( event ) {
2294  if ( event.pointerId == this.pointerIdentifier ) {
2295    this._pointerMove( event, event );
2296  }
2297};
2298
2299proto.ontouchmove = function( event ) {
2300  var touch = this.getTouch( event.changedTouches );
2301  if ( touch ) {
2302    this._pointerMove( event, touch );
2303  }
2304};
2305
2306/**
2307 * pointer move
2308 * @param {Event} event
2309 * @param {Event or Touch} pointer
2310 * @private
2311 */
2312proto._pointerMove = function( event, pointer ) {
2313  this.pointerMove( event, pointer );
2314};
2315
2316// public
2317proto.pointerMove = function( event, pointer ) {
2318  this.emitEvent( 'pointerMove', [ event, pointer ] );
2319};
2320
2321// ----- end event ----- //
2322
2323
2324proto.onmouseup = function( event ) {
2325  this._pointerUp( event, event );
2326};
2327
2328proto.onpointerup = function( event ) {
2329  if ( event.pointerId == this.pointerIdentifier ) {
2330    this._pointerUp( event, event );
2331  }
2332};
2333
2334proto.ontouchend = function( event ) {
2335  var touch = this.getTouch( event.changedTouches );
2336  if ( touch ) {
2337    this._pointerUp( event, touch );
2338  }
2339};
2340
2341/**
2342 * pointer up
2343 * @param {Event} event
2344 * @param {Event or Touch} pointer
2345 * @private
2346 */
2347proto._pointerUp = function( event, pointer ) {
2348  this._pointerDone();
2349  this.pointerUp( event, pointer );
2350};
2351
2352// public
2353proto.pointerUp = function( event, pointer ) {
2354  this.emitEvent( 'pointerUp', [ event, pointer ] );
2355};
2356
2357// ----- pointer done ----- //
2358
2359// triggered on pointer up & pointer cancel
2360proto._pointerDone = function() {
2361  this._pointerReset();
2362  this._unbindPostStartEvents();
2363  this.pointerDone();
2364};
2365
2366proto._pointerReset = function() {
2367  // reset properties
2368  this.isPointerDown = false;
2369  delete this.pointerIdentifier;
2370};
2371
2372proto.pointerDone = noop;
2373
2374// ----- pointer cancel ----- //
2375
2376proto.onpointercancel = function( event ) {
2377  if ( event.pointerId == this.pointerIdentifier ) {
2378    this._pointerCancel( event, event );
2379  }
2380};
2381
2382proto.ontouchcancel = function( event ) {
2383  var touch = this.getTouch( event.changedTouches );
2384  if ( touch ) {
2385    this._pointerCancel( event, touch );
2386  }
2387};
2388
2389/**
2390 * pointer cancel
2391 * @param {Event} event
2392 * @param {Event or Touch} pointer
2393 * @private
2394 */
2395proto._pointerCancel = function( event, pointer ) {
2396  this._pointerDone();
2397  this.pointerCancel( event, pointer );
2398};
2399
2400// public
2401proto.pointerCancel = function( event, pointer ) {
2402  this.emitEvent( 'pointerCancel', [ event, pointer ] );
2403};
2404
2405// -----  ----- //
2406
2407// utility function for getting x/y coords from event
2408Unipointer.getPointerPoint = function( pointer ) {
2409  return {
2410    x: pointer.pageX,
2411    y: pointer.pageY
2412  };
2413};
2414
2415// -----  ----- //
2416
2417return Unipointer;
2418
2419}));
2420
2421/*!
2422 * Unidragger v2.3.0
2423 * Draggable base class
2424 * MIT license
2425 */
2426
2427/*jshint browser: true, unused: true, undef: true, strict: true */
2428
2429( function( window, factory ) {
2430  // universal module definition
2431  /*jshint strict: false */ /*globals define, module, require */
2432
2433  if ( typeof define == 'function' && define.amd ) {
2434    // AMD
2435    define( 'unidragger/unidragger',[
2436      'unipointer/unipointer'
2437    ], function( Unipointer ) {
2438      return factory( window, Unipointer );
2439    });
2440  } else if ( typeof module == 'object' && module.exports ) {
2441    // CommonJS
2442    module.exports = factory(
2443      window,
2444      require('unipointer')
2445    );
2446  } else {
2447    // browser global
2448    window.Unidragger = factory(
2449      window,
2450      window.Unipointer
2451    );
2452  }
2453
2454}( window, function factory( window, Unipointer ) {
2455
2456
2457
2458// -------------------------- Unidragger -------------------------- //
2459
2460function Unidragger() {}
2461
2462// inherit Unipointer & EvEmitter
2463var proto = Unidragger.prototype = Object.create( Unipointer.prototype );
2464
2465// ----- bind start ----- //
2466
2467proto.bindHandles = function() {
2468  this._bindHandles( true );
2469};
2470
2471proto.unbindHandles = function() {
2472  this._bindHandles( false );
2473};
2474
2475/**
2476 * Add or remove start event
2477 * @param {Boolean} isAdd
2478 */
2479proto._bindHandles = function( isAdd ) {
2480  // munge isAdd, default to true
2481  isAdd = isAdd === undefined ? true : isAdd;
2482  // bind each handle
2483  var bindMethod = isAdd ? 'addEventListener' : 'removeEventListener';
2484  var touchAction = isAdd ? this._touchActionValue : '';
2485  for ( var i=0; i < this.handles.length; i++ ) {
2486    var handle = this.handles[i];
2487    this._bindStartEvent( handle, isAdd );
2488    handle[ bindMethod ]( 'click', this );
2489    // touch-action: none to override browser touch gestures. metafizzy/flickity#540
2490    if ( window.PointerEvent ) {
2491      handle.style.touchAction = touchAction;
2492    }
2493  }
2494};
2495

2496// prototype so it can be overwriteable by Flickity
2497proto._touchActionValue = 'none';
2498
2499// ----- start event ----- //
2500
2501/**
2502 * pointer start
2503 * @param {Event} event
2504 * @param {Event or Touch} pointer
2505 */
2506proto.pointerDown = function( event, pointer ) {
2507  var isOkay = this.okayPointerDown( event );
2508  if ( !isOkay ) {
2509    return;
2510  }
2511  // track start event position
2512  // Safari 9 overrides pageX and pageY. These values needs to be copied. flickity#842
2513  this.pointerDownPointer = {
2514    pageX: pointer.pageX,
2515    pageY: pointer.pageY,
2516  };
2517
2518  event.preventDefault();
2519  this.pointerDownBlur();
2520  // bind move and end events
2521  this._bindPostStartEvents( event );
2522  this.emitEvent( 'pointerDown', [ event, pointer ] );
2523};
2524
2525// nodes that have text fields
2526var cursorNodes = {
2527  TEXTAREA: true,
2528  INPUT: true,
2529  SELECT: true,
2530  OPTION: true,
2531};
2532
2533// input types that do not have text fields
2534var clickTypes = {
2535  radio: true,
2536  checkbox: true,
2537  button: true,
2538  submit: true,
2539  image: true,
2540  file: true,
2541};
2542
2543// dismiss inputs with text fields. flickity#403, flickity#404
2544proto.okayPointerDown = function( event ) {
2545  var isCursorNode = cursorNodes[ event.target.nodeName ];
2546  var isClickType = clickTypes[ event.target.type ];
2547  var isOkay = !isCursorNode || isClickType;
2548  if ( !isOkay ) {
2549    this._pointerReset();
2550  }
2551  return isOkay;
2552};
2553
2554// kludge to blur previously focused input
2555proto.pointerDownBlur = function() {
2556  var focused = document.activeElement;
2557  // do not blur body for IE10, metafizzy/flickity#117
2558  var canBlur = focused && focused.blur && focused != document.body;
2559  if ( canBlur ) {
2560    focused.blur();
2561  }
2562};
2563
2564// ----- move event ----- //
2565
2566/**
2567 * drag move
2568 * @param {Event} event
2569 * @param {Event or Touch} pointer
2570 */
2571proto.pointerMove = function( event, pointer ) {
2572  var moveVector = this._dragPointerMove( event, pointer );
2573  this.emitEvent( 'pointerMove', [ event, pointer, moveVector ] );
2574  this._dragMove( event, pointer, moveVector );
2575};
2576
2577// base pointer move logic
2578proto._dragPointerMove = function( event, pointer ) {
2579  var moveVector = {
2580    x: pointer.pageX - this.pointerDownPointer.pageX,
2581    y: pointer.pageY - this.pointerDownPointer.pageY
2582  };
2583  // start drag if pointer has moved far enough to start drag
2584  if ( !this.isDragging && this.hasDragStarted( moveVector ) ) {
2585    this._dragStart( event, pointer );
2586  }
2587  return moveVector;
2588};
2589
2590// condition if pointer has moved far enough to start drag
2591proto.hasDragStarted = function( moveVector ) {
2592  return Math.abs( moveVector.x ) > 3 || Math.abs( moveVector.y ) > 3;
2593};
2594
2595// ----- end event ----- //
2596
2597/**
2598 * pointer up
2599 * @param {Event} event
2600 * @param {Event or Touch} pointer
2601 */
2602proto.pointerUp = function( event, pointer ) {
2603  this.emitEvent( 'pointerUp', [ event, pointer ] );
2604  this._dragPointerUp( event, pointer );
2605};
2606
2607proto._dragPointerUp = function( event, pointer ) {
2608  if ( this.isDragging ) {
2609    this._dragEnd( event, pointer );
2610  } else {
2611    // pointer didn't move enough for drag to start
2612    this._staticClick( event, pointer );
2613  }
2614};
2615
2616// -------------------------- drag -------------------------- //
2617
2618// dragStart
2619proto._dragStart = function( event, pointer ) {
2620  this.isDragging = true;
2621  /* nectar addition iOS15 fix */
2622  document.ontouchmove = function() {
2623    return false;
2624  };
2625  /* nectar addition iOS15 fix end */
2626
2627  // prevent clicks

2628  this.isPreventingClicks = true;
2629  this.dragStart( event, pointer );
2630};
2631
2632proto.dragStart = function( event, pointer ) {
2633  this.emitEvent( 'dragStart', [ event, pointer ] );
2634};
2635
2636// dragMove
2637proto._dragMove = function( event, pointer, moveVector ) {
2638  // do not drag if not dragging yet
2639  if ( !this.isDragging ) {
2640    return;
2641  }
2642
2643  this.dragMove( event, pointer, moveVector );
2644};
2645
2646proto.dragMove = function( event, pointer, moveVector ) {
2647  event.preventDefault();
2648  this.emitEvent( 'dragMove', [ event, pointer, moveVector ] );
2649};
2650
2651// dragEnd
2652proto._dragEnd = function( event, pointer ) {
2653  // set flags
2654  this.isDragging = false;
2655
2656  /* nectar addition iOS15 fix */
2657  document.ontouchmove = function() {
2658    return true;
2659  };
2660  /* nectar addition iOS15 fix end */
2661
2662  // re-enable clicking async
2663  setTimeout( function() {
2664    delete this.isPreventingClicks;
2665  }.bind( this ) );
2666
2667  this.dragEnd( event, pointer );
2668};
2669
2670proto.dragEnd = function( event, pointer ) {
2671  this.emitEvent( 'dragEnd', [ event, pointer ] );
2672};
2673
2674// ----- onclick ----- //
2675
2676// handle all clicks and prevent clicks when dragging
2677proto.onclick = function( event ) {