correction && add form && add slide && add masonry && css

node_modules/flickity/test/unit/adaptive-height.js

@@ -0,0 +1,29 @@
+QUnit.test( 'adaptiveHeight', function( assert ) {
+  'use strict';
+
+  var flkty = new Flickity( '#adaptive-height', {
+    adaptiveHeight: true
+  });
+
+  // 2,1,3, 1,4,2, 1,2,1
+
+  function checkSelectHeight( index, height ) {
+    flkty.select( index, false, true );
+    assert.equal( flkty.viewport.style.height, height + 'px', 'slide ' + index );
+  }
+
+  checkSelectHeight( 0, 200 );
+  checkSelectHeight( 1, 100 );
+  checkSelectHeight( 2, 300 );
+  checkSelectHeight( 3, 100 );
+  checkSelectHeight( 4, 400 );
+  checkSelectHeight( 5, 200 );
+
+  flkty.options.groupCells = true;
+  flkty.resize();
+
+  checkSelectHeight( 0, 300 );
+  checkSelectHeight( 1, 400 );
+  checkSelectHeight( 2, 200 );
+
+});

node_modules/flickity/test/unit/add-remove-cells.js

@@ -0,0 +1,88 @@
+QUnit.test( 'add/remove cells', function( assert ) {
+  'use strict';
+
+  function makeCellElem() {
+    var cellElem = document.createElement('div');
+    cellElem.className = 'cell';
+    return cellElem;
+  }
+
+  // position values can be off by 0.1% or 1px
+  function isPositionApprox( value, expected ) {
+    var isPercent = value.indexOf('%') != -1;
+    value = parseFloat( value );
+    var diff = Math.abs( expected - value );
+    return isPercent ? diff < 0.1 : diff <= 1;
+  }
+
+  var elem = document.querySelector('#add-remove-cells');
+  var flkty = new Flickity( elem );
+  var sliderElem = elem.querySelector('.flickity-slider');
+
+  function checkCellElem( cellElem, index, message ) {
+    assert.equal( sliderElem.children[ index ], cellElem, message + ' cell element in DOM correct' );
+    assert.equal( flkty.cells[ index ].element, cellElem, message + ' element added as cell' );
+    assert.ok( isPositionApprox( cellElem.style.left, index * 25 ), ' element positioned' );
+  }
+
+  // prepend cell element
+  var cellElem = makeCellElem();
+  flkty.prepend( cellElem );
+  checkCellElem( cellElem, 0, 'prepended' );
+  assert.equal( flkty.selectedIndex, 1, 'selectedIndex +1 after prepend' );
+  // append cell element
+  cellElem = makeCellElem();
+  flkty.append( cellElem );
+  var lastIndex = flkty.cells.length - 1;
+  checkCellElem( cellElem, lastIndex, 'appended' );
+  assert.equal( flkty.selectedIndex, 1, 'selectedIndex same after prepend' );
+  // insert single cell element
+  cellElem = makeCellElem(); // this one gets removed first
+  flkty.select( 2 );
+  flkty.insert( cellElem, 2 );
+  checkCellElem( cellElem, 2, 'single inserted' );
+  assert.equal( flkty.selectedIndex, 3, 'selectedIndex +1 after insert before' );
+  flkty.insert( makeCellElem(), 4 );
+  assert.equal( flkty.selectedIndex, 3, 'selectedIndex same after insert before' );
+  // insert multiple cell elements
+  var cellElems = [ makeCellElem(), makeCellElem(), makeCellElem() ];
+  flkty.insert( cellElems, 3 );
+  checkCellElem( cellElems[0], 3, 'first multiple inserted' );
+  checkCellElem( cellElems[1], 4, 'second multiple inserted' );
+  checkCellElem( cellElems[2], 5, 'third multiple inserted' );
+  assert.equal( flkty.selectedIndex, 6, 'selectedIndex +6 after 3 insert before' );
+
+  function checkCellPositions() {
+    var isGap = false;
+    for ( var i=0, len = flkty.cells.length; i < len; i++ ) {
+      var cell = flkty.cells[i];
+      if ( !isPositionApprox( cell.element.style.left, i * 25 ) ) {
+        assert.ok( false, 'gap in cell position ' + i + ' after removal' );
+        isGap = true;
+      }
+    }
+    assert.ok( !isGap, 'no gaps in cell positions' );
+  }
+
+  // remove single cell element that was inserted
+  var len = flkty.cells.length;
+  flkty.remove( cellElem );
+  assert.equal( len - sliderElem.children.length, 1, 'element removed from DOM' );
+  assert.equal( len - flkty.cells.length, 1, 'cell removed' );
+  assert.equal( flkty.selectedIndex, 5, 'selectedIndex -1 after remove before' );
+  checkCellPositions();
+  // remove multiple
+  len = flkty.cells.length;
+  flkty.select( 4 );
+  flkty.remove([ cellElems[2], cellElems[0], cellElems[1] ]);
+  assert.equal( len - sliderElem.children.length, 3, 'elements removed from DOM' );
+  assert.equal( len - flkty.cells.length, 3, 'cells removed' );
+  checkCellPositions();
+
+  // remove all cells
+  flkty.remove( flkty.getCellElements() );
+  assert.equal( flkty.cells.length, 0, 'all cells removed' );
+  flkty.resize();
+  assert.ok( true, 'resize with zero items didnt freak out' );
+
+});

