@nanoporetech-digital/components 5.10.0 → 5.11.1

package/dist/collection/components/slides/lib/js/flickity.js

@@ -1,32 +1,28 @@
-import EvEmitter from 'ev-emitter';
-import getSize from 'get-size';
-import utils from 'fizzy-ui-utils';
+/*!
+ * Web Components for Nanopore digital Web Apps
+ */
+import { EvEmitter } from './utils/event-emitter';
+import { getSize } from './utils/get-size';
+import { utils } from './utils/utils';
 import Cell from './cell';
 import Slide from './slide';
 import animatePrototype from './animate';
-
-('use strict');
-
 // vars
-var getComputedStyle = window.getComputedStyle;
-var console = window.console;
-
+const getComputedStyle = window.getComputedStyle;
+const console = window.console;
 function moveElements(elems, toElem) {
   elems = utils.makeArray(elems);
   while (elems.length) {
     toElem.appendChild(elems.shift());
   }
 }
-
 // -------------------------- Flickity -------------------------- //
-
 // globally unique identifiers
-var GUID = 0;
+let GUID = 0;
 // internal store of all Flickity intances
-var instances = {};
-
+const instances = {};
 export default function Flickity(element, options) {
-  var queryElement = utils.getQueryElement(element);
+  const queryElement = utils.getQueryElement(element);
   if (!queryElement) {
     if (console) {
       console.error('Bad element for Flickity: ' + (queryElement || element));
@@ -36,28 +32,26 @@ export default function Flickity(element, options) {
   this.element = queryElement;
   // do not initialize twice on same element
   if (this.element.flickityGUID) {
-    var instance = instances[this.element.flickityGUID];
-    if (!instances[this.element.flickityGUID]) return;
+    const instance = instances[this.element.flickityGUID];
+    if (!instances[this.element.flickityGUID])
+      return;
     instance.option(options);
     return instance;
   }
-
   // options
   this.options = utils.extend({}, this.constructor.defaults);
   this.option(options);
-
   // kick things off
   this._create();
 }
-
 Flickity.defaults = {
   accessibility: true,
   // adaptiveHeight: false,
   cellAlign: 'center',
   // cellSelector: undefined,
   // contain: false,
-  freeScrollFriction: 0.075, // friction when free-scrolling
-  friction: 0.28, // friction when selecting
+  freeScrollFriction: 0.075,
+  friction: 0.28,
   namespaceJQueryEvents: true,
   // initialIndex: 0,
   percentPosition: true,
@@ -67,17 +61,14 @@ Flickity.defaults = {
   // watchCSS: false,
   // wrapAround: false
 };
-
 // hash of methods triggered on _create()
 Flickity.createMethods = [];
-
-var proto = Flickity.prototype;
+const proto = Flickity.prototype;
 // inherit EventEmitter
 utils.extend(proto, EvEmitter.prototype);
-
 proto._create = function () {
   // add id for Flickity.data
-  var id = (this.guid = ++GUID);
+  const id = (this.guid = ++GUID);
   this.element.flickityGUID = id; // expando
   instances[id] = this; // associate via id
   // initial properties
@@ -93,28 +84,24 @@ proto._create = function () {
   this.viewport.className = 'flickity-viewport';
   this.viewport.part.add('slide-viewport');
   this._createSlider();
-
   if (this.options.resize || this.options.watchCSS) {
     window.addEventListener('resize', this);
   }
-
   // add listeners from on option
-  for (var eventName in this.options.on) {
-    var listener = this.options.on[eventName];
+  for (const eventName in this.options.on) {
+    const listener = this.options.on[eventName];
     this.on(eventName, listener);
   }
-
   Flickity.createMethods.forEach(function (method) {
     this[method]();
   }, this);
-
   if (this.options.watchCSS) {
     this.watchCSS();
-  } else {
+  }
+  else {
     this.activate();
   }
 };
-
 /**
  * set options
  * @param {Object} opts
@@ -122,7 +109,6 @@ proto._create = function () {
 proto.option = function (opts) {
   utils.extend(this.options, opts);
 };
-
 proto.activate = function () {
   if (this.isActive) {
     return;
@@ -132,23 +118,20 @@ proto.activate = function () {
   if (this.options.rightToLeft) {
     this.element.classList.add('flickity-rtl');
   }
-
   this.getSize();
   // move initial cell elements so they can be loaded as cells
-  var cellElems = this.element.children; //this._filterFindCellElements( this.element.children );
+  const cellElems = this.element.children; //this._filterFindCellElements( this.element.children );
   moveElements(cellElems, this.slider);
   this.viewport.appendChild(this.slider);
   this.element.appendChild(this.viewport);
   // get cells from children
   this.reloadCells();
-
   if (this.options.accessibility) {
     // allow element to focusable
     this.element.tabIndex = 0;
     // listen for key presses
     this.element.addEventListener('keydown', this);
   }
-
   this.emitEvent('activate');
   this.selectInitialIndex();
   // flag for initial activation, for using initialIndex
@@ -156,57 +139,46 @@ proto.activate = function () {
   // ready event. #493
   this.dispatchEvent('ready');
 };
-
 // slider positions the cells
 proto._createSlider = function () {
   // slider element does all the positioning
-  var slider = document.createElement('div');
+  const slider = document.createElement('div');
   slider.className = 'flickity-slider';
   slider.style[this.originSide] = 0;
   this.slider = slider;
 };
-
 proto._filterFindCellElements = function (elems) {
   return utils.filterFindElements(elems, this.options.cellSelector);
 };
-
 // goes through all children
 proto.reloadCells = function () {
   // collection of item elements
-  this.cells = this._makeCells(
-    this.slider.getRootNode().host
-      ? this.slider.getRootNode().host.children
-      : this.slider.children
-  );
+  this.cells = this._makeCells(this.slider.getRootNode().host
+    ? this.slider.getRootNode().host.children
+    : this.slider.children);
   this.positionCells();
   this._getWrapShiftCells();
   this.setGallerySize();
 };
-
 /**
  * turn elements into Flickity.Cells
  * @param {Array or NodeList or HTMLElement} elems
  * @returns {Array} items - collection of new Flickity Cells
  */
 proto._makeCells = function (elems) {
-  var cellElems = this._filterFindCellElements(elems);
-
+  const cellElems = this._filterFindCellElements(elems);
   // create new Flickity for collection
-  var cells = cellElems.map(function (cellElem) {
+  const cells = cellElems.map(function (cellElem) {
     return new Cell(cellElem, this);
   }, this);
-
   return cells;
 };
-
 proto.getLastCell = function () {
   return this.cells[this.cells.length - 1];
 };
-
 proto.getLastSlide = function () {
   return this.slides[this.slides.length - 1];
 };
-
 // positions all cells
 proto.positionCells = function () {
   // size all cells
@@ -214,7 +186,6 @@ proto.positionCells = function () {
   // position all cells
   this._positionCells(0);
 };
-
 /**
  * position certain cells
  * @param {Integer} index - which cell to start with
@@ -224,15 +195,15 @@ proto._positionCells = function (index) {
   // also measure maxCellHeight
   // start 0 if positioning all cells
   this.maxCellHeight = index ? this.maxCellHeight || 0 : 0;
-  var cellX = 0;
+  let cellX = 0;
   // get cellX
   if (index > 0) {
-    var startCell = this.cells[index - 1];
+    const startCell = this.cells[index - 1];
     cellX = startCell.x + startCell.size.outerWidth;
   }
-  var len = this.cells.length;
-  for (var i = index; i < len; i++) {
-    var cell = this.cells[i];
+  const len = this.cells.length;
+  for (let i = index; i < len; i++) {
+    const cell = this.cells[i];
     cell.setPosition(cellX);
     cellX += cell.size.outerWidth;
     this.maxCellHeight = Math.max(cell.size.outerHeight, this.maxCellHeight);
@@ -248,7 +219,6 @@ proto._positionCells = function (index) {
     ? this.getLastSlide().target - this.slides[0].target
     : 0;
 };
-
 /**
  * cell.getSize() on multiple cells
  * @param {Array} cells
@@ -258,40 +228,32 @@ proto._sizeCells = function (cells) {
     cell.getSize();
   });
 };
-
 // --------------------------  -------------------------- //
-
 proto.updateSlides = function () {
   this.slides = [];
   if (!this.cells.length) {
     return;
   }
-
-  var slide = new Slide(this);
+  let slide = new Slide(this);
   this.slides.push(slide);
-  var isOriginLeft = this.originSide == 'left';
-  var nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
-
-  var canCellFit = this._getCanCellFit();
-
+  const isOriginLeft = this.originSide == 'left';
+  const nextMargin = isOriginLeft ? 'marginRight' : 'marginLeft';
+  const canCellFit = this._getCanCellFit();
   this.cells.forEach(function (cell, i) {
     // just add cell if first cell in slide
     if (!slide.cells.length) {
       slide.addCell(cell);
       return;
     }
-
-    var slideWidth =
-      slide.outerWidth -
+    const slideWidth = slide.outerWidth -
       slide.firstMargin +
       (cell.size.outerWidth - cell.size[nextMargin]);
-
     if (canCellFit.call(this, i, slideWidth)) {
       slide.addCell(cell);
-    } else {
+    }
+    else {
       // doesn't fit, new slide
       slide.updateTarget();
-
       slide = new Slide(this);
       this.slides.push(slide);
       slide.addCell(cell);
@@ -302,43 +264,40 @@ proto.updateSlides = function () {
   // update .selectedSlide
   this.updateSelectedSlide();
 };
-
 proto._getCanCellFit = function () {
-  var groupCells = this.options.groupCells;
+  const groupCells = this.options.groupCells;
   if (!groupCells) {
     return function () {
       return false;
     };
-  } else if (typeof groupCells == 'number') {
+  }
+  else if (typeof groupCells == 'number') {
     // group by number. 3 -> [0,1,2], [3,4,5], ...
-    var number = parseInt(groupCells, 10);
+    // @ts-ignore
+    const number = parseInt(groupCells, 10);
     return function (i) {
       return i % number !== 0;
     };
   }
   // default, group by width of slide
   // parse '75%
-  var percentMatch =
-    typeof groupCells == 'string' && groupCells.match(/^(\d+)%$/);
-  var percent = percentMatch ? parseInt(percentMatch[1], 10) / 100 : 1;
-  return function (i, slideWidth) {
+  const percentMatch = typeof groupCells == 'string' && groupCells.match(/^(\d+)%$/);
+  const percent = percentMatch ? parseInt(percentMatch[1], 10) / 100 : 1;
+  return function (_i, slideWidth) {
     return slideWidth <= (this.size.innerWidth + 1) * percent;
   };
 };
-
 // alias _init for jQuery plugin .flickity()
 proto._init = proto.reposition = function () {
   this.positionCells();
   this.positionSliderAtSelected();
 };
-
 proto.getSize = function () {
   this.size = getSize(this.element);
   this.setCellAlign();
   this.cursorPosition = this.size.innerWidth * this.cellAlign;
 };
-
-var cellAlignShorthands = {
+const cellAlignShorthands = {
   // cell align, then based on origin side
   center: {
     left: 0.5,
@@ -353,24 +312,20 @@ var cellAlignShorthands = {
     left: 1,
   },
 };
-
 proto.setCellAlign = function () {
-  var shorthand = cellAlignShorthands[this.options.cellAlign];
+  const shorthand = cellAlignShorthands[this.options.cellAlign];
   this.cellAlign = shorthand
     ? shorthand[this.originSide]
     : this.options.cellAlign;
 };
-
 proto.setGallerySize = function () {
   if (this.options.setGallerySize) {
-    var height =
-      this.options.adaptiveHeight && this.selectedSlide
-        ? this.selectedSlide.height
-        : this.maxCellHeight;
+    const height = this.options.adaptiveHeight && this.selectedSlide
+      ? this.selectedSlide.height
+      : this.maxCellHeight;
     this.viewport.style.height = height + 'px';
   }
 };
-
 proto._getWrapShiftCells = function () {
   // only for wrap-around
   if (!this.options.wrapAround) {
@@ -381,8 +336,8 @@ proto._getWrapShiftCells = function () {
   this._unshiftCells(this.afterShiftCells);
   // get before cells
   // initial gap
-  var gapX = this.cursorPosition;
-  var cellIndex = this.cells.length - 1;
+  let gapX = this.cursorPosition;
+  const cellIndex = this.cells.length - 1;
   this.beforeShiftCells = this._getGapCells(gapX, cellIndex, -1);
   // get after cells
   // ending gap between last cell and end of gallery viewport
@@ -390,12 +345,11 @@ proto._getWrapShiftCells = function () {
   // start cloning at first cell, working forwards
   this.afterShiftCells = this._getGapCells(gapX, 0, 1);
 };
-
 proto._getGapCells = function (gapX, cellIndex, increment) {
   // keep adding cells until the cover the initial gap
-  var cells = [];
+  const cells = [];
   while (gapX > 0) {
-    var cell = this.cells[cellIndex];
+    const cell = this.cells[cellIndex];
     if (!cell) {
       break;
     }
@@ -405,38 +359,35 @@ proto._getGapCells = function (gapX, cellIndex, increment) {
   }
   return cells;
 };
-
 // ----- contain ----- //
-
 // contain cell targets so no excess sliding
 proto._containSlides = function () {
   if (!this.options.contain || this.options.wrapAround || !this.cells.length) {
     return;
   }
-  var isRightToLeft = this.options.rightToLeft;
-  var beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
-  var endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
-  var contentWidth = this.slideableWidth - this.getLastCell().size[endMargin];
+  const isRightToLeft = this.options.rightToLeft;
+  const beginMargin = isRightToLeft ? 'marginRight' : 'marginLeft';
+  const endMargin = isRightToLeft ? 'marginLeft' : 'marginRight';
+  const contentWidth = this.slideableWidth - this.getLastCell().size[endMargin];
   // content is less than gallery size
-  var isContentSmaller = contentWidth < this.size.innerWidth;
+  const isContentSmaller = contentWidth < this.size.innerWidth;
   // bounds
-  var beginBound = this.cursorPosition + this.cells[0].size[beginMargin];
-  var endBound = contentWidth - this.size.innerWidth * (1 - this.cellAlign);
+  const beginBound = this.cursorPosition + this.cells[0].size[beginMargin];
+  const endBound = contentWidth - this.size.innerWidth * (1 - this.cellAlign);
   // contain each cell target
   this.slides.forEach(function (slide) {
     if (isContentSmaller) {
       // all cells fit inside gallery
       slide.target = contentWidth * this.cellAlign;
-    } else {
+    }
+    else {
       // contain to bounds
       slide.target = Math.max(slide.target, beginBound);
       slide.target = Math.min(slide.target, endBound);
     }
   }, this);
 };
-
 // -----  ----- //
-
 /**
  * emits events via eventEmitter and jQuery events
  * @param {String} type - name of event
@@ -444,12 +395,10 @@ proto._containSlides = function () {
  * @param {Array} args - extra arguments
  */
 proto.dispatchEvent = function (type, event, args) {
-  var emitArgs = event ? [event].concat(args) : args;
+  const emitArgs = event ? [event].concat(args) : args;
   this.emitEvent(type, emitArgs);
 };
-
 // -------------------------- select -------------------------- //
-
 /**
  * @param {Integer} index - index of the slide
  * @param {Boolean} isWrap - will wrap-around to last/first if at the end
@@ -461,7 +410,6 @@ proto.select = function (index, isWrap, isInstant) {
   }
   index = parseInt(index, 10);
   this._wrapSelect(index);
-
   if (this.options.wrapAround || isWrap) {
     index = utils.modulo(index, this.slides.length);
   }
@@ -469,12 +417,13 @@ proto.select = function (index, isWrap, isInstant) {
   if (!this.slides[index]) {
     return;
   }
-  var prevIndex = this.selectedIndex;
+  const prevIndex = this.selectedIndex;
   this.selectedIndex = index;
   this.updateSelectedSlide();
   if (isInstant) {
     this.positionSliderAtSelected();
-  } else {
+  }
+  else {
     this.startAnimation();
   }
   if (this.options.adaptiveHeight) {
@@ -489,42 +438,40 @@ proto.select = function (index, isWrap, isInstant) {
   // old v1 event name, remove in v3
   this.dispatchEvent('cellSelect');
 };
-
 // wraps position for wrapAround, to move to closest slide. #113
 proto._wrapSelect = function (index) {
-  var len = this.slides.length;
-  var isWrapping = this.options.wrapAround && len > 1;
+  const len = this.slides.length;
+  const isWrapping = this.options.wrapAround && len > 1;
   if (!isWrapping) {
     return index;
   }
-  var wrapIndex = utils.modulo(index, len);
+  const wrapIndex = utils.modulo(index, len);
   // go to shortest
-  var delta = Math.abs(wrapIndex - this.selectedIndex);
-  var backWrapDelta = Math.abs(wrapIndex + len - this.selectedIndex);
-  var forewardWrapDelta = Math.abs(wrapIndex - len - this.selectedIndex);
+  const delta = Math.abs(wrapIndex - this.selectedIndex);
+  const backWrapDelta = Math.abs(wrapIndex + len - this.selectedIndex);
+  const forewardWrapDelta = Math.abs(wrapIndex - len - this.selectedIndex);
   if (!this.isDragSelect && backWrapDelta < delta) {
     index += len;
-  } else if (!this.isDragSelect && forewardWrapDelta < delta) {
+  }
+  else if (!this.isDragSelect && forewardWrapDelta < delta) {
     index -= len;
   }
   // wrap position so slider is within normal area
   if (index < 0) {
     this.x -= this.slideableWidth;
-  } else if (index >= len) {
+  }
+  else if (index >= len) {
     this.x += this.slideableWidth;
   }
 };
-
 proto.previous = function (isWrap, isInstant) {
   this.select(this.selectedIndex - 1, isWrap, isInstant);
 };
-
 proto.next = function (isWrap, isInstant) {
   this.select(this.selectedIndex + 1, isWrap, isInstant);
 };
-
 proto.updateSelectedSlide = function () {
-  var slide = this.slides[this.selectedIndex];
+  const slide = this.slides[this.selectedIndex];
   // selectedIndex could be outside of slides, if triggered before resize()
   if (!slide) {
     return;
@@ -541,15 +488,13 @@ proto.updateSelectedSlide = function () {
   this.selectedCell = slide.cells[0];
   this.selectedElement = this.selectedElements[0];
 };
-
 proto.unselectSelectedSlide = function () {
   if (this.selectedSlide) {
     this.selectedSlide.unselect();
   }
 };
-
 proto.selectInitialIndex = function () {
-  var initialIndex = this.options.initialIndex;
+  const initialIndex = this.options.initialIndex;
   // already activated, select previous selectedIndex
   if (this.isInitActivated) {
     this.select(this.selectedIndex, false, true);
@@ -557,14 +502,13 @@ proto.selectInitialIndex = function () {
   }
   // select with selector string
   if (initialIndex && typeof initialIndex == 'string') {
-    var cell = this.queryCell(initialIndex);
+    const cell = this.queryCell(initialIndex);
     if (cell) {
       this.selectCell(initialIndex, false, true);
       return;
     }
   }
-
-  var index = 0;
+  let index = 0;
   // select with number
   if (initialIndex && this.slides[initialIndex]) {
     index = initialIndex;
@@ -572,50 +516,46 @@ proto.selectInitialIndex = function () {
   // select instantly
   this.select(index, false, true);
 };
-
 /**
  * select slide from number or cell element
  * @param {Element or Number} elem
+ * @param { Boolean } isWrap
+ * @param { Boolean } isInstant
  */
-proto.selectCell = function (value, isWrap, isInstant) {
+proto.selectCell = function (elem, isWrap, isInstant) {
   // get cell
-  var cell = this.queryCell(value);
+  const cell = this.queryCell(elem);
   if (!cell) {
     return;
   }
-
-  var index = this.getCellSlideIndex(cell);
+  const index = this.getCellSlideIndex(cell);
   this.select(index, isWrap, isInstant);
 };
-
 proto.getCellSlideIndex = function (cell) {
   // get index of slides that has cell
-  for (var i = 0; i < this.slides.length; i++) {
-    var slide = this.slides[i];
-    var index = slide.cells.indexOf(cell);
+  for (let i = 0; i < this.slides.length; i++) {
+    const slide = this.slides[i];
+    const index = slide.cells.indexOf(cell);
     if (index != -1) {
       return i;
     }
   }
 };
-
 // -------------------------- get cells -------------------------- //
-
 /**
  * get Flickity.Cell, given an Element
  * @param {Element} elem
- * @returns {Flickity.Cell} item
+ * @returns found flickity cell
  */
 proto.getCell = function (elem) {
   // loop through cells to get the one that matches
-  for (var i = 0; i < this.cells.length; i++) {
-    var cell = this.cells[i];
+  for (let i = 0; i < this.cells.length; i++) {
+    const cell = this.cells[i];
     if (cell.element == elem) {
       return cell;
     }
   }
 };
-
 /**
  * get collection of Flickity.Cells, given Elements
  * @param {Element, Array, NodeList} elems
@@ -623,16 +563,15 @@ proto.getCell = function (elem) {
  */
 proto.getCells = function (elems) {
   elems = utils.makeArray(elems);
-  var cells = [];
+  const cells = [];
   elems.forEach(function (elem) {
-    var cell = this.getCell(elem);
+    const cell = this.getCell(elem);
     if (cell) {
       cells.push(cell);
     }
   }, this);
   return cells;
 };
-
 /**
  * get cell elements
  * @returns {Array} cellElems
@@ -642,7 +581,6 @@ proto.getCellElements = function () {
     return cell.element;
   });
 };
-
 /**
  * get parent cell from an element
  * @param {Element} elem
@@ -650,7 +588,7 @@ proto.getCellElements = function () {
  */
 proto.getParentCell = function (elem) {
   // first check if elem is cell
-  var cell = this.getCell(elem);
+  const cell = this.getCell(elem);
   if (cell) {
     return cell;
   }
@@ -658,7 +596,6 @@ proto.getParentCell = function (elem) {
   elem = utils.getParent(elem, '.flickity-slider > *');
   return this.getCell(elem);
 };
-
 /**
  * get cells adjacent to a slide
  * @param {Integer} adjCount - number of adjacent slides
@@ -670,26 +607,24 @@ proto.getAdjacentCellElements = function (adjCount, index) {
     return this.selectedSlide.getCellElements();
   }
   index = index === undefined ? this.selectedIndex : index;
-
-  var len = this.slides.length;
+  const len = this.slides.length;
   if (1 + adjCount * 2 >= len) {
     return this.getCellElements();
   }
-
-  var cellElems = [];
-  for (var i = index - adjCount; i <= index + adjCount; i++) {
-    var slideIndex = this.options.wrapAround ? utils.modulo(i, len) : i;
-    var slide = this.slides[slideIndex];
+  let cellElems = [];
+  for (let i = index - adjCount; i <= index + adjCount; i++) {
+    const slideIndex = this.options.wrapAround ? utils.modulo(i, len) : i;
+    const slide = this.slides[slideIndex];
     if (slide) {
       cellElems = cellElems.concat(slide.getCellElements());
     }
   }
   return cellElems;
 };
-
 /**
  * select slide from number or cell element
  * @param {Element, Selector String, or Number} selector
+ * @returns {Flickity.Cell} found flickity cell
  */
 proto.queryCell = function (selector) {
   if (typeof selector == 'number') {
@@ -707,13 +642,10 @@ proto.queryCell = function (selector) {
   // get cell from element
   return this.getCell(selector);
 };
-
 // -------------------------- events -------------------------- //
-
 proto.uiChange = function () {
   this.emitEvent('uiChange');
 };
-
 // keep focus on element when child UI elements are clicked
 proto.childUIPointerDown = function (event) {
   // HACK iOS does not allow touch events to bubble up?!
@@ -722,16 +654,12 @@ proto.childUIPointerDown = function (event) {
   }
   this.focus();
 };
-
 // ----- resize ----- //
-
 proto.onresize = function () {
   this.watchCSS();
   this.resize();
 };
-
 utils.debounceMethod(Flickity, 'onresize', 150);
-
 proto.resize = function () {
   if (!this.isActive) {
     return;
@@ -747,73 +675,63 @@ proto.resize = function () {
   this.emitEvent('resize');
   // update selected index for group slides, instant
   // TODO: position can be lost between groups of various numbers
-  var selectedElement = this.selectedElements && this.selectedElements[0];
+  const selectedElement = this.selectedElements && this.selectedElements[0];
   this.selectCell(selectedElement, false, true);
 };
-
 // watches the :after property, activates/deactivates
 proto.watchCSS = function () {
-  var watchOption = this.options.watchCSS;
+  const watchOption = this.options.watchCSS;
   if (!watchOption) {
     return;
   }
-
-  var afterContent = getComputedStyle(this.element, ':after').content;
+  const afterContent = getComputedStyle(this.element, ':after').content;
   // activate if :after { content: 'flickity' }
   if (afterContent.indexOf('flickity') != -1) {
     this.activate();
-  } else {
+  }
+  else {
     this.deactivate();
   }
 };
-
 // ----- keydown ----- //
-
 // go previous/next if left/right keys pressed
 proto.onkeydown = function (event) {
   // only work if element is in focus
-  var isNotFocused =
-    document.activeElement && document.activeElement != this.element;
+  const isNotFocused = document.activeElement && document.activeElement != this.element;
   if (!this.options.accessibility || isNotFocused) {
     return;
   }
-
-  var handler = Flickity.keyboardHandlers[event.keyCode];
+  const handler = Flickity.keyboardHandlers[event.keyCode];
   if (handler) {
     handler.call(this);
   }
 };
-
 Flickity.keyboardHandlers = {
   // left arrow
   37: function () {
-    var leftMethod = this.options.rightToLeft ? 'next' : 'previous';
+    const leftMethod = this.options.rightToLeft ? 'next' : 'previous';
     this.uiChange();
     this[leftMethod]();
   },
   // right arrow
   39: function () {
-    var rightMethod = this.options.rightToLeft ? 'previous' : 'next';
+    const rightMethod = this.options.rightToLeft ? 'previous' : 'next';
     this.uiChange();
     this[rightMethod]();
   },
 };
-
 // ----- focus ----- //
-
 proto.focus = function () {
   // TODO remove scrollTo once focus options gets more support
   // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus#Browser_compatibility
-  var prevScrollY = window.pageYOffset;
+  const prevScrollY = window.pageYOffset;
   this.element.focus({ preventScroll: true });
   // hack to fix scroll jump after focus, #76
   if (window.pageYOffset != prevScrollY) {
     window.scrollTo(window.pageXOffset, prevScrollY);
   }
 };
-
 // -------------------------- destroy -------------------------- //
-
 // deactivate all Flickity functionality, but keep stuff available
 proto.deactivate = function () {
   if (!this.isActive) {
@@ -837,7 +755,6 @@ proto.deactivate = function () {
   this.isActive = false;
   this.emitEvent('deactivate');
 };
-
 proto.destroy = function () {
   this.deactivate();
   window.removeEventListener('resize', this);
@@ -846,25 +763,20 @@ proto.destroy = function () {
   delete this.element.flickityGUID;
   delete instances[this.guid];
 };
-
 // -------------------------- prototype -------------------------- //
-
 utils.extend(proto, animatePrototype);
-
 // -------------------------- extras -------------------------- //
-
 /**
  * get Flickity instance from element
  * @param {Element} elem
- * @returns {Flickity}
+ * @returns {Flickity} Flickity instance
  */
 Flickity.data = function (elem) {
   elem = utils.getQueryElement(elem);
-  var id = elem && elem.flickityGUID;
+  const id = elem && elem.flickityGUID;
   return id && instances[id];
 };
-
 utils.htmlInit(Flickity, 'flickity');
-
 Flickity.Cell = Cell;
 Flickity.Slide = Slide;
+//# sourceMappingURL=flickity.js.map