https://www.ntu.org/content/public/js/bundle.min.js

209  getSize.isBoxSizeOuter = isBoxSizeOuter = getStyleSize( style.width ) == 200;
210  body.removeChild( div );
211
212}
213
214// -------------------------- getSize -------------------------- //
215
216function getSize( elem ) {
217  setup();
218
219  // use querySeletor if elem is string
220  if ( typeof elem == 'string' ) {
221    elem = document.querySelector( elem );
222  }
223
224  // do not proceed on non-objects
225  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
226    return;
227  }
228
229  var style = getStyle( elem );
230
231  // if hidden, everything is 0
232  if ( style.display == 'none' ) {
233    return getZeroSize();
234  }
235
236  var size = {};
237  size.width = elem.offsetWidth;
238  size.height = elem.offsetHeight;
239
240  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
241
242  // get all measurements
243  for ( var i=0; i < measurementsLength; i++ ) {
244    var measurement = measurements[i];
245    var value = style[ measurement ];
246    var num = parseFloat( value );
247    // any 'auto', 'medium' value will be 0
248    size[ measurement ] = !isNaN( num ) ? num : 0;
249  }
250
251  var paddingWidth = size.paddingLeft + size.paddingRight;
252  var paddingHeight = size.paddingTop + size.paddingBottom;
253  var marginWidth = size.marginLeft + size.marginRight;
254  var marginHeight = size.marginTop + size.marginBottom;
255  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
256  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
257
258  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
259
260  // overwrite width and height if we can get it from style
261  var styleWidth = getStyleSize( style.width );
262  if ( styleWidth !== false ) {
263    size.width = styleWidth +
264      // add padding and border unless it's already including it
265      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
266  }
267
268  var styleHeight = getStyleSize( style.height );
269  if ( styleHeight !== false ) {
270    size.height = styleHeight +
271      // add padding and border unless it's already including it
272      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
273  }
274
275  size.innerWidth = size.width - ( paddingWidth + borderWidth );
276  size.innerHeight = size.height - ( paddingHeight + borderHeight );
277
278  size.outerWidth = size.width + marginWidth;
279  size.outerHeight = size.height + marginHeight;
280
281  return size;
282}
283
284return getSize;
285
286});
287
288
289/***/ }),
290/* 2 */
291/***/ (function(module, exports, __webpack_require__) {
292
293var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
294 * Outlayer v2.1.1
295 * the brains and guts of a layout library
296 * MIT license
297 */
298
299( function( window, factory ) {
300  'use strict';
301  // universal module definition
302  /* jshint strict: false */ /* globals define, module, require */
303  if ( true ) {
304    // AMD - RequireJS
305    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
306        __webpack_require__(7),
307        __webpack_require__(1),
308        __webpack_require__(6),
309        __webpack_require__(12)
310      ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( EvEmitter, getSize, utils, Item ) {
311        return factory( window, EvEmitter, getSize, utils, Item);
312      }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
313				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
314  } else if ( typeof module == 'object' && module.exports ) {
315    // CommonJS - Browserify, Webpack
316    module.exports = factory(
317      window,
318      require('ev-emitter'),
319      require('get-size'),
320      require('fizzy-ui-utils'),
321      require('./item')
322    );
323  } else {
324    // browser global
325    window.Outlayer = factory(
326      window,
327      window.EvEmitter,
328      window.getSize,
329      window.fizzyUIUtils,
330      window.Outlayer.Item
331    );
332  }
333
334}( window, function factory( window, EvEmitter, getSize, utils, Item ) {
335'use strict';
336
337// ----- vars ----- //
338
339var console = window.console;
340var jQuery = window.jQuery;
341var noop = function() {};
342
343// -------------------------- Outlayer -------------------------- //
344
345// globally unique identifiers
346var GUID = 0;
347// internal store of all Outlayer intances
348var instances = {};
349
350
351/**
352 * @param {Element, String} element
353 * @param {Object} options
354 * @constructor
355 */
356function Outlayer( element, options ) {
357  var queryElement = utils.getQueryElement( element );
358  if ( !queryElement ) {
359    if ( console ) {
360      console.error( 'Bad element for ' + this.constructor.namespace +
361        ': ' + ( queryElement || element ) );
362    }
363    return;
364  }
365  this.element = queryElement;
366  // add jQuery
367  if ( jQuery ) {
368    this.$element = jQuery( this.element );
369  }
370
371  // options
372  this.options = utils.extend( {}, this.constructor.defaults );
373  this.option( options );
374
375  // add id for Outlayer.getFromElement
376  var id = ++GUID;
377  this.element.outlayerGUID = id; // expando
378  instances[ id ] = this; // associate via id
379
380  // kick it off
381  this._create();
382
383  var isInitLayout = this._getOption('initLayout');
384  if ( isInitLayout ) {
385    this.layout();
386  }
387}
388
389// settings are for internal use only
390Outlayer.namespace = 'outlayer';
391Outlayer.Item = Item;
392
393// default options
394Outlayer.defaults = {
395  containerStyle: {
396    position: 'relative'
397  },
398  initLayout: true,
399  originLeft: true,
400  originTop: true,
401  resize: true,
402  resizeContainer: true,
403  // item options
404  transitionDuration: '0.4s',
405  hiddenStyle: {
406    opacity: 0,
407    transform: 'scale(0.001)'
408  },
409  visibleStyle: {
410    opacity: 1,
411    transform: 'scale(1)'
412  }
413};
414
415var proto = Outlayer.prototype;
416// inherit EvEmitter
417utils.extend( proto, EvEmitter.prototype );
418
419/**
420 * set options
421 * @param {Object} opts
422 */
423proto.option = function( opts ) {
424  utils.extend( this.options, opts );
425};

426
427/**
428 * get backwards compatible option value, check old name
429 */
430proto._getOption = function( option ) {
431  var oldOption = this.constructor.compatOptions[ option ];
432  return oldOption && this.options[ oldOption ] !== undefined ?
433    this.options[ oldOption ] : this.options[ option ];
434};
435
436Outlayer.compatOptions = {
437  // currentName: oldName
438  initLayout: 'isInitLayout',
439  horizontal: 'isHorizontal',
440  layoutInstant: 'isLayoutInstant',
441  originLeft: 'isOriginLeft',
442  originTop: 'isOriginTop',
443  resize: 'isResizeBound',
444  resizeContainer: 'isResizingContainer'
445};
446
447proto._create = function() {
448  // get items from children
449  this.reloadItems();
450  // elements that affect layout, but are not laid out
451  this.stamps = [];
452  this.stamp( this.options.stamp );
453  // set container style
454  utils.extend( this.element.style, this.options.containerStyle );
455
456  // bind resize method
457  var canBindResize = this._getOption('resize');
458  if ( canBindResize ) {
459    this.bindResize();
460  }
461};
462
463// goes through all children again and gets bricks in proper order
464proto.reloadItems = function() {
465  // collection of item elements
466  this.items = this._itemize( this.element.children );
467};
468
469
470/**
471 * turn elements into Outlayer.Items to be used in layout
472 * @param {Array or NodeList or HTMLElement} elems
473 * @returns {Array} items - collection of new Outlayer Items
474 */
475proto._itemize = function( elems ) {
476
477  var itemElems = this._filterFindItemElements( elems );
478  var Item = this.constructor.Item;
479
480  // create new Outlayer Items for collection
481  var items = [];
482  for ( var i=0; i < itemElems.length; i++ ) {
483    var elem = itemElems[i];
484    var item = new Item( elem, this );
485    items.push( item );
486  }
487
488  return items;
489};
490
491/**
492 * get item elements to be used in layout
493 * @param {Array or NodeList or HTMLElement} elems
494 * @returns {Array} items - item elements
495 */
496proto._filterFindItemElements = function( elems ) {
497  return utils.filterFindElements( elems, this.options.itemSelector );
498};
499
500/**
501 * getter method for getting item elements
502 * @returns {Array} elems - collection of item elements
503 */
504proto.getItemElements = function() {
505  return this.items.map( function( item ) {
506    return item.element;
507  });
508};
509
510// ----- init & layout ----- //
511
512/**
513 * lays out all items
514 */
515proto.layout = function() {
516  this._resetLayout();
517  this._manageStamps();
518
519  // don't animate first layout
520  var layoutInstant = this._getOption('layoutInstant');
521  var isInstant = layoutInstant !== undefined ?
522    layoutInstant : !this._isLayoutInited;
523  this.layoutItems( this.items, isInstant );
524
525  // flag for initalized
526  this._isLayoutInited = true;
527};
528
529// _init is alias for layout
530proto._init = proto.layout;
531
532/**
533 * logic before any new layout
534 */
535proto._resetLayout = function() {
536  this.getSize();
537};
538
539
540proto.getSize = function() {
541  this.size = getSize( this.element );
542};
543
544/**
545 * get measurement from option, for columnWidth, rowHeight, gutter
546 * if option is String -> get element from selector string, & get size of element
547 * if option is Element -> get size of element
548 * else use option as a number
549 *
550 * @param {String} measurement
551 * @param {String} size - width or height
552 * @private
553 */
554proto._getMeasurement = function( measurement, size ) {
555  var option = this.options[ measurement ];
556  var elem;
557  if ( !option ) {
558    // default to 0
559    this[ measurement ] = 0;
560  } else {
561    // use option as an element
562    if ( typeof option == 'string' ) {
563      elem = this.element.querySelector( option );
564    } else if ( option instanceof HTMLElement ) {
565      elem = option;
566    }
567    // use size of element, if element
568    this[ measurement ] = elem ? getSize( elem )[ size ] : option;
569  }
570};
571
572/**
573 * layout a collection of item elements
574 * @api public
575 */
576proto.layoutItems = function( items, isInstant ) {
577  items = this._getItemsForLayout( items );
578
579  this._layoutItems( items, isInstant );
580
581  this._postLayout();
582};
583
584/**
585 * get the items to be laid out
586 * you may want to skip over some items
587 * @param {Array} items
588 * @returns {Array} items
589 */
590proto._getItemsForLayout = function( items ) {
591  return items.filter( function( item ) {
592    return !item.isIgnored;
593  });
594};
595
596/**
597 * layout items
598 * @param {Array} items
599 * @param {Boolean} isInstant
600 */
601proto._layoutItems = function( items, isInstant ) {
602  this._emitCompleteOnItems( 'layout', items );
603
604  if ( !items || !items.length ) {
605    // no items, emit event with empty array
606    return;
607  }
608
609  var queue = [];
610
611  items.forEach( function( item ) {
612    // get x/y object from method
613    var position = this._getItemLayoutPosition( item );
614    // enqueue
615    position.item = item;
616    position.isInstant = isInstant || item.isLayoutInstant;
617    queue.push( position );
618  }, this );
619
620  this._processLayoutQueue( queue );
621};
622
623/**
624 * get item layout position
625 * @param {Outlayer.Item} item
626 * @returns {Object} x and y position
627 */
628proto._getItemLayoutPosition = function( /* item */ ) {
629  return {
630    x: 0,
631    y: 0
632  };
633};
634
635/**
636 * iterate over array and position each item
637 * Reason being - separating this logic prevents 'layout invalidation'
638 * thx @paul_irish
639 * @param {Array} queue
640 */
641proto._processLayoutQueue = function( queue ) {
642  this.updateStagger();
643  queue.forEach( function( obj, i ) {
644    this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );
645  }, this );
646};
647
648// set stagger from option in milliseconds number
649proto.updateStagger = function() {
650  var stagger = this.options.stagger;
651  if ( stagger === null || stagger === undefined ) {
652    this.stagger = 0;
653    return;
654  }
655  this.stagger = getMilliseconds( stagger );
656  return this.stagger;
657};
658
659/**
660 * Sets position of item in DOM
661 * @param {Outlayer.Item} item
662 * @param {Number} x - horizontal position
663 * @param {Number} y - vertical position
664 * @param {Boolean} isInstant - disables transitions
665 */
666proto._positionItem = function( item, x, y, isInstant, i ) {
667  if ( isInstant ) {
668    // if not transition, just set CSS
669    item.goTo( x, y );
670  } else {
671    item.stagger( i * this.stagger );
672    item.moveTo( x, y );
673  }
674};
675
676/**
677 * Any logic you want to do after each layout,
678 * i.e. size the container
679 */
680proto._postLayout = function() {
681  this.resizeContainer();
682};
683
684proto.resizeContainer = function() {
685  var isResizingContainer = this._getOption('resizeContainer');
686  if ( !isResizingContainer ) {
687    return;
688  }
689  var size = this._getContainerSize();
690  if ( size ) {
691    this._setContainerMeasure( size.width, true );
692    this._setContainerMeasure( size.height, false );
693  }
694};
695
696/**
697 * Sets width or height of container if returned
698 * @returns {Object} size
699 *   @param {Number} width
700 *   @param {Number} height
701 */
702proto._getContainerSize = noop;
703
704/**
705 * @param {Number} measure - size of width or height
706 * @param {Boolean} isWidth
707 */
708proto._setContainerMeasure = function( measure, isWidth ) {
709  if ( measure === undefined ) {
710    return;
711  }
712
713  var elemSize = this.size;
714  // add padding and border width if border box
715  if ( elemSize.isBorderBox ) {
716    measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +
717      elemSize.borderLeftWidth + elemSize.borderRightWidth :
718      elemSize.paddingBottom + elemSize.paddingTop +
719      elemSize.borderTopWidth + elemSize.borderBottomWidth;
720  }
721
722  measure = Math.max( measure, 0 );
723  this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';
724};
725
726/**
727 * emit eventComplete on a collection of items events
728 * @param {String} eventName
729 * @param {Array} items - Outlayer.Items
730 */
731proto._emitCompleteOnItems = function( eventName, items ) {
732  var _this = this;
733  function onComplete() {
734    _this.dispatchEvent( eventName + 'Complete', null, [ items ] );
735  }
736
737  var count = items.length;
738  if ( !items || !count ) {
739    onComplete();
740    return;
741  }
742
743  var doneCount = 0;
744  function tick() {
745    doneCount++;
746    if ( doneCount == count ) {
747      onComplete();
748    }
749  }
750
751  // bind callback
752  items.forEach( function( item ) {
753    item.once( eventName, tick );
754  });
755};
756
757/**
758 * emits events via EvEmitter and jQuery events
759 * @param {String} type - name of event
760 * @param {Event} event - original event
761 * @param {Array} args - extra arguments
762 */
763proto.dispatchEvent = function( type, event, args ) {
764  // add original event to arguments
765  var emitArgs = event ? [ event ].concat( args ) : args;
766  this.emitEvent( type, emitArgs );
767
768  if ( jQuery ) {
769    // set this.$element
770    this.$element = this.$element || jQuery( this.element );
771    if ( event ) {
772      // create jQuery event
773      var $event = jQuery.Event( event );
774      $event.type = type;
775      this.$element.trigger( $event, args );
776    } else {
777      // just trigger with type if no event available
778      this.$element.trigger( type, args );
779    }
780  }
781};
782
783// -------------------------- ignore & stamps -------------------------- //
784
785
786/**
787 * keep item in collection, but do not lay it out
788 * ignored items do not get skipped in layout
789 * @param {Element} elem
790 */
791proto.ignore = function( elem ) {
792  var item = this.getItem( elem );
793  if ( item ) {
794    item.isIgnored = true;
795  }
796};
797
798/**
799 * return item to layout collection
800 * @param {Element} elem
801 */
802proto.unignore = function( elem ) {
803  var item = this.getItem( elem );
804  if ( item ) {
805    delete item.isIgnored;
806  }
807};
808
809/**
810 * adds elements to stamps
811 * @param {NodeList, Array, Element, or String} elems
812 */
813proto.stamp = function( elems ) {
814  elems = this._find( elems );
815  if ( !elems ) {
816    return;
817  }
818
819  this.stamps = this.stamps.concat( elems );
820  // ignore
821  elems.forEach( this.ignore, this );
822};
823
824/**
825 * removes elements to stamps
826 * @param {NodeList, Array, or Element} elems
827 */
828proto.unstamp = function( elems ) {
829  elems = this._find( elems );
830  if ( !elems ){
831    return;
832  }
833
834  elems.forEach( function( elem ) {
835    // filter out removed stamp elements
836    utils.removeFrom( this.stamps, elem );
837    this.unignore( elem );
838  }, this );
839};
840
841/**
842 * finds child elements
843 * @param {NodeList, Array, Element, or String} elems
844 * @returns {Array} elems
845 */
846proto._find = function( elems ) {
847  if ( !elems ) {
848    return;
849  }
850  // if string, use argument as selector string
851  if ( typeof elems == 'string' ) {
852    elems = this.element.querySelectorAll( elems );
853  }
854  elems = utils.makeArray( elems );
855  return elems;
856};
857
858proto._manageStamps = function() {
859  if ( !this.stamps || !this.stamps.length ) {
860    return;
861  }
862
863  this._getBoundingRect();
864
865  this.stamps.forEach( this._manageStamp, this );
866};
867
868// update boundingLeft / Top
869proto._getBoundingRect = function() {
870  // get bounding rect for container element
871  var boundingRect = this.element.getBoundingClientRect();
872  var size = this.size;
873  this._boundingRect = {
874    left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,
875    top: boundingRect.top + size.paddingTop + size.borderTopWidth,
876    right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),
877    bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )
878  };
879};
880
881/**
882 * @param {Element} stamp
883**/
884proto._manageStamp = noop;
885
886/**
887 * get x/y position of element relative to container element
888 * @param {Element} elem
889 * @returns {Object} offset - has left, top, right, bottom
890 */
891proto._getElementOffset = function( elem ) {
892  var boundingRect = elem.getBoundingClientRect();
893  var thisRect = this._boundingRect;
894  var size = getSize( elem );
895  var offset = {
896    left: boundingRect.left - thisRect.left - size.marginLeft,
897    top: boundingRect.top - thisRect.top - size.marginTop,
898    right: thisRect.right - boundingRect.right - size.marginRight,
899    bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom
900  };
901  return offset;
902};
903
904// -------------------------- resize -------------------------- //
905
906// enable event handlers for listeners
907// i.e. resize -> onresize
908proto.handleEvent = utils.handleEvent;
909
910/**
911 * Bind layout to window resizing
912 */
913proto.bindResize = function() {
914  window.addEventListener( 'resize', this );
915  this.isResizeBound = true;
916};
917
918/**
919 * Unbind layout to window resizing
920 */
921proto.unbindResize = function() {
922  window.removeEventListener( 'resize', this );
923  this.isResizeBound = false;
924};
925
926proto.onresize = function() {
927  this.resize();
928};
929
930utils.debounceMethod( Outlayer, 'onresize', 100 );
931
932proto.resize = function() {
933  // don't trigger if size did not change
934  // or if resize was unbound. See #9
935  if ( !this.isResizeBound || !this.needsResizeLayout() ) {
936    return;
937  }
938
939  this.layout();
940};
941
942/**
943 * check if layout is needed post layout
944 * @returns Boolean
945 */
946proto.needsResizeLayout = function() {
947  var size = getSize( this.element );
948  // check that this.size and size are there
949  // IE8 triggers resize on body size change, so they might not be
950  var hasSizes = this.size && size;
951  return hasSizes && size.innerWidth !== this.size.innerWidth;
952};

953
954// -------------------------- methods -------------------------- //
955
956/**
957 * add items to Outlayer instance
958 * @param {Array or NodeList or Element} elems
959 * @returns {Array} items - Outlayer.Items
960**/
961proto.addItems = function( elems ) {
962  var items = this._itemize( elems );
963  // add items to collection
964  if ( items.length ) {
965    this.items = this.items.concat( items );
966  }
967  return items;
968};
969
970/**
971 * Layout newly-appended item elements
972 * @param {Array or NodeList or Element} elems
973 */
974proto.appended = function( elems ) {
975  var items = this.addItems( elems );
976  if ( !items.length ) {
977    return;
978  }
979  // layout and reveal just the new items
980  this.layoutItems( items, true );
981  this.reveal( items );
982};
983
984/**
985 * Layout prepended elements
986 * @param {Array or NodeList or Element} elems
987 */
988proto.prepended = function( elems ) {
989  var items = this._itemize( elems );
990  if ( !items.length ) {
991    return;
992  }
993  // add items to beginning of collection
994  var previousItems = this.items.slice(0);
995  this.items = items.concat( previousItems );
996  // start new layout
997  this._resetLayout();
998  this._manageStamps();
999  // layout new stuff without transition
1000  this.layoutItems( items, true );
1001  this.reveal( items );
1002  // layout previous items
1003  this.layoutItems( previousItems );
1004};
1005
1006/**
1007 * reveal a collection of items
1008 * @param {Array of Outlayer.Items} items
1009 */
1010proto.reveal = function( items ) {
1011  this._emitCompleteOnItems( 'reveal', items );
1012  if ( !items || !items.length ) {
1013    return;
1014  }
1015  var stagger = this.updateStagger();
1016  items.forEach( function( item, i ) {
1017    item.stagger( i * stagger );
1018    item.reveal();
1019  });
1020};
1021
1022/**
1023 * hide a collection of items
1024 * @param {Array of Outlayer.Items} items
1025 */
1026proto.hide = function( items ) {
1027  this._emitCompleteOnItems( 'hide', items );
1028  if ( !items || !items.length ) {
1029    return;
1030  }
1031  var stagger = this.updateStagger();
1032  items.forEach( function( item, i ) {
1033    item.stagger( i * stagger );
1034    item.hide();
1035  });
1036};
1037
1038/**
1039 * reveal item elements
1040 * @param {Array}, {Element}, {NodeList} items
1041 */
1042proto.revealItemElements = function( elems ) {
1043  var items = this.getItems( elems );
1044  this.reveal( items );
1045};
1046
1047/**
1048 * hide item elements
1049 * @param {Array}, {Element}, {NodeList} items
1050 */
1051proto.hideItemElements = function( elems ) {
1052  var items = this.getItems( elems );
1053  this.hide( items );
1054};
1055
1056/**
1057 * get Outlayer.Item, given an Element
1058 * @param {Element} elem
1059 * @param {Function} callback
1060 * @returns {Outlayer.Item} item
1061 */
1062proto.getItem = function( elem ) {
1063  // loop through items to get the one that matches
1064  for ( var i=0; i < this.items.length; i++ ) {
1065    var item = this.items[i];
1066    if ( item.element == elem ) {
1067      // return item
1068      return item;
1069    }
1070  }
1071};
1072
1073/**
1074 * get collection of Outlayer.Items, given Elements
1075 * @param {Array} elems
1076 * @returns {Array} items - Outlayer.Items
1077 */
1078proto.getItems = function( elems ) {
1079  elems = utils.makeArray( elems );
1080  var items = [];
1081  elems.forEach( function( elem ) {
1082    var item = this.getItem( elem );
1083    if ( item ) {
1084      items.push( item );
1085    }
1086  }, this );
1087
1088  return items;
1089};
1090
1091/**
1092 * remove element(s) from instance and DOM
1093 * @param {Array or NodeList or Element} elems
1094 */
1095proto.remove = function( elems ) {
1096  var removeItems = this.getItems( elems );
1097
1098  this._emitCompleteOnItems( 'remove', removeItems );
1099
1100  // bail if no items to remove
1101  if ( !removeItems || !removeItems.length ) {
1102    return;
1103  }
1104
1105  removeItems.forEach( function( item ) {
1106    item.remove();
1107    // remove item from collection
1108    utils.removeFrom( this.items, item );
1109  }, this );
1110};
1111
1112// ----- destroy ----- //
1113
1114// remove and disable Outlayer instance
1115proto.destroy = function() {
1116  // clean up dynamic styles
1117  var style = this.element.style;
1118  style.height = '';
1119  style.position = '';
1120  style.width = '';
1121  // destroy items
1122  this.items.forEach( function( item ) {
1123    item.destroy();
1124  });
1125
1126  this.unbindResize();
1127
1128  var id = this.element.outlayerGUID;
1129  delete instances[ id ]; // remove reference to instance by id
1130  delete this.element.outlayerGUID;
1131  // remove data for jQuery
1132  if ( jQuery ) {
1133    jQuery.removeData( this.element, this.constructor.namespace );
1134  }
1135
1136};
1137
1138// -------------------------- data -------------------------- //
1139
1140/**
1141 * get Outlayer instance from element
1142 * @param {Element} elem
1143 * @returns {Outlayer}
1144 */
1145Outlayer.data = function( elem ) {
1146  elem = utils.getQueryElement( elem );
1147  var id = elem && elem.outlayerGUID;
1148  return id && instances[ id ];
1149};
1150
1151
1152// -------------------------- create Outlayer class -------------------------- //
1153
1154/**
1155 * create a layout class
1156 * @param {String} namespace
1157 */
1158Outlayer.create = function( namespace, options ) {
1159  // sub-class Outlayer
1160  var Layout = subclass( Outlayer );
1161  // apply new options and compatOptions
1162  Layout.defaults = utils.extend( {}, Outlayer.defaults );
1163  utils.extend( Layout.defaults, options );
1164  Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions  );
1165
1166  Layout.namespace = namespace;
1167
1168  Layout.data = Outlayer.data;
1169
1170  // sub-class Item
1171  Layout.Item = subclass( Item );
1172
1173  // -------------------------- declarative -------------------------- //
1174
1175  utils.htmlInit( Layout, namespace );
1176
1177  // -------------------------- jQuery bridge -------------------------- //
1178
1179  // make into jQuery plugin
1180  if ( jQuery && jQuery.bridget ) {
1181    jQuery.bridget( namespace, Layout );
1182  }
1183
1184  return Layout;
1185};
1186
1187function subclass( Parent ) {
1188  function SubClass() {
1189    Parent.apply( this, arguments );
1190  }
1191
1192  SubClass.prototype = Object.create( Parent.prototype );
1193  SubClass.prototype.constructor = SubClass;
1194
1195  return SubClass;
1196}
1197
1198// ----- helpers ----- //
1199
1200// how many milliseconds are in each unit
1201var msUnits = {
1202  ms: 1,
1203  s: 1000
1204};
1205
1206// munge time-like parameter into millisecond number
1207// '0.4s' -> 40
1208function getMilliseconds( time ) {
1209  if ( typeof time == 'number' ) {
1210    return time;
1211  }
1212  var matches = time.match( /(^\d*\.?\d*)(\w*)/ );
1213  var num = matches && matches[1];
1214  var unit = matches && matches[2];
1215  if ( !num.length ) {
1216    return 0;
1217  }
1218  num = parseFloat( num );
1219  var mult = msUnits[ unit ] || 1;
1220  return num * mult;
1221}
1222
1223// ----- fin ----- //
1224
1225// back in global
1226Outlayer.Item = Item;
1227
1228return Outlayer;
1229
1230}));
1231
1232
1233/***/ }),
1234/* 3 */
1235/***/ (function(module, exports, __webpack_require__) {
1236
1237var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
1238 * Isotope LayoutMode
1239 */
1240
1241( function( window, factory ) {
1242  // universal module definition
1243  /* jshint strict: false */ /*globals define, module, require */
1244  if ( true ) {
1245    // AMD
1246    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
1247        __webpack_require__(1),
1248        __webpack_require__(2)
1249      ], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
1250				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
1251				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
1252				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
1253  } else if ( typeof module == 'object' && module.exports ) {
1254    // CommonJS
1255    module.exports = factory(
1256      require('get-size'),
1257      require('outlayer')
1258    );
1259  } else {
1260    // browser global
1261    window.Isotope = window.Isotope || {};
1262    window.Isotope.LayoutMode = factory(
1263      window.getSize,
1264      window.Outlayer
1265    );
1266  }
1267
1268}( window, function factory( getSize, Outlayer ) {
1269  'use strict';
1270
1271  // layout mode class
1272  function LayoutMode( isotope ) {
1273    this.isotope = isotope;
1274    // link properties
1275    if ( isotope ) {
1276      this.options = isotope.options[ this.namespace ];
1277      this.element = isotope.element;
1278      this.items = isotope.filteredItems;
1279      this.size = isotope.size;
1280    }
1281  }
1282
1283  var proto = LayoutMode.prototype;
1284
1285  /**
1286   * some methods should just defer to default Outlayer method
1287   * and reference the Isotope instance as `this`
1288  **/
1289  var facadeMethods = [
1290    '_resetLayout',
1291    '_getItemLayoutPosition',
1292    '_manageStamp',
1293    '_getContainerSize',
1294    '_getElementOffset',
1295    'needsResizeLayout',
1296    '_getOption'
1297  ];
1298
1299  facadeMethods.forEach( function( methodName ) {
1300    proto[ methodName ] = function() {
1301      return Outlayer.prototype[ methodName ].apply( this.isotope, arguments );
1302    };
1303  });
1304
1305  // -----  ----- //
1306
1307  // for horizontal layout modes, check vertical size
1308  proto.needsVerticalResizeLayout = function() {
1309    // don't trigger if size did not change
1310    var size = getSize( this.isotope.element );
1311    // check that this.size and size are there
1312    // IE8 triggers resize on body size change, so they might not be
1313    var hasSizes = this.isotope.size && size;
1314    return hasSizes && size.innerHeight != this.isotope.size.innerHeight;
1315  };
1316
1317  // ----- measurements ----- //
1318
1319  proto._getMeasurement = function() {
1320    this.isotope._getMeasurement.apply( this, arguments );
1321  };
1322
1323  proto.getColumnWidth = function() {
1324    this.getSegmentSize( 'column', 'Width' );
1325  };
1326
1327  proto.getRowHeight = function() {
1328    this.getSegmentSize( 'row', 'Height' );
1329  };
1330
1331  /**
1332   * get columnWidth or rowHeight
1333   * segment: 'column' or 'row'
1334   * size 'Width' or 'Height'
1335  **/
1336  proto.getSegmentSize = function( segment, size ) {
1337    var segmentName = segment + size;
1338    var outerSize = 'outer' + size;
1339    // columnWidth / outerWidth // rowHeight / outerHeight
1340    this._getMeasurement( segmentName, outerSize );
1341    // got rowHeight or columnWidth, we can chill
1342    if ( this[ segmentName ] ) {
1343      return;
1344    }
1345    // fall back to item of first element
1346    var firstItemSize = this.getFirstItemSize();
1347    this[ segmentName ] = firstItemSize && firstItemSize[ outerSize ] ||
1348      // or size of container
1349      this.isotope.size[ 'inner' + size ];
1350  };
1351
1352  proto.getFirstItemSize = function() {
1353    var firstItem = this.isotope.filteredItems[0];
1354    return firstItem && firstItem.element && getSize( firstItem.element );
1355  };
1356
1357  // ----- methods that should reference isotope ----- //
1358
1359  proto.layout = function() {
1360    this.isotope.layout.apply( this.isotope, arguments );
1361  };
1362
1363  proto.getSize = function() {
1364    this.isotope.getSize();
1365    this.size = this.isotope.size;
1366  };
1367
1368  // -------------------------- create -------------------------- //
1369
1370  LayoutMode.modes = {};
1371
1372  LayoutMode.create = function( namespace, options ) {
1373
1374    function Mode() {
1375      LayoutMode.apply( this, arguments );
1376    }
1377
1378    Mode.prototype = Object.create( proto );
1379    Mode.prototype.constructor = Mode;
1380
1381    // default options
1382    if ( options ) {
1383      Mode.options = options;
1384    }
1385
1386    Mode.prototype.namespace = namespace;
1387    // register in Isotope
1388    LayoutMode.modes[ namespace ] = Mode;
1389
1390    return Mode;
1391  };
1392
1393  return LayoutMode;
1394
1395}));
1396
1397
1398/***/ }),
1399/* 4 */
1400/***/ (function(module, exports, __webpack_require__) {
1401
1402var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
1403 * Isotope v3.0.5
1404 *
1405 * Licensed GPLv3 for open source use
1406 * or Isotope Commercial License for commercial use
1407 *
1408 * https://isotope.metafizzy.co
1409 * Copyright 2017 Metafizzy
1410 */
1411
1412( function( window, factory ) {
1413  // universal module definition
1414  /* jshint strict: false */ /*globals define, module, require */
1415  if ( true ) {
1416    // AMD
1417    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
1418        __webpack_require__(2),
1419        __webpack_require__(1),
1420        __webpack_require__(5),
1421        __webpack_require__(6),
1422        __webpack_require__(17),
1423        __webpack_require__(3),
1424        // include default layout modes
1425        __webpack_require__(13),
1426        __webpack_require__(15),
1427        __webpack_require__(16)
1428      ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( Outlayer, getSize, matchesSelector, utils, Item, LayoutMode ) {
1429        return factory( window, Outlayer, getSize, matchesSelector, utils, Item, LayoutMode );
1430      }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
1431				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
1432  } else if ( typeof module == 'object' && module.exports ) {
1433    // CommonJS
1434    module.exports = factory(
1435      window,
1436      require('outlayer'),
1437      require('get-size'),
1438      require('desandro-matches-selector'),
1439      require('fizzy-ui-utils'),
1440      require('./item'),
1441      require('./layout-mode'),
1442      // include default layout modes
1443      require('./layout-modes/masonry'),
1444      require('./layout-modes/fit-rows'),
1445      require('./layout-modes/vertical')
1446    );
1447  } else {
1448    // browser global
1449    window.Isotope = factory(
1450      window,
1451      window.Outlayer,
1452      window.getSize,
1453      window.matchesSelector,
1454      window.fizzyUIUtils,
1455      window.Isotope.Item,
1456      window.Isotope.LayoutMode
1457    );
1458  }
1459
1460}( window, function factory( window, Outlayer, getSize, matchesSelector, utils,
1461  Item, LayoutMode ) {
1462
1463'use strict';
1464
1465// -------------------------- vars -------------------------- //
1466
1467var jQuery = window.jQuery;
1468
1469// -------------------------- helpers -------------------------- //
1470
1471var trim = String.prototype.trim ?
1472  function( str ) {
1473    return str.trim();
1474  } :
1475  function( str ) {
1476    return str.replace( /^\s+|\s+$/g, '' );
1477  };
1478
1479// -------------------------- isotopeDefinition -------------------------- //
1480
1481  // create an Outlayer layout class
1482  var Isotope = Outlayer.create( 'isotope', {
1483    layoutMode: 'masonry',
1484    isJQueryFiltering: true,
1485    sortAscending: true
1486  });
1487
1488  Isotope.Item = Item;
1489  Isotope.LayoutMode = LayoutMode;
1490
1491  var proto = Isotope.prototype;
1492
1493  proto._create = function() {
1494    this.itemGUID = 0;
1495    // functions that sort items
1496    this._sorters = {};
1497    this._getSorters();
1498    // call super
1499    Outlayer.prototype._create.call( this );
1500
1501    // create layout modes
1502    this.modes = {};
1503    // start filteredItems with all items
1504    this.filteredItems = this.items;
1505    // keep of track of sortBys
1506    this.sortHistory = [ 'original-order' ];
1507    // create from registered layout modes
1508    for ( var name in LayoutMode.modes ) {
1509      this._initLayoutMode( name );
1510    }
1511  };
1512
1513  proto.reloadItems = function() {
1514    // reset item ID counter
1515    this.itemGUID = 0;
1516    // call super
1517    Outlayer.prototype.reloadItems.call( this );
1518  };
1519
1520  proto._itemize = function() {
1521    var items = Outlayer.prototype._itemize.apply( this, arguments );
1522    // assign ID for original-order
1523    for ( var i=0; i < items.length; i++ ) {
1524      var item = items[i];
1525      item.id = this.itemGUID++;
1526    }
1527    this._updateItemsSortData( items );
1528    return items;
1529  };
1530
1531
1532  // -------------------------- layout -------------------------- //
1533
1534  proto._initLayoutMode = function( name ) {
1535    var Mode = LayoutMode.modes[ name ];
1536    // set mode options
1537    // HACK extend initial options, back-fill in default options
1538    var initialOpts = this.options[ name ] || {};
1539    this.options[ name ] = Mode.options ?
1540      utils.extend( Mode.options, initialOpts ) : initialOpts;
1541    // init layout mode instance
1542    this.modes[ name ] = new Mode( this );
1543  };
1544
1545
1546  proto.layout = function() {
1547    // if first time doing layout, do all magic
1548    if ( !this._isLayoutInited && this._getOption('initLayout') ) {
1549      this.arrange();
1550      return;
1551    }
1552    this._layout();
1553  };
1554
1555  // private method to be used in layout() & magic()
1556  proto._layout = function() {
1557    // don't animate first layout
1558    var isInstant = this._getIsInstant();
1559    // layout flow
1560    this._resetLayout();
1561    this._manageStamps();
1562    this.layoutItems( this.filteredItems, isInstant );
1563
1564    // flag for initalized
1565    this._isLayoutInited = true;
1566  };
1567
1568  // filter + sort + layout
1569  proto.arrange = function( opts ) {
1570    // set any options pass
1571    this.option( opts );
1572    this._getIsInstant();
1573    // filter, sort, and layout
1574
1575    // filter
1576    var filtered = this._filter( this.items );
1577    this.filteredItems = filtered.matches;
1578
1579    this._bindArrangeComplete();
1580
1581    if ( this._isInstant ) {
1582      this._noTransition( this._hideReveal, [ filtered ] );
1583    } else {
1584      this._hideReveal( filtered );
1585    }
1586
1587    this._sort();
1588    this._layout();
1589  };
1590  // alias to _init for main plugin method
1591  proto._init = proto.arrange;
1592
1593  proto._hideReveal = function( filtered ) {
1594    this.reveal( filtered.needReveal );
1595    this.hide( filtered.needHide );
1596  };
1597
1598  // HACK
1599  // Don't animate/transition first layout
1600  // Or don't animate/transition other layouts
1601  proto._getIsInstant = function() {
1602    var isLayoutInstant = this._getOption('layoutInstant');
1603    var isInstant = isLayoutInstant !== undefined ? isLayoutInstant :
1604      !this._isLayoutInited;
1605    this._isInstant = isInstant;
1606    return isInstant;
1607  };
1608
1609  // listen for layoutComplete, hideComplete and revealComplete
1610  // to trigger arrangeComplete
1611  proto._bindArrangeComplete = function() {
1612    // listen for 3 events to trigger arrangeComplete
1613    var isLayoutComplete, isHideComplete, isRevealComplete;
1614    var _this = this;
1615    function arrangeParallelCallback() {
1616      if ( isLayoutComplete && isHideComplete && isRevealComplete ) {
1617        _this.dispatchEvent( 'arrangeComplete', null, [ _this.filteredItems ] );
1618      }
1619    }
1620    this.once( 'layoutComplete', function() {
1621      isLayoutComplete = true;
1622      arrangeParallelCallback();
1623    });

1624    this.once( 'hideComplete', function() {
1625      isHideComplete = true;
1626      arrangeParallelCallback();
1627    });
1628    this.once( 'revealComplete', function() {
1629      isRevealComplete = true;
1630      arrangeParallelCallback();
1631    });
1632  };
1633
1634  // -------------------------- filter -------------------------- //
1635
1636  proto._filter = function( items ) {
1637    var filter = this.options.filter;
1638    filter = filter || '*';
1639    var matches = [];
1640    var hiddenMatched = [];
1641    var visibleUnmatched = [];
1642
1643    var test = this._getFilterTest( filter );
1644
1645    // test each item
1646    for ( var i=0; i < items.length; i++ ) {
1647      var item = items[i];
1648      if ( item.isIgnored ) {
1649        continue;
1650      }
1651      // add item to either matched or unmatched group
1652      var isMatched = test( item );
1653      // item.isFilterMatched = isMatched;
1654      // add to matches if its a match
1655      if ( isMatched ) {
1656        matches.push( item );
1657      }
1658      // add to additional group if item needs to be hidden or revealed
1659      if ( isMatched && item.isHidden ) {
1660        hiddenMatched.push( item );
1661      } else if ( !isMatched && !item.isHidden ) {
1662        visibleUnmatched.push( item );
1663      }
1664    }
1665
1666    // return collections of items to be manipulated
1667    return {
1668      matches: matches,
1669      needReveal: hiddenMatched,
1670      needHide: visibleUnmatched
1671    };
1672  };
1673
1674  // get a jQuery, function, or a matchesSelector test given the filter
1675  proto._getFilterTest = function( filter ) {
1676    if ( jQuery && this.options.isJQueryFiltering ) {
1677      // use jQuery
1678      return function( item ) {
1679        return jQuery( item.element ).is( filter );
1680      };
1681    }
1682    if ( typeof filter == 'function' ) {
1683      // use filter as function
1684      return function( item ) {
1685        return filter( item.element );
1686      };
1687    }
1688    // default, use filter as selector string
1689    return function( item ) {
1690      return matchesSelector( item.element, filter );
1691    };
1692  };
1693
1694  // -------------------------- sorting -------------------------- //
1695
1696  /**
1697   * @params {Array} elems
1698   * @public
1699   */
1700  proto.updateSortData = function( elems ) {
1701    // get items
1702    var items;
1703    if ( elems ) {
1704      elems = utils.makeArray( elems );
1705      items = this.getItems( elems );
1706    } else {
1707      // update all items if no elems provided
1708      items = this.items;
1709    }
1710
1711    this._getSorters();
1712    this._updateItemsSortData( items );
1713  };
1714
1715  proto._getSorters = function() {
1716    var getSortData = this.options.getSortData;
1717    for ( var key in getSortData ) {
1718      var sorter = getSortData[ key ];
1719      this._sorters[ key ] = mungeSorter( sorter );
1720    }
1721  };
1722
1723  /**
1724   * @params {Array} items - of Isotope.Items
1725   * @private
1726   */
1727  proto._updateItemsSortData = function( items ) {
1728    // do not update if no items
1729    var len = items && items.length;
1730
1731    for ( var i=0; len && i < len; i++ ) {
1732      var item = items[i];
1733      item.updateSortData();
1734    }
1735  };
1736
1737  // ----- munge sorter ----- //
1738
1739  // encapsulate this, as we just need mungeSorter
1740  // other functions in here are just for munging
1741  var mungeSorter = ( function() {
1742    // add a magic layer to sorters for convienent shorthands
1743    // `.foo-bar` will use the text of .foo-bar querySelector
1744    // `[foo-bar]` will use attribute
1745    // you can also add parser
1746    // `.foo-bar parseInt` will parse that as a number
1747    function mungeSorter( sorter ) {
1748      // if not a string, return function or whatever it is
1749      if ( typeof sorter != 'string' ) {
1750        return sorter;
1751      }
1752      // parse the sorter string
1753      var args = trim( sorter ).split(' ');
1754      var query = args[0];
1755      // check if query looks like [an-attribute]
1756      var attrMatch = query.match( /^\[(.+)\]$/ );
1757      var attr = attrMatch && attrMatch[1];
1758      var getValue = getValueGetter( attr, query );
1759      // use second argument as a parser
1760      var parser = Isotope.sortDataParsers[ args[1] ];
1761      // parse the value, if there was a parser
1762      sorter = parser ? function( elem ) {
1763        return elem && parser( getValue( elem ) );
1764      } :
1765      // otherwise just return value
1766      function( elem ) {
1767        return elem && getValue( elem );
1768      };
1769
1770      return sorter;
1771    }
1772
1773    // get an attribute getter, or get text of the querySelector
1774    function getValueGetter( attr, query ) {
1775      // if query looks like [foo-bar], get attribute
1776      if ( attr ) {
1777        return function getAttribute( elem ) {
1778          return elem.getAttribute( attr );
1779        };
1780      }
1781
1782      // otherwise, assume its a querySelector, and get its text
1783      return function getChildText( elem ) {
1784        var child = elem.querySelector( query );
1785        return child && child.textContent;
1786      };
1787    }
1788
1789    return mungeSorter;
1790  })();
1791
1792  // parsers used in getSortData shortcut strings
1793  Isotope.sortDataParsers = {
1794    'parseInt': function( val ) {
1795      return parseInt( val, 10 );
1796    },
1797    'parseFloat': function( val ) {
1798      return parseFloat( val );
1799    }
1800  };
1801
1802  // ----- sort method ----- //
1803
1804  // sort filteredItem order
1805  proto._sort = function() {
1806    if ( !this.options.sortBy ) {
1807      return;
1808    }
1809    // keep track of sortBy History
1810    var sortBys = utils.makeArray( this.options.sortBy );
1811    if ( !this._getIsSameSortBy( sortBys ) ) {
1812      // concat all sortBy and sortHistory, add to front, oldest goes in last
1813      this.sortHistory = sortBys.concat( this.sortHistory );
1814    }
1815    // sort magic
1816    var itemSorter = getItemSorter( this.sortHistory, this.options.sortAscending );
1817    this.filteredItems.sort( itemSorter );
1818  };
1819
1820  // check if sortBys is same as start of sortHistory
1821  proto._getIsSameSortBy = function( sortBys ) {
1822    for ( var i=0; i < sortBys.length; i++ ) {
1823      if ( sortBys[i] != this.sortHistory[i] ) {
1824        return false;
1825      }
1826    }
1827    return true;
1828  };
1829
1830  // returns a function used for sorting
1831  function getItemSorter( sortBys, sortAsc ) {
1832    return function sorter( itemA, itemB ) {
1833      // cycle through all sortKeys
1834      for ( var i = 0; i < sortBys.length; i++ ) {
1835        var sortBy = sortBys[i];
1836        var a = itemA.sortData[ sortBy ];
1837        var b = itemB.sortData[ sortBy ];
1838        if ( a > b || a < b ) {
1839          // if sortAsc is an object, use the value given the sortBy key
1840          var isAscending = sortAsc[ sortBy ] !== undefined ? sortAsc[ sortBy ] : sortAsc;
1841          var direction = isAscending ? 1 : -1;
1842          return ( a > b ? 1 : -1 ) * direction;
1843        }
1844      }
1845      return 0;
1846    };
1847  }
1848
1849  // -------------------------- methods -------------------------- //
1850
1851  // get layout mode
1852  proto._mode = function() {
1853    var layoutMode = this.options.layoutMode;
1854    var mode = this.modes[ layoutMode ];
1855    if ( !mode ) {
1856      // TODO console.error
1857      throw new Error( 'No layout mode: ' + layoutMode );
1858    }
1859    // HACK sync mode's options
1860    // any options set after init for layout mode need to be synced
1861    mode.options = this.options[ layoutMode ];
1862    return mode;
1863  };
1864
1865  proto._resetLayout = function() {
1866    // trigger original reset layout
1867    Outlayer.prototype._resetLayout.call( this );
1868    this._mode()._resetLayout();
1869  };
1870
1871  proto._getItemLayoutPosition = function( item  ) {
1872    return this._mode()._getItemLayoutPosition( item );
1873  };
1874
1875  proto._manageStamp = function( stamp ) {
1876    this._mode()._manageStamp( stamp );
1877  };
1878
1879  proto._getContainerSize = function() {
1880    return this._mode()._getContainerSize();
1881  };
1882
1883  proto.needsResizeLayout = function() {
1884    return this._mode().needsResizeLayout();
1885  };
1886
1887  // -------------------------- adding & removing -------------------------- //
1888
1889  // HEADS UP overwrites default Outlayer appended
1890  proto.appended = function( elems ) {
1891    var items = this.addItems( elems );
1892    if ( !items.length ) {
1893      return;
1894    }
1895    // filter, layout, reveal new items
1896    var filteredItems = this._filterRevealAdded( items );
1897    // add to filteredItems
1898    this.filteredItems = this.filteredItems.concat( filteredItems );
1899  };
1900
1901  // HEADS UP overwrites default Outlayer prepended
1902  proto.prepended = function( elems ) {
1903    var items = this._itemize( elems );
1904    if ( !items.length ) {
1905      return;
1906    }
1907    // start new layout
1908    this._resetLayout();
1909    this._manageStamps();
1910    // filter, layout, reveal new items
1911    var filteredItems = this._filterRevealAdded( items );
1912    // layout previous items
1913    this.layoutItems( this.filteredItems );
1914    // add to items and filteredItems
1915    this.filteredItems = filteredItems.concat( this.filteredItems );
1916    this.items = items.concat( this.items );
1917  };
1918
1919  proto._filterRevealAdded = function( items ) {
1920    var filtered = this._filter( items );
1921    this.hide( filtered.needHide );
1922    // reveal all new items
1923    this.reveal( filtered.matches );
1924    // layout new items, no transition
1925    this.layoutItems( filtered.matches, true );
1926    return filtered.matches;
1927  };
1928
1929  /**
1930   * Filter, sort, and layout newly-appended item elements
1931   * @param {Array or NodeList or Element} elems
1932   */
1933  proto.insert = function( elems ) {
1934    var items = this.addItems( elems );
1935    if ( !items.length ) {
1936      return;
1937    }
1938    // append item elements
1939    var i, item;
1940    var len = items.length;
1941    for ( i=0; i < len; i++ ) {
1942      item = items[i];
1943      this.element.appendChild( item.element );
1944    }
1945    // filter new stuff
1946    var filteredInsertItems = this._filter( items ).matches;
1947    // set flag
1948    for ( i=0; i < len; i++ ) {
1949      items[i].isLayoutInstant = true;
1950    }
1951    this.arrange();
1952    // reset flag
1953    for ( i=0; i < len; i++ ) {
1954      delete items[i].isLayoutInstant;
1955    }
1956    this.reveal( filteredInsertItems );
1957  };
1958
1959  var _remove = proto.remove;
1960  proto.remove = function( elems ) {
1961    elems = utils.makeArray( elems );
1962    var removeItems = this.getItems( elems );
1963    // do regular thing
1964    _remove.call( this, elems );
1965    // bail if no items to remove
1966    var len = removeItems && removeItems.length;
1967    // remove elems from filteredItems
1968    for ( var i=0; len && i < len; i++ ) {
1969      var item = removeItems[i];
1970      // remove item from collection
1971      utils.removeFrom( this.filteredItems, item );
1972    }
1973  };
1974
1975  proto.shuffle = function() {
1976    // update random sortData
1977    for ( var i=0; i < this.items.length; i++ ) {
1978      var item = this.items[i];
1979      item.sortData.random = Math.random();
1980    }
1981    this.options.sortBy = 'random';
1982    this._sort();
1983    this._layout();
1984  };
1985
1986  /**
1987   * trigger fn without transition
1988   * kind of hacky to have this in the first place
1989   * @param {Function} fn
1990   * @param {Array} args
1991   * @returns ret
1992   * @private
1993   */
1994  proto._noTransition = function( fn, args ) {
1995    // save transitionDuration before disabling
1996    var transitionDuration = this.options.transitionDuration;
1997    // disable transition
1998    this.options.transitionDuration = 0;
1999    // do it
2000    var returnValue = fn.apply( this, args );
2001    // re-enable transition for reveal
2002    this.options.transitionDuration = transitionDuration;
2003    return returnValue;
2004  };
2005
2006  // ----- helper methods ----- //
2007
2008  /**
2009   * getter method for getting filtered item elements
2010   * @returns {Array} elems - collection of item elements
2011   */
2012  proto.getFilteredItemElements = function() {
2013    return this.filteredItems.map( function( item ) {
2014      return item.element;
2015    });

2016  };
2017
2018  // -----  ----- //
2019
2020  return Isotope;
2021
2022}));
2023
2024
2025/***/ }),
2026/* 5 */
2027/***/ (function(module, exports, __webpack_require__) {
2028
2029var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
2030 * matchesSelector v2.0.2
2031 * matchesSelector( element, '.selector' )
2032 * MIT license
2033 */
2034
2035/*jshint browser: true, strict: true, undef: true, unused: true */
2036
2037( function( window, factory ) {
2038  /*global define: false, module: false */
2039  'use strict';
2040  // universal module definition
2041  if ( true ) {
2042    // AMD
2043    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
2044				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
2045				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
2046				__WEBPACK_AMD_DEFINE_FACTORY__),
2047				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
2048  } else if ( typeof module == 'object' && module.exports ) {
2049    // CommonJS
2050    module.exports = factory();
2051  } else {
2052    // browser global
2053    window.matchesSelector = factory();
2054  }
2055
2056}( window, function factory() {
2057  'use strict';
2058
2059  var matchesMethod = ( function() {
2060    var ElemProto = window.Element.prototype;
2061    // check for the standard method name first
2062    if ( ElemProto.matches ) {
2063      return 'matches';
2064    }
2065    // check un-prefixed
2066    if ( ElemProto.matchesSelector ) {
2067      return 'matchesSelector';
2068    }
2069    // check vendor prefixes
2070    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];
2071
2072    for ( var i=0; i < prefixes.length; i++ ) {
2073      var prefix = prefixes[i];
2074      var method = prefix + 'MatchesSelector';
2075      if ( ElemProto[ method ] ) {
2076        return method;
2077      }
2078    }
2079  })();
2080
2081  return function matchesSelector( elem, selector ) {
2082    return elem[ matchesMethod ]( selector );
2083  };
2084
2085}));
2086
2087
2088/***/ }),
2089/* 6 */
2090/***/ (function(module, exports, __webpack_require__) {
2091
2092var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
2093 * Fizzy UI utils v2.0.7
2094 * MIT license
2095 */
2096
2097/*jshint browser: true, undef: true, unused: true, strict: true */
2098
2099( function( window, factory ) {
2100  // universal module definition
2101  /*jshint strict: false */ /*globals define, module, require */
2102
2103  if ( true ) {
2104    // AMD
2105    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [
2106      __webpack_require__(5)
2107    ], __WEBPACK_AMD_DEFINE_RESULT__ = (function( matchesSelector ) {
2108      return factory( window, matchesSelector );
2109    }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
2110				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
2111  } else if ( typeof module == 'object' && module.exports ) {
2112    // CommonJS
2113    module.exports = factory(
2114      window,
2115      require('desandro-matches-selector')
2116    );
2117  } else {
2118    // browser global
2119    window.fizzyUIUtils = factory(
2120      window,
2121      window.matchesSelector
2122    );
2123  }
2124
2125}( window, function factory( window, matchesSelector ) {
2126
2127'use strict';
2128
2129var utils = {};
2130
2131// ----- extend ----- //
2132
2133// extends objects
2134utils.extend = function( a, b ) {
2135  for ( var prop in b ) {
2136    a[ prop ] = b[ prop ];
2137  }
2138  return a;
2139};
2140
2141// ----- modulo ----- //
2142
2143utils.modulo = function( num, div ) {
2144  return ( ( num % div ) + div ) % div;
2145};
2146
2147// ----- makeArray ----- //
2148
2149var arraySlice = Array.prototype.slice;
2150
2151// turn element or nodeList into an array
2152utils.makeArray = function( obj ) {
2153  if ( Array.isArray( obj ) ) {
2154    // use object if already an array
2155    return obj;
2156  }
2157  // return empty array if undefined or null. #6
2158  if ( obj === null || obj === undefined ) {
2159    return [];
2160  }
2161
2162  var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
2163  if ( isArrayLike ) {
2164    // convert nodeList to array
2165    return arraySlice.call( obj );
2166  }
2167
2168  // array of single index
2169  return [ obj ];
2170};
2171
2172// ----- removeFrom ----- //
2173
2174utils.removeFrom = function( ary, obj ) {
2175  var index = ary.indexOf( obj );
2176  if ( index != -1 ) {
2177    ary.splice( index, 1 );
2178  }
2179};
2180
2181// ----- getParent ----- //
2182
2183utils.getParent = function( elem, selector ) {
2184  while ( elem.parentNode && elem != document.body ) {
2185    elem = elem.parentNode;
2186    if ( matchesSelector( elem, selector ) ) {
2187      return elem;
2188    }
2189  }
2190};
2191
2192// ----- getQueryElement ----- //
2193
2194// use element as selector string
2195utils.getQueryElement = function( elem ) {
2196  if ( typeof elem == 'string' ) {
2197    return document.querySelector( elem );
2198  }
2199  return elem;
2200};
2201
2202// ----- handleEvent ----- //
2203
2204// enable .ontype to trigger from .addEventListener( elem, 'type' )
2205utils.handleEvent = function( event ) {
2206  var method = 'on' + event.type;
2207  if ( this[ method ] ) {
2208    this[ method ]( event );
2209  }
2210};
2211
2212// ----- filterFindElements ----- //
2213
2214utils.filterFindElements = function( elems, selector ) {
2215  // make array of elems
2216  elems = utils.makeArray( elems );
2217  var ffElems = [];
2218
2219  elems.forEach( function( elem ) {
2220    // check that elem is an actual element
2221    if ( !( elem instanceof HTMLElement ) ) {
2222      return;
2223    }
2224    // add elem if no selector
2225    if ( !selector ) {
2226      ffElems.push( elem );
2227      return;
2228    }
2229    // filter & find items if we have a selector
2230    // filter
2231    if ( matchesSelector( elem, selector ) ) {
2232      ffElems.push( elem );
2233    }
2234    // find children
2235    var childElems = elem.querySelectorAll( selector );
2236    // concat childElems to filterFound array
2237    for ( var i=0; i < childElems.length; i++ ) {
2238      ffElems.push( childElems[i] );
2239    }
2240  });
2241
2242  return ffElems;
2243};
2244
2245// ----- debounceMethod ----- //
2246
2247utils.debounceMethod = function( _class, methodName, threshold ) {
2248  threshold = threshold || 100;
2249  // original method
2250  var method = _class.prototype[ methodName ];
2251  var timeoutName = methodName + 'Timeout';
2252
2253  _class.prototype[ methodName ] = function() {
2254    var timeout = this[ timeoutName ];
2255    clearTimeout( timeout );
2256
2257    var args = arguments;
2258    var _this = this;
2259    this[ timeoutName ] = setTimeout( function() {
2260      method.apply( _this, args );
2261      delete _this[ timeoutName ];
2262    }, threshold );
2263  };
2264};
2265
2266// ----- docReady ----- //
2267
2268utils.docReady = function( callback ) {
2269  var readyState = document.readyState;
2270  if ( readyState == 'complete' || readyState == 'interactive' ) {
2271    // do async to allow for other scripts to run. metafizzy/flickity#441
2272    setTimeout( callback );
2273  } else {
2274    document.addEventListener( 'DOMContentLoaded', callback );
2275  }
2276};
2277
2278// ----- htmlInit ----- //
2279
2280// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
2281utils.toDashed = function( str ) {
2282  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {
2283    return $1 + '-' + $2;
2284  }).toLowerCase();
2285};
2286
2287var console = window.console;
2288/**
2289 * allow user to initialize classes via [data-namespace] or .js-namespace class
2290 * htmlInit( Widget, 'widgetName' )
2291 * options are parsed from data-namespace-options
2292 */
2293utils.htmlInit = function( WidgetClass, namespace ) {
2294  utils.docReady( function() {
2295    var dashedNamespace = utils.toDashed( namespace );
2296    var dataAttr = 'data-' + dashedNamespace;
2297    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );
2298    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );
2299    var elems = utils.makeArray( dataAttrElems )
2300      .concat( utils.makeArray( jsDashElems ) );
2301    var dataOptionsAttr = dataAttr + '-options';
2302    var jQuery = window.jQuery;
2303
2304    elems.forEach( function( elem ) {
2305      var attr = elem.getAttribute( dataAttr ) ||
2306        elem.getAttribute( dataOptionsAttr );
2307      var options;
2308      try {
2309        options = attr && JSON.parse( attr );
2310      } catch ( error ) {
2311        // log error, do not initialize
2312        if ( console ) {
2313          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +
2314          ': ' + error );
2315        }
2316        return;
2317      }
2318      // initialize
2319      var instance = new WidgetClass( elem, options );
2320      // make available via $().data('namespace')
2321      if ( jQuery ) {
2322        jQuery.data( elem, namespace, instance );
2323      }
2324    });
2325
2326  });
2327};
2328
2329// -----  ----- //
2330
2331return utils;
2332
2333}));
2334
2335
2336/***/ }),
2337/* 7 */
2338/***/ (function(module, exports, __webpack_require__) {
2339
2340var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
2341 * EvEmitter v1.1.0
2342 * Lil' event emitter
2343 * MIT License
2344 */
2345
2346/* jshint unused: true, undef: true, strict: true */
2347
2348( function( global, factory ) {
2349  // universal module definition
2350  /* jshint strict: false */ /* globals define, module, window */
2351  if ( true ) {
2352    // AMD - RequireJS
2353    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
2354				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
2355				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
2356				__WEBPACK_AMD_DEFINE_FACTORY__),
2357				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
2358  } else if ( typeof module == 'object' && module.exports ) {
2359    // CommonJS - Browserify, Webpack
2360    module.exports = factory();
2361  } else {
2362    // Browser globals
2363    global.EvEmitter = factory();
2364  }
2365
2366}( typeof window != 'undefined' ? window : this, function() {
2367
2368"use strict";
2369
2370function EvEmitter() {}
2371
2372var proto = EvEmitter.prototype;
2373
2374proto.on = function( eventName, listener ) {
2375  if ( !eventName || !listener ) {
2376    return;
2377  }
2378  // set events hash
2379  var events = this._events = this._events || {};
2380  // set listeners array
2381  var listeners = events[ eventName ] = events[ eventName ] || [];
2382  // only add once
2383  if ( listeners.indexOf( listener ) == -1 ) {
2384    listeners.push( listener );
2385  }
2386
2387  return this;
2388};