node_modules/flickity/test/unit/auto-play.js

@@ -0,0 +1,91 @@
+QUnit.test( 'auto play', function( assert ) {
+  'use strict';
+
+  var done = assert.async();
+
+  var flkty = new Flickity( '#auto-play', {
+    autoPlay: 200
+  });
+
+  var selectCount = 0;
+  var testDelay = flkty.options.autoPlay + 100;
+
+  var tests;
+
+  function nextTest() {
+    if ( tests.length ) {
+      var next = tests.shift();
+      next();
+    } else {
+      flkty.stopPlayer();
+      done();
+    }
+  }
+
+  tests = [
+    // check that player runs
+    function() {
+      var onSelect = function() {
+        selectCount++;
+        if ( selectCount < 5 ) {
+          assert.equal( flkty.selectedIndex, selectCount % flkty.cells.length,
+            'auto-played to ' + flkty.selectedIndex );
+        } else if ( selectCount == 5 ) {
+          // HACK do async, should be able to stop after a tick
+          flkty.off( 'select', onSelect );
+          nextTest();
+        }
+      };
+      flkty.on( 'select', onSelect );
+    },
+    // pause & unpause
+    function() {
+      function onPauseSelect() {
+        assert.ok( false, 'player ticked during pause' );
+      }
+      flkty.on( 'select', onPauseSelect );
+      flkty.pausePlayer();
+      setTimeout( function() {
+        assert.ok( true, 'player did not tick during pause' );
+        flkty.off( 'select', onPauseSelect );
+        flkty.once( 'select', function() {
+          assert.ok( true, 'player resumed after unpausing' );
+          nextTest();
+        });
+        flkty.unpausePlayer();
+      }, testDelay );
+    },
+    // stopPlayer
+    function() {
+      var ticks = 0;
+      function onSelect() {
+        ticks++;
+      }
+      flkty.stopPlayer();
+      setTimeout( function() {
+        flkty.off( 'select', onSelect );
+        assert.equal( ticks, 0, 'no ticks after stopped' );
+        nextTest();
+      }, testDelay * 2 );
+    },
+    // double playPlayer()
+    function() {
+      var ticks = 0;
+      function onSelect() {
+        ticks++;
+      }
+      flkty.stopPlayer();
+      flkty.on( 'select', onSelect );
+      flkty.playPlayer();
+      flkty.playPlayer();
+      setTimeout( function() {
+        flkty.off( 'select', onSelect );
+        assert.equal( ticks, 1, 'only one tick after double playPlayer' );
+        nextTest();
+      }, testDelay );
+    },
+  ];
+
+  nextTest();
+
+});

node_modules/flickity/test/unit/cell-selector.js

@@ -0,0 +1,32 @@
+QUnit.test( 'cellSelector', function( assert ) {
+  'use strict';
+
+  var elem = document.querySelector('#cell-selector');
+  var notCell1 = elem.querySelector('.not-cell1');
+  var notCell2 = elem.querySelector('.not-cell2');
+
+  var flkty = new Flickity( elem, {
+    cellSelector: '.cell'
+  });
+
+  var cellsMatchSelector = true;
+  for ( var i=0, len = flkty.cells.length; i < len; i++ ) {
+    var cell = flkty.cells[i];
+    var isMatch = matchesSelector( cell.element, flkty.options.cellSelector );
+    cellsMatchSelector = cellsMatchSelector && isMatch;
+  }
+
+  // getCellElements()
+  var cellElems = flkty.getCellElements();
+  var queriedCellElems = elem.querySelectorAll( flkty.options.cellSelector );
+  assert.equal( cellElems.length, flkty.cells.length, 'getCellElements returns corrent number of elements' );
+  for( i=0, len = cellElems.length; i < len; i++ ) {
+    assert.equal( cellElems[i], queriedCellElems[i], 'cell element same as queried cell element' );
+  }
+
+  assert.ok( cellsMatchSelector, 'all cell elements match cellSelector' );
+
+  assert.equal( notCell1.parentNode, elem, 'notCell1 parent node is still gallery' );
+  assert.equal( notCell2.parentNode, elem, 'notCell2 parent node is still gallery' );
+
+});

node_modules/flickity/test/unit/change.js

@@ -0,0 +1,47 @@
+QUnit.test( 'change', function( assert ) {
+  'use strict';
+
+  var done = assert.async();
+
+  function onInitChange() {
+    assert.ok( false, 'change should not trigger on init' );
+  }
+
+  new Flickity( '#change', {
+    on: {
+      change: onInitChange,
+      ready: function() {
+        // define events last to first for strict
+        var onChangeC = function( index ) {
+          assert.equal( index, 0, 'change triggered on select back to 0' );
+          done();
+        };
+
+        var onChangeB = function() {
+          assert.ok( false, 'change should not trigger on same select' );
+        };
+
+        var onSelectB = function( index ) {
+          assert.equal( index, 1, 'select triggered on same select 1' );
+          this.off( 'change', onChangeB );
+          this.once( 'change', onChangeC );
+          this.select( 0, false, true );
+        };
+
+        var onChangeA = function( index ) {
+          assert.equal( index, 1, 'change triggered, selected 1');
+          this.once( 'change', onChangeB );
+          this.once( 'select', onSelectB );
+          // select 1 again
+          this.select( 1, false, true );
+        };
+
+        // kick off
+        this.off( 'change', onInitChange );
+        this.once( 'change', onChangeA );
+        this.select( 1, false, true );
+      }
+    },
+  });
+
+});

node_modules/flickity/test/unit/contain.js

@@ -0,0 +1,21 @@
+QUnit.test( 'contain', function( assert ) {
+
+  'use strict';
+
+  var flkty = new Flickity( '#contain', {
+    contain: true
+  });
+
+  assert.equal( Math.round( flkty.x + flkty.cursorPosition ), 0, 'selected at 0, position left edge' );
+  flkty.select( 1 );
+  flkty.positionSliderAtSelected();
+  assert.equal( Math.round( flkty.x + flkty.cursorPosition ), 0, 'selected at 1, position left edge' );
+  flkty.select( 4 );
+  flkty.positionSliderAtSelected();
+  var endLimit = flkty.slideableWidth - flkty.size.innerWidth * ( 1 - flkty.cellAlign );
+  assert.equal( Math.round( -endLimit ), Math.round( flkty.x ), 'selected at 4, position right edge' );
+  flkty.select( 5 );
+  flkty.positionSliderAtSelected();
+  assert.equal( Math.round( -endLimit ), Math.round( flkty.x ), 'selected at 5, position right edge' );
+
+});

node_modules/flickity/test/unit/destroy.js

@@ -0,0 +1,25 @@
+QUnit.test( 'destroy', function( assert ) {
+
+  'use strict';
+
+  var elem = document.querySelector('#destroy');
+  var flkty = new Flickity( elem );
+
+  var done = assert.async();
+  // do it async
+  setTimeout( function() {
+    flkty.destroy();
+    assert.strictEqual( elem.flickityGUID, undefined, 'flickityGUID removed' );
+    assert.ok( !flkty.isActive, 'not active' );
+    assert.ok( !Flickity.data( elem ), '.data() returns falsey' );
+    assert.ok( elem.children[0], '.cell', 'cell is back as first child' );
+    assert.ok( !matchesSelector( elem, '.flickity-enabled'), 'flickity-enabled class removed' );
+    assert.ok( !elem.querySelector('.flickity-prev-next-button'), 'no buttons' );
+    assert.ok( !elem.querySelector('.flickity-page-dots'), 'no page dots' );
+    assert.ok( !elem.style.height, 'no height set' );
+    assert.ok( !elem.children[0].style.left, 'first cell has no left position' );
+
+    done();
+  }, 20 );
+
+});

node_modules/flickity/test/unit/drag.js

@@ -0,0 +1,188 @@
+( function() {
+
+'use strict';
+
+var utils = window.fizzyUIUtils;
+
+function noop() {}
+
+var fakeDrag = window.fakeDrag = function( flkty, positions ) {
+
+  function fakeEvent( type, pageX ) {
+    return {
+      type: type,
+      pageX: pageX,
+      pageY: 0,
+      preventDefault: noop,
+      target: flkty.viewport
+    };
+  }
+
+  var hasBeenDown = false;
+
+  function triggerEvent() {
+    var position = positions.shift();
+    // down or move event
+    if ( !hasBeenDown ) {
+      var downEvent = fakeEvent( 'mousedown', position );
+      flkty._pointerDown( downEvent, downEvent );
+      hasBeenDown = true;
+    } else {
+      var moveEvent = fakeEvent( 'mousemove', position );
+      flkty._pointerMove( moveEvent, moveEvent );
+    }
+
+    if ( positions.length ) {
+      // loop next
+      setTimeout( triggerEvent, 40 );
+    } else {
+      // up event
+      var upEvent = fakeEvent( 'mouseup', position );
+      flkty._pointerUp( upEvent, upEvent );
+    }
+  }
+
+  triggerEvent();
+};
+
+var dragTests;
+// do each drag test one after another
+function getDoNextDragTest( done ) {
+  return function doNextDragTest() {
+    if ( dragTests.length ) {
+      var dragTest = dragTests.shift();
+      dragTest();
+    } else {
+      done();
+    }
+  };
+}
+
+// flickity, dragPositions, index, callback, message
+function getFakeDragTest( args ) {
+  var assert = args.assert;
+  var flkty = args.flickity;
+  var msgCell = 'slide[' + args.index + ']';
+
+  return function fakeDragTest() {
+    var selectMsg = ( args.message ? args.message + '. ' : '' ) + 'selected ' + msgCell;
+    flkty.once( 'select', function() {
+      assert.equal( flkty.selectedIndex, args.index, selectMsg );
+    });
+
+    var settleMsg = ( args.message ? args.message + '. ' : '' ) + 'settled ' + msgCell;
+    var target = flkty.slides[ args.index ].target;
+    flkty.once( 'settle', function() {
+      assert.equal( Math.round( -flkty.x ), Math.round( target ), settleMsg );
+      setTimeout( args.callback );
+    });
+
+    fakeDrag( args.flickity, args.dragPositions );
+  };
+}
+
+
+
+QUnit.test( 'drag', function( assert ) {
+  // async test
+  var done = assert.async();
+
+  var flkty = new Flickity('#drag');
+
+  var doNextDragTest = getDoNextDragTest( done );
+
+  function getDragTest( args ) {
+    args = utils.extend( args, {
+      assert: assert,
+      flickity: flkty,
+      callback: doNextDragTest
+    });
+    return getFakeDragTest( args );
+  }
+
+  dragTests = [
+    getDragTest({
+      message: 'drag to 2nd cell',
+      index: 1,
+      dragPositions: [ 0, -10, -20 ]
+    }),
+    getDragTest({
+      message: 'drag back to 1st cell',
+      index: 0,
+      dragPositions: [ 0, 10, 20 ]
+    }),
+    getDragTest({
+      message: 'big flick to 3rd cell',
+      index: 2,
+      dragPositions: [ 0, -10, -80 ]
+    }),
+    // minimal movement to trigger static click
+    function() {
+      flkty.once( 'staticClick', function() {
+        assert.ok( true, 'staticClick fired on non-drag');
+        assert.equal( flkty.selectedIndex, 2, 'selected index still at 2 after click' );
+        setTimeout( doNextDragTest );
+      });
+      fakeDrag( flkty, [ 0, 1, 0, -2, -1 ] );
+    },
+    // move out then back to where it started
+    function() {
+      flkty.once( 'settle', function() {
+        assert.equal( flkty.selectedIndex, 2, 'move out then back. same cell' );
+        setTimeout( doNextDragTest );
+      });
+      fakeDrag( flkty, [ 0, 10, 20, 30, 20 ] );
+    },
+    getDragTest({
+      message: 'drag and try to flick past 6th cell',
+      index: 5,
+      dragPositions: [ 0, -10, -50, -77, -100, -125, -150, -175, -250, -350 ]
+    })
+  ];
+
+  doNextDragTest();
+
+});
+
+QUnit.test( 'drag with wrapAround', function( assert ) {
+  // async test
+  var done = assert.async();
+
+  var flkty = new Flickity('#drag-wrap-around', {
+    wrapAround: true
+  });
+
+  var doNextDragTest = getDoNextDragTest( done );
+
+  function getDragTest( args ) {
+    args = utils.extend( args, {
+      assert: assert,
+      flickity: flkty,
+      callback: doNextDragTest
+    });
+    return getFakeDragTest( args );
+  }
+
+  dragTests = [
+    getDragTest({
+      message: 'drag to last cell via wrap-around',
+      index: 5,
+      dragPositions: [ 0, 10, 20 ]
+    }),
+    getDragTest({
+      message: 'drag to first cell via wrap-around',
+      index: 0,
+      dragPositions: [ 0, -10, -20 ]
+    }),
+    getDragTest({
+      message: 'big flick to 5th cell via wrap-around',
+      index: 4,
+      dragPositions: [ 0, 10, 80 ]
+    })
+  ];
+
+  doNextDragTest();
+
+});
+
+})();

node_modules/flickity/test/unit/empty.js

@@ -0,0 +1,39 @@
+QUnit.test( 'empty', function( assert ) {
+  'use strict';
+
+  var gallery = document.querySelector('#empty');
+
+  var flkty = new Flickity( gallery );
+
+  assert.ok( true, 'empty gallery ok' );
+  assert.ok( flkty.prevButton.element.disabled, 'previous button disabled' );
+  assert.ok( flkty.nextButton.element.disabled, 'next button disabled' );
+  assert.equal( flkty.pageDots.dots.length, 0, '0 page dots');
+
+  flkty.resize();
+  assert.ok( true, 'resize with empty gallery ok');
+
+  function makeCellElem() {
+    var cellElem = document.createElement('div');
+    cellElem.className = 'cell';
+    return cellElem;
+  }
+
+  flkty.append( makeCellElem() );
+  assert.equal( flkty.cells.length, 1, 'added cell to empty gallery' );
+
+
+  assert.ok( flkty.prevButton.element.disabled, 'previous button disabled' );
+  assert.ok( flkty.nextButton.element.disabled, 'next button disabled' );
+  assert.equal( flkty.pageDots.dots.length, 1, '1 page dots');
+
+  // destroy and re-init with higher initialIndex
+  flkty.destroy();
+  flkty = new Flickity( gallery, {
+    initialIndex: 2
+  });
+
+  // #291
+  assert.ok( true, 'initializing with initialIndex > cells doesnt throw error' );
+
+});

node_modules/flickity/test/unit/get-parent-cell.js

@@ -0,0 +1,37 @@
+QUnit.test( 'getParentCell', function( assert ) {
+  'use strict';
+
+  var gallery = document.querySelector('#get-parent-cell');
+  var flkty = new Flickity( gallery );
+
+  // cell1
+  var cell = flkty.getParentCell( gallery.querySelector('.cell1') );
+  assert.ok( cell, 'getParentCell( cell ) ok' );
+  assert.ok( cell instanceof Flickity.Cell, 'cell is Flickity.Cell' );
+  var index = flkty.cells.indexOf( cell );
+  assert.equal( index, 0, 'cell is index 0' );
+  // cell3
+  cell = flkty.getParentCell( gallery.querySelector('.cell3') );
+  assert.ok( cell, 'getParentCell( cell ) ok' );
+  assert.ok( cell instanceof Flickity.Cell, 'cell is Flickity.Cell' );
+  index = flkty.cells.indexOf( cell );
+  assert.equal( index, 2, 'cell is index 2' );
+  // child1
+  cell = flkty.getParentCell( gallery.querySelector('.child1') );
+  assert.ok( cell, 'getParentCell( cell ) ok' );
+  assert.ok( cell instanceof Flickity.Cell, 'cell is Flickity.Cell' );
+  index = flkty.cells.indexOf( cell );
+  assert.equal( index, 0, 'cell is index 0' );
+  // child2
+  cell = flkty.getParentCell( gallery.querySelector('.child2') );
+  assert.ok( cell, 'getParentCell( cell ) ok' );
+  assert.ok( cell instanceof Flickity.Cell, 'cell is Flickity.Cell' );
+  index = flkty.cells.indexOf( cell );
+  assert.equal( index, 1, 'cell is index 1' );
+  // outside
+  cell = flkty.getParentCell( document.querySelector('.outside') );
+  assert.ok( !cell, 'getParentCell( notCell ) not ok' );
+  index = flkty.cells.indexOf( cell );
+  assert.equal( index, -1, 'not cell is index -1' );
+
+});

node_modules/flickity/test/unit/get-wrap-cells.js

@@ -0,0 +1,24 @@
+QUnit.test( 'getWrapCells', function( assert ) {
+  'use strict';
+
+  var flkty = new Flickity( '#get-wrap-cells', {
+    wrapAround: true
+  });
+  // cells are 25% width
+  // center align, 2 cells on each side
+  assert.equal( flkty.beforeShiftCells.length, 2, 'center align, 2 before shift cells' );
+  assert.equal( flkty.afterShiftCells.length, 2, 'center align, 2 after shift cells' );
+
+  flkty.options.cellAlign = 'left';
+  flkty.resize();
+  // left align, 0, 4
+  assert.equal( flkty.beforeShiftCells.length, 0, 'left align, 1 before shift cells' );
+  assert.equal( flkty.afterShiftCells.length, 4, 'left align, 4 after shift cells' );
+
+  flkty.options.cellAlign = 'right';
+  flkty.resize();
+  // right align, 4, 0
+  assert.equal( flkty.beforeShiftCells.length, 4, 'right align, 4 before shift cells' );
+  assert.equal( flkty.afterShiftCells.length, 0, 'right align, 0 after shift cells' );
+
+});

node_modules/flickity/test/unit/group-cells.js

@@ -0,0 +1,39 @@
+QUnit.test( 'groupCells', function( assert ) {
+  'use strict';
+
+  var flkty = new Flickity( '#group-cells', {
+    groupCells: true
+  });
+
+  function getSlideCellsCount() {
+    var counts = flkty.slides.map( function( slide ) {
+      return slide.cells.length;
+    });
+    return counts.join(',');
+  }
+
+  assert.equal( getSlideCellsCount(), '3,2,2,1,1,3,2', 'groupCells: true' );
+  var targets = flkty.slides.map( function( slide ) {
+    return slide.target;
+  });
+  assert.deepEqual( targets, [200, 600, 1000, 1300, 1600, 2000, 2300], 'targets' );
+
+  flkty.selectCell( 6 );
+  assert.equal( flkty.selectedIndex, 2, 'selectCell(6) selects 3rd slide' );
+  flkty.selectCell( flkty.cells[2].element );
+  assert.equal( flkty.selectedIndex, 0, 'selectCell(3rd elem) selects 1st slide' );
+
+  flkty.options.groupCells = 2;
+  flkty.reposition();
+  assert.equal( getSlideCellsCount(), '2,2,2,2,2,2,2', 'groupCells: 2' );
+
+  flkty.options.groupCells = '75%';
+  flkty.reposition();
+  assert.equal( getSlideCellsCount(), '2,1,1,2,1,1,1,2,2,1', 'groupCells: 75%' );
+
+  flkty.element.classList.add('is-expanded'); // 600px wide
+  flkty.options.groupCells = true;
+  flkty.resize();
+  assert.equal( getSlideCellsCount(), '3,3,2,3,3', 'groupCells: true, container @ 600px' );
+
+});

node_modules/flickity/test/unit/init.js

@@ -0,0 +1,37 @@
+( function() {
+
+'use strict';
+
+QUnit.module('Flickity');
+
+var utils = window.fizzyUIUtils;
+
+QUnit.test( 'init', function( assert ) {
+
+  var elem = document.querySelector('#init');
+  var flkty = new Flickity( elem );
+
+  for ( var prop in Flickity.defaults ) {
+    assert.equal( flkty.options[ prop ], Flickity.defaults[ prop ], prop + ' option matches default' );
+  }
+
+  assert.equal( flkty.element, elem, '.element is proper element' );
+  var children = utils.makeArray( flkty.element.children );
+  assert.notEqual( children.indexOf( flkty.viewport ), -1, 'viewport element is a child element' );
+  assert.equal( flkty.viewport.children[0], flkty.slider, 'slider is in viewport' );
+  assert.equal( flkty.viewport.style.height, '100px', 'viewport height set' );
+
+  assert.ok( flkty.isActive, 'isActive' );
+  assert.ok( matchesSelector( elem, '.flickity-enabled' ), 'flickity-enabled class added' );
+
+  assert.equal( flkty.cells.length, 6, 'has 6 cells' );
+  assert.equal( flkty.cells[0].element.style.left, '0%', 'first cell left: 0%' );
+  assert.equal( flkty.cells[5].element.style.left, '500%', '6th cell left: 500%' );
+
+  assert.equal( flkty.selectedIndex, 0, 'selectedIndex = 0' );
+  assert.equal( flkty.cursorPosition, 200, 'cursorPosition = 200' );
+  assert.equal( flkty.x + flkty.cursorPosition, 0, 'x + cursorPosition = 0' );
+
+});
+
+})();

node_modules/flickity/test/unit/initial-index.js

@@ -0,0 +1,26 @@
+QUnit.test( 'initialIndex', function( assert ) {
+  'use strict';
+  // initialIndex number
+  var flkty = new Flickity( '#initial-index', {
+    initialIndex: 3,
+  });
+  assert.equal( flkty.selectedIndex, 3, 'initialIndex number' );
+  // selectedIndex remains same after reactivation
+  flkty.deactivate();
+  flkty.activate();
+  assert.equal( flkty.selectedIndex, 3, 'reactivated selectedIndex stays the same' );
+  flkty.destroy();
+  // initialIndex selector string
+  flkty = new Flickity( '#initial-index', {
+    initialIndex: '.cell--initial',
+  });
+  assert.equal( flkty.selectedIndex, 4, 'initialIndex selector string' );
+  flkty.destroy();
+  // initialIndex selector string with groupCells #881
+  flkty = new Flickity( '#initial-index', {
+    groupCells: 3,
+    initialIndex: '.cell--initial',
+  });
+  assert.equal( flkty.selectedIndex, 1, 'initialIndex selector string with groupCells' );
+
+});

node_modules/flickity/test/unit/lazyload-srcset.js

@@ -0,0 +1,29 @@
+QUnit.test( 'lazyload srcset', function( assert ) {
+  'use strict';
+
+  var done = assert.async();
+
+  var gallery = document.querySelector('#lazyload-srcset');
+  var flkty = new Flickity( gallery, {
+    lazyLoad: 1
+  });
+
+  var loadCount = 0;
+  flkty.on( 'lazyLoad', function( event, cellElem ) {
+    loadCount++;
+
+    assert.equal( event.type, 'load', 'event.type == load' );
+    assert.ok( event.target.complete, 'img ' + loadCount + ' is complete' );
+    assert.ok( cellElem, 'cellElement argument there' );
+    var srcset = event.target.getAttribute('srcset');
+    assert.ok( srcset, 'srcset attribute set');
+    var lazyAttr = event.target.getAttribute('data-flickity-lazyload-srcset');
+    assert.ok( !lazyAttr, 'data-flickity-lazyload attribute removed' );
+
+    // after first 2 have loaded, select 7th cell
+    if ( loadCount == 2 ) {
+      done();
+    }
+  });
+
+});

node_modules/flickity/test/unit/lazyload.js

@@ -0,0 +1,32 @@
+QUnit.test( 'lazyload', function( assert ) {
+  'use strict';
+
+  var done = assert.async();
+
+  var gallery = document.querySelector('#lazyload');
+  var flkty = new Flickity( gallery, {
+    lazyLoad: 1
+  });
+
+  var loadCount = 0;
+  flkty.on( 'lazyLoad', function( event, cellElem ) {
+    loadCount++;
+
+    assert.equal( event.type, 'load', 'event.type == load' );
+    assert.ok( event.target.complete, 'img ' + loadCount + ' is complete' );
+    assert.ok( cellElem, 'cellElement argument there' );
+    var lazyAttr = event.target.getAttribute('data-flickity-lazyload');
+    assert.ok( !lazyAttr, 'data-flickity-lazyload attribute removed' );
+
+    // after first 2 have loaded, select 7th cell
+    if ( loadCount == 2 ) {
+      flkty.select( 6 );
+    }
+    if ( loadCount == 5 ) {
+      var loadedImgs = gallery.querySelectorAll('.flickity-lazyloaded');
+      assert.equal( loadedImgs.length, '5', 'only 5 images loaded' );
+      done();
+    }
+  });
+
+});

node_modules/flickity/test/unit/page-dots.js

@@ -0,0 +1,33 @@
+QUnit.test( 'pageDots', function( assert ) {
+  'use strict';
+
+  var elem = document.querySelector('#page-dots');
+  var flkty = new Flickity( elem );
+
+  var dotsHolder = elem.querySelector('.flickity-page-dots');
+  var dotsElems = dotsHolder.querySelectorAll('.dot');
+
+  assert.ok( dotsHolder, 'dots holder in DOM' );
+  assert.equal( flkty.pageDots.holder, dotsHolder, 'dots holder element matches flkty.pageDots.holder' );
+  assert.equal( dotsElems.length, flkty.cells.length, 'number of dots matches number of cells' );
+
+  function getSelectedDotIndex() {
+    var selectedDot = dotsHolder.querySelector('.is-selected');
+    for ( var i=0, len = dotsElems.length; i < len; i++ ) {
+      var dotElem = dotsElems[i];
+      if ( dotElem == selectedDot ) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  assert.equal( getSelectedDotIndex(), 0, 'first dot is selected' );
+  flkty.select( 2 );
+  assert.equal( getSelectedDotIndex(), 2, '3rd dot is selected' );
+
+  // fake tap
+  flkty.pageDots.onTap( { target: dotsElems[4] } );
+  assert.equal( flkty.selectedIndex, 4, 'tap dot selects cell' );
+
+});

node_modules/flickity/test/unit/position-cells.js

@@ -0,0 +1,51 @@
+( function() {
+
+'use strict';
+
+// position values can be off by 0.1% or 1px
+function isPositionApprox( value, expected ) {
+  var isPercent = value.indexOf('%') != -1;
+  value = parseFloat( value );
+  var diff = Math.abs( expected - value );
+  return isPercent ? diff < 0.1 : diff <= 1;
+}
+
+// loop through cells and check position values against expecteds
+function checkCellPositions( flkty, expecteds ) {
+  var isOK;
+  for ( var i=0, len = expecteds.length; i < len; i++ ) {
+    var expected = expecteds[i];
+    var cell = flkty.cells[i];
+    var position = cell.element.style.left;
+    isOK = isPositionApprox( position, expected );
+    if ( !isOK ) {
+      console.error( 'wrong cell position, index: ' + i + '. ' +
+        'expected: ' + expected + '. position: ' + position );
+      break;
+    }
+  }
+  return isOK;
+}
+
+QUnit.test( 'position cells', function( assert ) {
+
+  var flkty = new Flickity('#position-cells');
+
+  assert.ok( checkCellPositions( flkty, [ 0, 40, 65, 125, 165, 225 ] ), 'percent cell position' );
+  // .cell { margin: 0 2%; }
+  flkty.element.classList.add('percent-margin');
+  flkty.positionCells();
+  assert.ok( checkCellPositions( flkty, [ 0, 44, 73, 137, 181, 245 ] ), 'percent cell position with margin' );
+  flkty.element.classList.remove('percent-margin');
+  // pixel-based position
+  flkty.options.percentPosition = false;
+  flkty.positionCells();
+  assert.ok( checkCellPositions( flkty, [ 0, 160, 260, 500, 660, 900 ] ), 'pixel cell position' );
+  // pixel margin, { margin: 0 10px; }
+  flkty.element.classList.add('pixel-margin');
+  flkty.positionCells();
+  assert.ok( checkCellPositions( flkty, [ 0, 180, 300, 560, 740, 1000 ] ), 'pixel cell position with margin' );
+
+});
+
+})();

node_modules/flickity/test/unit/prev-next-buttons.js

@@ -0,0 +1,27 @@
+QUnit.test( 'prev-next-buttons', function( assert ) {
+  'use strict';
+
+  var elem = document.querySelector('#prev-next-buttons');
+  var flkty = new Flickity( elem );
+
+  var prevElem = elem.querySelector('.flickity-prev-next-button.previous');
+  var nextElem = elem.querySelector('.flickity-prev-next-button.next');
+  assert.ok( prevElem, 'previous button in DOM' );
+  assert.ok( nextElem, 'next button in DOM' );
+  assert.equal( flkty.prevButton.element, prevElem, 'previous button element matches prevButton.element' );
+  assert.equal( flkty.nextButton.element, nextElem, 'next button element matches nextButton.element' );
+  assert.ok( prevElem.disabled, 'previous button is disabled at first index' );
+
+  prevElem.focus();
+  prevElem.click();
+  assert.equal( flkty.selectedIndex, 0, 'selectedIndex still at 0' );
+  nextElem.focus();
+  nextElem.click();
+  assert.equal( flkty.selectedIndex, 1, 'next button clicked, selectedIndex at 1' );
+  prevElem.focus();
+  prevElem.click();
+  assert.equal( flkty.selectedIndex, 0, 'previous button clicked, selectedIndex back at 0' );
+  flkty.select( 5 );
+  assert.ok( nextElem.disabled, 'next button disabled when at last cell' );
+
+});

node_modules/flickity/test/unit/resize.js

@@ -0,0 +1,16 @@
+QUnit.test( 'resize', function( assert ) {
+
+  'use strict';
+
+  var elem = document.querySelector('#resize');
+  var flkty = new Flickity( elem, {
+    initialIndex: 2
+  });
+  elem.style.width = '500px';
+  flkty.resize();
+
+  assert.equal( flkty.selectedIndex, 2, 'selectedIndex = 2' );
+  assert.equal( flkty.cursorPosition, 250, 'cursorPosition = 250' );
+  assert.equal( flkty.x + flkty.cursorPosition, -1000, 'x + cursorPosition = -1000' );
+
+});

node_modules/flickity/test/unit/select-cell.js

@@ -0,0 +1,18 @@
+QUnit.test( 'selectCell', function( assert ) {
+  'use strict';
+
+  var gallery = document.querySelector('#select-cell');
+  var cellElems = gallery.querySelectorAll('.cell');
+  var flkty = new Flickity( gallery, {
+    groupCells: true, // groups of 3
+  });
+
+  flkty.selectCell( 3 );
+  assert.equal( flkty.selectedIndex, 1, 'selectCell number' );
+  flkty.selectCell( cellElems[1] );
+  assert.equal( flkty.selectedIndex, 0, 'selectCell element' );
+  flkty.selectCell('.select-cell__6');
+  assert.equal( flkty.selectedIndex, 2, 'selectCell selector string' );
+  flkty.selectCell('none');
+  assert.equal( flkty.selectedIndex, 2, 'selectCell bad string is okay' );
+});

node_modules/flickity/test/unit/watch.js

@@ -0,0 +1,10 @@
+QUnit.test( 'watch fallback', function( assert ) {
+  'use strict';
+
+  var elem = document.querySelector('#watch');
+  var flkty = new Flickity( elem, {
+    watchCSS: true
+  });
+
+  assert.ok( !flkty.isActive, 'fallback not active, watchCSS: true' );
+});