https://closertotruth.com/wp-content/themes/closer-to-truth/dist/scripts/main.js?ver=1790742401

691InfiniteScroll.setJQuery = function( $ ) {
692  jQuery = $;
693};
694
695// -------------------------- setup -------------------------- //
696
697utils.htmlInit( InfiniteScroll, 'infinite-scroll' );
698
699if ( jQuery && jQuery.bridget ) {
700  jQuery.bridget( 'infiniteScroll', InfiniteScroll );
701}
702
703// --------------------------  -------------------------- //
704
705return InfiniteScroll;
706
707}));
708
709
710/***/ }),
711/* 3 */
712/***/ (function(module, exports, __webpack_require__) {
713
714var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
715 * getSize v2.0.3
716 * measure size of elements
717 * MIT license
718 */
719
720/* jshint browser: true, strict: true, undef: true, unused: true */
721/* globals console: false */
722
723( function( window, factory ) {
724  /* jshint strict: false */ /* globals define, module */
725  if ( true ) {
726    // AMD
727    !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
728				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
729				(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :
730				__WEBPACK_AMD_DEFINE_FACTORY__),
731				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
732  } else if ( typeof module == 'object' && module.exports ) {
733    // CommonJS
734    module.exports = factory();
735  } else {
736    // browser global
737    window.getSize = factory();
738  }
739
740})( window, function factory() {
741'use strict';
742
743// -------------------------- helpers -------------------------- //
744
745// get a number from a string, not a percentage
746function getStyleSize( value ) {
747  var num = parseFloat( value );
748  // not a percent like '100%', and a number
749  var isValid = value.indexOf('%') == -1 && !isNaN( num );
750  return isValid && num;
751}
752
753function noop() {}
754
755var logError = typeof console == 'undefined' ? noop :
756  function( message ) {
757    console.error( message );
758  };
759
760// -------------------------- measurements -------------------------- //
761
762var measurements = [
763  'paddingLeft',
764  'paddingRight',
765  'paddingTop',
766  'paddingBottom',
767  'marginLeft',
768  'marginRight',
769  'marginTop',
770  'marginBottom',
771  'borderLeftWidth',
772  'borderRightWidth',
773  'borderTopWidth',
774  'borderBottomWidth'
775];
776
777var measurementsLength = measurements.length;
778
779function getZeroSize() {
780  var size = {
781    width: 0,
782    height: 0,
783    innerWidth: 0,
784    innerHeight: 0,
785    outerWidth: 0,
786    outerHeight: 0
787  };
788  for ( var i=0; i < measurementsLength; i++ ) {
789    var measurement = measurements[i];
790    size[ measurement ] = 0;
791  }
792  return size;
793}
794
795// -------------------------- getStyle -------------------------- //
796
797/**
798 * getStyle, get style of element, check for Firefox bug
799 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
800 */
801function getStyle( elem ) {
802  var style = getComputedStyle( elem );
803  if ( !style ) {
804    logError( 'Style returned ' + style +
805      '. Are you running this code in a hidden iframe on Firefox? ' +
806      'See https://bit.ly/getsizebug1' );
807  }
808  return style;
809}
810
811// -------------------------- setup -------------------------- //
812
813var isSetup = false;
814
815var isBoxSizeOuter;
816
817/**
818 * setup
819 * check isBoxSizerOuter
820 * do on first getSize() rather than on page load for Firefox bug
821 */
822function setup() {
823  // setup once
824  if ( isSetup ) {
825    return;
826  }
827  isSetup = true;
828
829  // -------------------------- box sizing -------------------------- //
830
831  /**
832   * Chrome & Safari measure the outer-width on style.width on border-box elems
833   * IE11 & Firefox<29 measures the inner-width
834   */
835  var div = document.createElement('div');
836  div.style.width = '200px';
837  div.style.padding = '1px 2px 3px 4px';
838  div.style.borderStyle = 'solid';
839  div.style.borderWidth = '1px 2px 3px 4px';
840  div.style.boxSizing = 'border-box';
841
842  var body = document.body || document.documentElement;
843  body.appendChild( div );
844  var style = getStyle( div );
845  // round value for browser zoom. desandro/masonry#928
846  isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200;
847  getSize.isBoxSizeOuter = isBoxSizeOuter;
848
849  body.removeChild( div );
850}
851
852// -------------------------- getSize -------------------------- //
853
854function getSize( elem ) {
855  setup();
856
857  // use querySeletor if elem is string
858  if ( typeof elem == 'string' ) {
859    elem = document.querySelector( elem );
860  }
861
862  // do not proceed on non-objects
863  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {
864    return;
865  }
866
867  var style = getStyle( elem );
868
869  // if hidden, everything is 0
870  if ( style.display == 'none' ) {
871    return getZeroSize();
872  }
873
874  var size = {};
875  size.width = elem.offsetWidth;
876  size.height = elem.offsetHeight;
877
878  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';
879
880  // get all measurements
881  for ( var i=0; i < measurementsLength; i++ ) {
882    var measurement = measurements[i];
883    var value = style[ measurement ];
884    var num = parseFloat( value );
885    // any 'auto', 'medium' value will be 0
886    size[ measurement ] = !isNaN( num ) ? num : 0;
887  }
888
889  var paddingWidth = size.paddingLeft + size.paddingRight;
890  var paddingHeight = size.paddingTop + size.paddingBottom;
891  var marginWidth = size.marginLeft + size.marginRight;
892  var marginHeight = size.marginTop + size.marginBottom;
893  var borderWidth = size.borderLeftWidth + size.borderRightWidth;
894  var borderHeight = size.borderTopWidth + size.borderBottomWidth;
895
896  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;
897
898  // overwrite width and height if we can get it from style
899  var styleWidth = getStyleSize( style.width );
900  if ( styleWidth !== false ) {
901    size.width = styleWidth +
902      // add padding and border unless it's already including it
903      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );
904  }
905
906  var styleHeight = getStyleSize( style.height );
907  if ( styleHeight !== false ) {
908    size.height = styleHeight +
909      // add padding and border unless it's already including it
910      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );
911  }
912
913  size.innerWidth = size.width - ( paddingWidth + borderWidth );

1083);
1084  } else if ( typeof module == 'object' && module.exports ) {
1085    // CommonJS - Browserify, Webpack
1086    module.exports = factory(
1087      window,
1088      require('ev-emitter'),
1089      require('get-size'),
1090      require('fizzy-ui-utils'),
1091      require('./item')
1092    );
1093  } else {
1094    // browser global
1095    window.Outlayer = factory(
1096      window,
1097      window.EvEmitter,
1098      window.getSize,
1099      window.fizzyUIUtils,
1100      window.Outlayer.Item
1101    );
1102  }
1103
1104}( window, function factory( window, EvEmitter, getSize, utils, Item ) {
1105'use strict';
1106
1107// ----- vars ----- //
1108
1109var console = window.console;
1110var jQuery = window.jQuery;
1111var noop = function() {};
1112
1113// -------------------------- Outlayer -------------------------- //
1114
1115// globally unique identifiers
1116var GUID = 0;
1117// internal store of all Outlayer intances
1118var instances = {};
1119
1120
1121/**
1122 * @param {Element, String} element
1123 * @param {Object} options
1124 * @constructor
1125 */
1126function Outlayer( element, options ) {
1127  var queryElement = utils.getQueryElement( element );
1128  if ( !queryElement ) {
1129    if ( console ) {
1130      console.error( 'Bad element for ' + this.constructor.namespace +
1131        ': ' + ( queryElement || element ) );
1132    }
1133    return;
1134  }
1135  this.element = queryElement;
1136  // add jQuery
1137  if ( jQuery ) {
1138    this.$element = jQuery( this.element );
1139  }
1140
1141  // options
1142  this.options = utils.extend( {}, this.constructor.defaults );
1143  this.option( options );
1144
1145  // add id for Outlayer.getFromElement
1146  var id = ++GUID;
1147  this.element.outlayerGUID = id; // expando
1148  instances[ id ] = this; // associate via id
1149
1150  // kick it off
1151  this._create();
1152
1153  var isInitLayout = this._getOption('initLayout');
1154  if ( isInitLayout ) {
1155    this.layout();
1156  }
1157}
1158
1159// settings are for internal use only
1160Outlayer.namespace = 'outlayer';
1161Outlayer.Item = Item;
1162
1163// default options
1164Outlayer.defaults = {
1165  containerStyle: {
1166    position: 'relative'
1167  },
1168  initLayout: true,
1169  originLeft: true,
1170  originTop: true,
1171  resize: true,
1172  resizeContainer: true,
1173  // item options
1174  transitionDuration: '0.4s',
1175  hiddenStyle: {
1176    opacity: 0,
1177    transform: 'scale(0.001)'
1178  },
1179  visibleStyle: {
1180    opacity: 1,
1181    transform: 'scale(1)'
1182  }
1183};
1184
1185var proto = Outlayer.prototype;
1186// inherit EvEmitter
1187utils.extend( proto, EvEmitter.prototype );
1188
1189/**
1190 * set options
1191 * @param {Object} opts
1192 */
1193proto.option = function( opts ) {
1194  utils.extend( this.options, opts );
1195};
1196
1197/**
1198 * get backwards compatible option value, check old name
1199 */
1200proto._getOption = function( option ) {
1201  var oldOption = this.constructor.compatOptions[ option ];
1202  return oldOption && this.options[ oldOption ] !== undefined ?
1203    this.options[ oldOption ] : this.options[ option ];
1204};
1205
1206Outlayer.compatOptions = {
1207  // currentName: oldName
1208  initLayout: 'isInitLayout',
1209  horizontal: 'isHorizontal',
1210  layoutInstant: 'isLayoutInstant',
1211  originLeft: 'isOriginLeft',
1212  originTop: 'isOriginTop',
1213  resize: 'isResizeBound',
1214  resizeContainer: 'isResizingContainer'
1215};
1216
1217proto._create = function() {
1218  // get items from children
1219  this.reloadItems();
1220  // elements that affect layout, but are not laid out
1221  this.stamps = [];
1222  this.stamp( this.options.stamp );
1223  // set container style
1224  utils.extend( this.element.style, this.options.containerStyle );
1225
1226  // bind resize method
1227  var canBindResize = this._getOption('resize');
1228  if ( canBindResize ) {
1229    this.bindResize();
1230  }
1231};
1232
1233// goes through all children again and gets bricks in proper order
1234proto.reloadItems = function() {
1235  // collection of item elements
1236  this.items = this._itemize( this.element.children );
1237};
1238
1239
1240/**
1241 * turn elements into Outlayer.Items to be used in layout
1242 * @param {Array or NodeList or HTMLElement} elems
1243 * @returns {Array} items - collection of new Outlayer Items
1244 */
1245proto._itemize = function( elems ) {
1246
1247  var itemElems = this._filterFindItemElements( elems );
1248  var Item = this.constructor.Item;
1249
1250  // create new Outlayer Items for collection
1251  var items = [];
1252  for ( var i=0; i < itemElems.length; i++ ) {
1253    var elem = itemElems[i];
1254    var item = new Item( elem, this );
1255    items.push( item );
1256  }
1257
1258  return items;
1259};
1260
1261/**
1262 * get item elements to be used in layout
1263 * @param {Array or NodeList or HTMLElement} elems
1264 * @returns {Array} items - item elements
1265 */
1266proto._filterFindItemElements = function( elems ) {
1267  return utils.filterFindElements( elems, this.options.itemSelector );
1268};
1269
1270/**
1271 * getter method for getting item elements
1272 * @returns {Array} elems - collection of item elements
1273 */
1274proto.getItemElements = function() {
1275  return this.items.map( function( item ) {
1276    return item.element;
1277  });
1278};
1279
1280// ----- init & layout ----- //
1281
1282/**
1283 * lays out all items
1284 */
1285proto.layout = function() {
1286  this._resetLayout();
1287  this._manageStamps();
1288
1289  // don't animate first layout
1290  var layoutInstant = this._getOption('layoutInstant');
1291  var isInstant = layoutInstant !== undefined ?
1292    layoutInstant : !this._isLayoutInited;
1293  this.layoutItems( this.items, isInstant );
1294
1295  // flag for initalized
1296  this._isLayoutInited = true;
1297};
1298
1299// _init is alias for layout
1300proto._init = proto.layout;
1301
1302/**
1303 * logic before any new layout
1304 */
1305proto._resetLayout = function() {
1306  this.getSize();
1307};
1308
1309
1310proto.getSize = function() {
1311  this.size = getSize( this.element );
1312};
1313
1314/**
1315 * get measurement from option, for columnWidth, rowHeight, gutter
1316 * if option is String -> get element from selector string, & get size of element
1317 * if option is Element -> get size of element
1318 * else use option as a number
1319 *
1320 * @param {String} measurement
1321 * @param {String} size - width or height
1322 * @private
1323 */
1324proto._getMeasurement = function( measurement, size ) {
1325  var option = this.options[ measurement ];
1326  var elem;
1327  if ( !option ) {
1328    // default to 0
1329    this[ measurement ] = 0;
1330  } else {
1331    // use option as an element
1332    if ( typeof option == 'string' ) {
1333      elem = this.element.querySelector( option );
1334    } else if ( option instanceof HTMLElement ) {
1335      elem = option;
1336    }
1337    // use size of element, if element
1338    this[ measurement ] = elem ? getSize( elem )[ size ] : option;
1339  }
1340};
1341
1342/**
1343 * layout a collection of item elements
1344 * @api public
1345 */
1346proto.layoutItems = function( items, isInstant ) {
1347  items = this._getItemsForLayout( items );
1348
1349  this._layoutItems( items, isInstant );
1350
1351  this._postLayout();
1352};
1353
1354/**
1355 * get the items to be laid out
1356 * you may want to skip over some items
1357 * @param {Array} items
1358 * @returns {Array} items
1359 */
1360proto._getItemsForLayout = function( items ) {
1361  return items.filter( function( item ) {
1362    return !item.isIgnored;
1363  });
1364};
1365
1366/**
1367 * layout items
1368 * @param {Array} items
1369 * @param {Boolean} isInstant
1370 */
1371proto._layoutItems = function( items, isInstant ) {
1372  this._emitCompleteOnItems( 'layout', items );
1373
1374  if ( !items || !items.length ) {
1375    // no items, emit event with empty array
1376    return;
1377  }
1378
1379  var queue = [];
1380
1381  items.forEach( function( item ) {
1382    // get x/y object from method
1383    var position = this._getItemLayoutPosition( item );
1384    // enqueue
1385    position.item = item;
1386    position.isInstant = isInstant || item.isLayoutInstant;
1387    queue.push( position );
1388  }, this );
1389
1390  this._processLayoutQueue( queue );
1391};
1392
1393/**
1394 * get item layout position
1395 * @param {Outlayer.Item} item
1396 * @returns {Object} x and y position
1397 */
1398proto._getItemLayoutPosition = function( /* item */ ) {
1399  return {
1400    x: 0,
1401    y: 0
1402  };
1403};
1404
1405/**
1406 * iterate over array and position each item
1407 * Reason being - separating this logic prevents 'layout invalidation'
1408 * thx @paul_irish
1409 * @param {Array} queue
1410 */
1411proto._processLayoutQueue = function( queue ) {
1412  this.updateStagger();
1413  queue.forEach( function( obj, i ) {
1414    this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );
1415  }, this );
1416};
1417
1418// set stagger from option in milliseconds number
1419proto.updateStagger = function() {
1420  var stagger = this.options.stagger;
1421  if ( stagger === null || stagger === undefined ) {
1422    this.stagger = 0;
1423    return;
1424  }
1425  this.stagger = getMilliseconds( stagger );
1426  return this.stagger;
1427};
1428
1429/**
1430 * Sets position of item in DOM
1431 * @param {Outlayer.Item} item
1432 * @param {Number} x - horizontal position
1433 * @param {Number} y - vertical position
1434 * @param {Boolean} isInstant - disables transitions
1435 */
1436proto._positionItem = function( item, x, y, isInstant, i ) {
1437  if ( isInstant ) {
1438    // if not transition, just set CSS
1439    item.goTo( x, y );
1440  } else {
1441    item.stagger( i * this.stagger );
1442    item.moveTo( x, y );
1443  }
1444};
1445
1446/**
1447 * Any logic you want to do after each layout,
1448 * i.e. size the container
1449 */
1450proto._postLayout = function() {
1451  this.resizeContainer();
1452};
1453
1454proto.resizeContainer = function() {
1455  var isResizingContainer = this._getOption('resizeContainer');
1456  if ( !isResizingContainer ) {
1457    return;
1458  }
1459  var size = this._getContainerSize();
1460  if ( size ) {
1461    this._setContainerMeasure( size.width, true );
1462    this._setContainerMeasure( size.height, false );
1463  }
1464};
1465
1466/**
1467 * Sets width or height of container if returned
1468 * @returns {Object} size
1469 *   @param {Number} width
1470 *   @param {Number} height
1471 */
1472proto._getContainerSize = noop;
1473
1474/**
1475 * @param {Number} measure - size of width or height
1476 * @param {Boolean} isWidth
1477 */
1478proto._setContainerMeasure = function( measure, isWidth ) {
1479  if ( measure === undefined ) {
1480    return;
1481  }
1482
1483  var elemSize = this.size;
1484  // add padding and border width if border box
1485  if ( elemSize.isBorderBox ) {
1486    measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +
1487      elemSize.borderLeftWidth + elemSize.borderRightWidth :
1488      elemSize.paddingBottom + elemSize.paddingTop +
1489      elemSize.borderTopWidth + elemSize.borderBottomWidth;
1490  }
1491
1492  measure = Math.max( measure, 0 );
1493  this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';
1494};
1495
1496/**
1497 * emit eventComplete on a collection of items events
1498 * @param {String} eventName
1499 * @param {Array} items - Outlayer.Items
1500 */
1501proto._emitCompleteOnItems = function( eventName, items ) {
1502  var _this = this;
1503  function onComplete() {
1504    _this.dispatchEvent( eventName + 'Complete', null, [ items ] );
1505  }
1506
1507  var count = items.length;
1508  if ( !items || !count ) {
1509    onComplete();
1510    return;
1511  }
1512
1513  var doneCount = 0;
1514  function tick() {
1515    doneCount++;
1516    if ( doneCount == count ) {
1517      onComplete();
1518    }
1519  }
1520
1521  // bind callback
1522  items.forEach( function( item ) {
1523    item.once( eventName, tick );
1524  });
1525};
1526
1527/**
1528 * emits events via EvEmitter and jQuery events
1529 * @param {String} type - name of event
1530 * @param {Event} event - original event
1531 * @param {Array} args - extra arguments
1532 */
1533proto.dispatchEvent = function( type, event, args ) {
1534  // add original event to arguments
1535  var emitArgs = event ? [ event ].concat( args ) : args;
1536  this.emitEvent( type, emitArgs );
1537
1538  if ( jQuery ) {
1539    // set this.$element
1540    this.$element = this.$element || jQuery( this.element );
1541    if ( event ) {
1542      // create jQuery event
1543      var $event = jQuery.Event( event );
1544      $event.type = type;
1545      this.$element.trigger( $event, args );
1546    } else {
1547      // just trigger with type if no event available
1548      this.$element.trigger( type, args );
1549    }
1550  }
1551};
1552
1553// -------------------------- ignore & stamps -------------------------- //
1554
1555
1556/**
1557 * keep item in collection, but do not lay it out
1558 * ignored items do not get skipped in layout
1559 * @param {Element} elem
1560 */
1561proto.ignore = function( elem ) {
1562  var item = this.getItem( elem );
1563  if ( item ) {
1564    item.isIgnored = true;
1565  }
1566};
1567
1568/**
1569 * return item to layout collection
1570 * @param {Element} elem
1571 */
1572proto.unignore = function( elem ) {
1573  var item = this.getItem( elem );
1574  if ( item ) {
1575    delete item.isIgnored;
1576  }
1577};
1578
1579/**
1580 * adds elements to stamps
1581 * @param {NodeList, Array, Element, or String} elems
1582 */
1583proto.stamp = function( elems ) {
1584  elems = this._find( elems );
1585  if ( !elems ) {
1586    return;
1587  }
1588
1589  this.stamps = this.stamps.concat( elems );
1590  // ignore
1591  elems.forEach( this.ignore, this );
1592};
1593
1594/**
1595 * removes elements to stamps
1596 * @param {NodeList, Array, or Element} elems
1597 */
1598proto.unstamp = function( elems ) {
1599  elems = this._find( elems );
1600  if ( !elems ){
1601    return;
1602  }
1603
1604  elems.forEach( function( elem ) {
1605    // filter out removed stamp elements
1606    utils.removeFrom( this.stamps, elem );
1607    this.unignore( elem );
1608  }, this );
1609};
1610
1611/**
1612 * finds child elements
1613 * @param {NodeList, Array, Element, or String} elems
1614 * @returns {Array} elems
1615 */
1616proto._find = function( elems ) {
1617  if ( !elems ) {
1618    return;
1619  }
1620  // if string, use argument as selector string
1621  if ( typeof elems == 'string' ) {
1622    elems = this.element.querySelectorAll( elems );
1623  }
1624  elems = utils.makeArray( elems );
1625  return elems;
1626};
1627
1628proto._manageStamps = function() {
1629  if ( !this.stamps || !this.stamps.length ) {
1630    return;
1631  }
1632
1633  this._getBoundingRect();
1634
1635  this.stamps.forEach( this._manageStamp, this );
1636};
1637
1638// update boundingLeft / Top
1639proto._getBoundingRect = function() {
1640  // get bounding rect for container element
1641  var boundingRect = this.element.getBoundingClientRect();
1642  var size = this.size;
1643  this._boundingRect = {
1644    left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,
1645    top: boundingRect.top + size.paddingTop + size.borderTopWidth,
1646    right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),
1647    bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )
1648  };
1649};
1650
1651/**
1652 * @param {Element} stamp
1653**/
1654proto._manageStamp = noop;
1655
1656/**
1657 * get x/y position of element relative to container element
1658 * @param {Element} elem
1659 * @returns {Object} offset - has left, top, right, bottom
1660 */
1661proto._getElementOffset = function( elem ) {
1662  var boundingRect = elem.getBoundingClientRect();
1663  var thisRect = this._boundingRect;
1664  var size = getSize( elem );
1665  var offset = {
1666    left: boundingRect.left - thisRect.left - size.marginLeft,
1667    top: boundingRect.top - thisRect.top - size.marginTop,
1668    right: thisRect.right - boundingRect.right - size.marginRight,
1669    bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom
1670  };
1671  return offset;
1672};
1673
1674// -------------------------- resize -------------------------- //
1675
1676// enable event handlers for listeners
1677// i.e. resize -> onresize
1678proto.handleEvent = utils.handleEvent;
1679
1680/**
1681 * Bind layout to window resizing
1682 */
1683proto.bindResize = function() {
1684  window.addEventListener( 'resize', this );
1685  this.isResizeBound = true;
1686};
1687
1688/**
1689 * Unbind layout to window resizing
1690 */
1691proto.unbindResize = function() {
1692  window.removeEventListener( 'resize', this );
1693  this.isResizeBound = false;
1694};
1695
1696proto.onresize = function() {
1697  this.resize();
1698};
1699
1700utils.debounceMethod( Outlayer, 'onresize', 100 );
1701
1702proto.resize = function() {
1703  // don't trigger if size did not change
1704  // or if resize was unbound. See #9
1705  if ( !this.isResizeBound || !this.needsResizeLayout() ) {
1706    return;
1707  }
1708
1709  this.layout();
1710};
1711
1712/**
1713 * check if layout is needed post layout
1714 * @returns Boolean
1715 */
1716proto.needsResizeLayout = function() {
1717  var size = getSize( this.element );
1718  // check that this.size and size are there
1719  // IE8 triggers resize on body size change, so they might not be
1720  var hasSizes = this.size && size;
1721  return hasSizes && size.innerWidth !== this.size.innerWidth;
1722};
1723
1724// -------------------------- methods -------------------------- //
1725
1726/**
1727 * add items to Outlayer instance
1728 * @param {Array or NodeList or Element} elems
1729 * @returns {Array} items - Outlayer.Items
1730**/
1731proto.addItems = function( elems ) {
1732  var items = this._itemize( elems );
1733  // add items to collection
1734  if ( items.length ) {
1735    this.items = this.items.concat( items );
1736  }
1737  return items;
1738};
1739
1740/**
1741 * Layout newly-appended item elements
1742 * @param {Array or NodeList or Element} elems
1743 */
1744proto.appended = function( elems ) {
1745  var items = this.addItems( elems );
1746  if ( !items.length ) {
1747    return;
1748  }
1749  // layout and reveal just the new items
1750  this.layoutItems( items, true );
1751  this.reveal( items );
1752};
1753
1754/**
1755 * Layout prepended elements
1756 * @param {Array or NodeList or Element} elems
1757 */
1758proto.prepended = function( elems ) {
1759  var items = this._itemize( elems );
1760  if ( !items.length ) {
1761    return;
1762  }
1763  // add items to beginning of collection
1764  var previousItems = this.items.slice(0);
1765  this.items = items.concat( previousItems );
1766  // start new layout
1767  this._resetLayout();
1768  this._manageStamps();
1769  // layout new stuff without transition
1770  this.layoutItems( items, true );
1771  this.reveal( items );
1772  // layout previous items
1773  this.layoutItems( previousItems );
1774};
1775
1776/**
1777 * reveal a collection of items
1778 * @param {Array of Outlayer.Items} items
1779 */
1780proto.reveal = function( items ) {
1781  this._emitCompleteOnItems( 'reveal', items );
1782  if ( !items || !items.length ) {
1783    return;
1784  }
1785  var stagger = this.updateStagger();
1786  items.forEach( function( item, i ) {
1787    item.stagger( i * stagger );
1788    item.reveal();
1789  });
1790};
1791
1792/**
1793 * hide a collection of items
1794 * @param {Array of Outlayer.Items} items
1795 */
1796proto.hide = function( items ) {
1797  this._emitCompleteOnItems( 'hide', items );
1798  if ( !items || !items.length ) {
1799    return;
1800  }
1801  var stagger = this.updateStagger();
1802  items.forEach( function( item, i ) {
1803    item.stagger( i * stagger );
1804    item.hide();
1805  });
1806};
1807
1808/**
1809 * reveal item elements
1810 * @param {Array}, {Element}, {NodeList} items
1811 */
1812proto.revealItemElements = function( elems ) {
1813  var items = this.getItems( elems );
1814  this.reveal( items );
1815};
1816
1817/**
1818 * hide item elements
1819 * @param {Array}, {Element}, {NodeList} items
1820 */
1821proto.hideItemElements = function( elems ) {
1822  var items = this.getItems( elems );
1823  this.hide( items );
1824};
1825
1826/**
1827 * get Outlayer.Item, given an Element
1828 * @param {Element} elem
1829 * @param {Function} callback
1830 * @returns {Outlayer.Item} item
1831 */
1832proto.getItem = function( elem ) {
1833  // loop through items to get the one that matches
1834  for ( var i=0; i < this.items.length; i++ ) {
1835    var item = this.items[i];
1836    if ( item.element == elem ) {
1837      // return item
1838      return item;
1839    }
1840  }
1841};
1842
1843/**
1844 * get collection of Outlayer.Items, given Elements
1845 * @param {Array} elems
1846 * @returns {Array} items - Outlayer.Items
1847 */
1848proto.getItems = function( elems ) {
1849  elems = utils.makeArray( elems );
1850  var items = [];
1851  elems.forEach( function( elem ) {
1852    var item = this.getItem( elem );
1853    if ( item ) {
1854      items.push( item );
1855    }
1856  }, this );
1857
1858  return items;
1859};
1860
1861/**
1862 * remove element(s) from instance and DOM
1863 * @param {Array or NodeList or Element} elems
1864 */
1865proto.remove = function( elems ) {
1866  var removeItems = this.getItems( elems );
1867
1868  this._emitCompleteOnItems( 'remove', removeItems );
1869
1870  // bail if no items to remove
1871  if ( !removeItems || !removeItems.length ) {
1872    return;
1873  }
1874
1875  removeItems.forEach( function( item ) {
1876    item.remove();
1877    // remove item from collection
1878    utils.removeFrom( this.items, item );
1879  }, this );
1880};
1881
1882// ----- destroy ----- //
1883
1884// remove and disable Outlayer instance
1885proto.destroy = function() {
1886  // clean up dynamic styles
1887  var style = this.element.style;
1888  style.height = '';
1889  style.position = '';
1890  style.width = '';
1891  // destroy items
1892  this.items.forEach( function( item ) {
1893    item.destroy();
1894  });
1895
1896  this.unbindResize();
1897
1898  var id = this.element.outlayerGUID;
1899  delete instances[ id ]; // remove reference to instance by id
1900  delete this.element.outlayerGUID;
1901  // remove data for jQuery
1902  if ( jQuery ) {
1903    jQuery.removeData( this.element, this.constructor.namespace );
1904  }
1905
1906};
1907
1908// -------------------------- data -------------------------- //
1909
1910/**
1911 * get Outlayer instance from element
1912 * @param {Element} elem
1913 * @returns {Outlayer}
1914 */
1915Outlayer.data = function( elem ) {
1916  elem = utils.getQueryElement( elem );
1917  var id = elem && elem.outlayerGUID;
1918  return id && instances[ id ];
1919};
1920
1921
1922// -------------------------- create Outlayer class -------------------------- //
1923
1924/**
1925 * create a layout class
1926 * @param {String} namespace
1927 */
1928Outlayer.create = function( namespace, options ) {
1929  // sub-class Outlayer
1930  var Layout = subclass( Outlayer );
1931  // apply new options and compatOptions
1932  Layout.defaults = utils.extend( {}, Outlayer.defaults );
1933  utils.extend( Layout.defaults, options );
1934  Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions  );
1935
1936  Layout.namespace = namespace;
1937
1938  Layout.data = Outlayer.data;
1939
1940  // sub-class Item
1941  Layout.Item = subclass( Item );
1942
1943  // -------------------------- declarative -------------------------- //
1944
1945  utils.htmlInit( Layout, namespace );
1946
1947  // -------------------------- jQuery bridge -------------------------- //
1948
1949  // make into jQuery plugin
1950  if ( jQuery && jQuery.bridget ) {
1951    jQuery.bridget( namespace, Layout );
1952  }
1953
1954  return Layout;
1955};
1956
1957function subclass( Parent ) {
1958  function SubClass() {
1959    Parent.apply( this, arguments );
1960  }
1961
1962  SubClass.prototype = Object.create( Parent.prototype );
1963  SubClass.prototype.constructor = SubClass;
1964
1965  return SubClass;
1966}
1967
1968// ----- helpers ----- //
1969
1970// how many milliseconds are in each unit
1971var msUnits = {
1972  ms: 1,
1973  s: 1000
1974};
1975
1976// munge time-like parameter into millisecond number
1977// '0.4s' -> 40
1978function getMilliseconds( time ) {
1979  if ( typeof time == 'number' ) {
1980    return time;
1981  }
1982  var matches = time.match( /(^\d*\.?\d*)(\w*)/ );
1983  var num = matches && matches[1];
1984  var unit = matches && matches[2];
1985  if ( !num.length ) {
1986    return 0;
1987  }
1988  num = parseFloat( num );
1989  var mult = msUnits[ unit ] || 1;
1990  return num * mult;
1991}
1992
1993// ----- fin ----- //
1994
1995// back in global
1996Outlayer.Item = Item;
1997
1998return Outlayer;
1999
2000}));
2001

2079    // don't trigger if size did not change
2080    var size = getSize( this.isotope.element );
2081    // check that this.size and size are there
2082    // IE8 triggers resize on body size change, so they might not be
2083    var hasSizes = this.isotope.size && size;
2084    return hasSizes && size.innerHeight != this.isotope.size.innerHeight;
2085  };
2086
2087  // ----- measurements ----- //
2088
2089  proto._getMeasurement = function() {
2090    this.isotope._getMeasurement.apply( this, arguments );
2091  };
2092
2093  proto.getColumnWidth = function() {
2094    this.getSegmentSize( 'column', 'Width' );
2095  };
2096
2097  proto.getRowHeight = function() {
2098    this.getSegmentSize( 'row', 'Height' );
2099  };
2100
2101  /**
2102   * get columnWidth or rowHeight
2103   * segment: 'column' or 'row'
2104   * size 'Width' or 'Height'
2105  **/
2106  proto.getSegmentSize = function( segment, size ) {
2107    var segmentName = segment + size;
2108    var outerSize = 'outer' + size;
2109    // columnWidth / outerWidth // rowHeight / outerHeight
2110    this._getMeasurement( segmentName, outerSize );
2111    // got rowHeight or columnWidth, we can chill
2112    if ( this[ segmentName ] ) {
2113      return;
2114    }
2115    // fall back to item of first element
2116    var firstItemSize = this.getFirstItemSize();
2117    this[ segmentName ] = firstItemSize && firstItemSize[ outerSize ] ||
2118      // or size of container
2119      this.isotope.size[ 'inner' + size ];
2120  };
2121
2122  proto.getFirstItemSize = function() {
2123    var firstItem = this.isotope.filteredItems[0];
2124    return firstItem && firstItem.element && getSize( firstItem.element );
2125  };
2126
2127  // ----- methods that should reference isotope ----- //
2128
2129  proto.layout = function() {
2130    this.isotope.layout.apply( this.isotope, arguments );
2131  };
2132
2133  proto.getSize = function() {
2134    this.isotope.getSize();
2135    this.size = this.isotope.size;
2136  };
2137
2138  // -------------------------- create -------------------------- //
2139
2140  LayoutMode.modes = {};
2141
2142  LayoutMode.create = function( namespace, options ) {
2143
2144    function Mode() {
2145      LayoutMode.apply( this, arguments );
2146    }
2147
2148    Mode.prototype = Object.create( proto );
2149    Mode.prototype.constructor = Mode;
2150
2151    // default options
2152    if ( options ) {
2153      Mode.options = options;
2154    }
2155
2156    Mode.prototype.namespace = namespace;
2157    // register in Isotope
2158    LayoutMode.modes[ namespace ] = Mode;
2159
2160    return Mode;
2161  };
2162
2163  return LayoutMode;
2164
2165}));
2166
2167
2168/***/ }),
2169/* 7 */
2170/***/ (function(module, exports, __webpack_require__) {
2171
2172/*!
2173 * imagesLoaded v5.0.0
2174 * JavaScript is all like "You images are done yet or what?"
2175 * MIT License
2176 */
2177
2178( function( window, factory ) {
2179  // universal module definition
2180  if ( typeof module == 'object' && module.exports ) {
2181    // CommonJS
2182    module.exports = factory( window, __webpack_require__(24

2182) );
2183  } else {
2184    // browser global
2185    window.imagesLoaded = factory( window, window.EvEmitter );
2186  }
2187
2188} )( typeof window !== 'undefined' ? window : this,
2189    function factory( window, EvEmitter ) {
2190
2191let $ = window.jQuery;
2192let console = window.console;
2193
2194// -------------------------- helpers -------------------------- //
2195
2196// turn element or nodeList into an array
2197function makeArray( obj ) {
2198  // use object if already an array
2199  if ( Array.isArray( obj ) ) return obj;
2200
2201  let isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';
2202  // convert nodeList to array
2203  if ( isArrayLike ) return [ ...obj ];
2204
2205  // array of single index
2206  return [ obj ];
2207}
2208
2209// -------------------------- imagesLoaded -------------------------- //
2210
2211/**
2212 * @param {[Array, Element, NodeList, String]} elem
2213 * @param {[Object, Function]} options - if function, use as callback
2214 * @param {Function} onAlways - callback function
2215 * @returns {ImagesLoaded}
2216 */
2217function ImagesLoaded( elem, options, onAlways ) {
2218  // coerce ImagesLoaded() without new, to be new ImagesLoaded()
2219  if ( !( this instanceof ImagesLoaded ) ) {
2220    return new ImagesLoaded( elem, options, onAlways );
2221  }
2222  // use elem as selector string
2223  let queryElem = elem;
2224  if ( typeof elem == 'string' ) {
2225    queryElem = document.querySelectorAll( elem );
2226  }
2227  // bail if bad element
2228  if ( !queryElem ) {
2229    console.error(`Bad element for imagesLoaded ${queryElem || elem}`);
2230    return;
2231  }
2232
2233  this.elements = makeArray( queryElem );
2234  this.options = {};
2235  // shift arguments if no options set
2236  if ( typeof options == 'function' ) {
2237    onAlways = options;
2238  } else {
2239    Object.assign( this.options, options );
2240  }
2241
2242  if ( onAlways ) this.on( 'always', onAlways );
2243
2244  this.getImages();
2245  // add jQuery Deferred object
2246  if ( $ ) this.jqDeferred = new $.Deferred();
2247
2248  // HACK check async to allow time to bind listeners
2249  setTimeout( this.check.bind( this ) );
2250}
2251
2252ImagesLoaded.prototype = Object.create( EvEmitter.prototype );
2253
2254ImagesLoaded.prototype.getImages = function() {
2255  this.images = [];
2256
2257  // filter & find items if we have an item selector
2258  this.elements.forEach( this.addElementImages, this );
2259};
2260
2261const elementNodeTypes = [ 1, 9, 11 ];
2262
2263/**
2264 * @param {Node} elem
2265 */
2266ImagesLoaded.prototype.addElementImages = function( elem ) {
2267  // filter siblings
2268  if ( elem.nodeName === 'IMG' ) {
2269    this.addImage( elem );
2270  }
2271  // get background image on element
2272  if ( this.options.background === true ) {
2273    this.addElementBackgroundImages( elem );
2274  }
2275
2276  // find children
2277  // no non-element nodes, #143
2278  let { nodeType } = elem;
2279  if ( !nodeType || !elementNodeTypes.includes( nodeType ) ) return;
2280
2281  let childImgs = elem.querySelectorAll('img');
2282  // concat childElems to filterFound array
2283  for ( let img of childImgs ) {
2284    this.addImage( img );
2285  }
2286
2287  // get child background images
2288  if ( typeof this.options.background == 'string' ) {
2289    let children = elem.querySelectorAll( this.options.background );
2290    for ( let child of children ) {
2291      this.addElementBackgroundImages( child );
2292    }
2293  }
2294};
2295
2296const reURL = /url\((['"])?(.*?)\1\)/gi;
2297
2298ImagesLoaded.prototype.addElementBackgroundImages = function( elem ) {
2299  let style = getComputedStyle( elem );
2300  // Firefox returns null if in a hidden iframe https://bugzil.la/548397
2301  if ( !style ) return;
2302
2303  // get url inside url("...")
2304  let matches = reURL.exec( style.backgroundImage );
2305  while ( matches !== null ) {
2306    let url = matches && matches[2];
2307    if ( url ) {
2308      this.addBackground( url, elem );
2309    }
2310    matches = reURL.exec( style.backgroundImage );
2311  }
2312};
2313
2314/**
2315 * @param {Image} img
2316 */
2317ImagesLoaded.prototype.addImage = function( img ) {
2318  let loadingImage = new LoadingImage( img );
2319  this.images.push( loadingImage );
2320};
2321
2322ImagesLoaded.prototype.addBackground = function( url, elem ) {
2323  let background = new Background( url, elem );
2324  this.images.push( background );
2325};
2326
2327ImagesLoaded.prototype.check = function() {
2328  this.progressedCount = 0;
2329  this.hasAnyBroken = false;
2330  // complete if no images
2331  if ( !this.images.length ) {
2332    this.complete();
2333    return;
2334  }
2335
2336  /* eslint-disable-next-line func-style */
2337  let onProgress = ( image, elem, message ) => {
2338    // HACK - Chrome triggers event before object properties have changed. #83
2339    setTimeout( () => {
2340      this.progress( image, elem, message );
2341    } );
2342  };
2343
2344  this.images.forEach( function( loadingImage ) {
2345    loadingImage.once( 'progress', onProgress );
2346    loadingImage.check();
2347  } );
2348};
2349
2350ImagesLoaded.prototype.progress = function( image, elem, message ) {
2351  this.progressedCount++;
2352  this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded;
2353  // progress event
2354  this.emitEvent( 'progress', [ this, image, elem ] );
2355  if ( this.jqDeferred && this.jqDeferred.notify ) {
2356    this.jqDeferred.notify( this, image );
2357  }
2358  // check if completed
2359  if ( this.progressedCount === this.images.length ) {
2360    this.complete();
2361  }
2362
2363  if ( this.options.debug && console ) {
2364    console.log( `progress: ${message}`, image, elem );
2365  }
2366};
2367
2368ImagesLoaded.prototype.complete = function() {
2369  let eventName = this.hasAnyBroken ? 'fail' : 'done';
2370  this.isComplete = true;
2371  this.emitEvent( eventName, [ this ] );
2372  this.emitEvent( 'always', [ this ] );
2373  if ( this.jqDeferred ) {
2374    let jqMethod = this.hasAnyBroken ? 'reject' : 'resolve';
2375    this.jqDeferred[ jqMethod ]( this );
2376  }
2377};
2378
2379// --------------------------  -------------------------- //
2380
2381function LoadingImage( img ) {
2382  this.img = img;
2383}
2384
2385LoadingImage.prototype = Object.create( EvEmitter.prototype );
2386
2387LoadingImage.prototype.check = function() {
2388  // If complete is true and browser supports natural sizes,
2389  // try to check for image status manually.
2390  let isComplete = this.getIsImageComplete();
2391  if ( isComplete ) {
2392    // report based on naturalWidth
2393    this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
2394    return;
2395  }
2396
2397  // If none of the checks above matched, simulate loading on detached element.
2398  this.proxyImage = new Image();
2399  // add crossOrigin attribute. #204
2400  if ( this.img.crossOrigin ) {
2401    this.proxyImage.crossOrigin = this.img.crossOrigin;
2402  }
2403  this.proxyImage.addEventListener( 'load', this );
2404  this.proxyImage.addEventListener( 'error', this );
2405  // bind to image as well for Firefox. #191
2406  this.img.addEventListener( 'load', this );
2407  this.img.addEventListener( 'error', this );
2408  this.proxyImage.src = this.img.currentSrc || this.img.src;
2409};
2410
2411LoadingImage.prototype.getIsImageComplete = function() {
2412  // check for non-zero, non-undefined naturalWidth
2413  // fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671
2414  return this.img.complete && this.img.naturalWidth;
2415};
2416
2417LoadingImage.prototype.confirm = function( isLoaded, message ) {
2418  this.isLoaded = isLoaded;
2419  let { parentNode } = this.img;
2420  // emit progress with parent <picture> or self <img>
2421  let elem = parentNode.nodeName === 'PICTURE' ? parentNode : this.img;
2422  this.emitEvent( 'progress', [ this, elem, message ] );
2423};
2424
2425// ----- events ----- //
2426
2427// trigger specified handler for event type
2428LoadingImage.prototype.handleEvent = function( event ) {
2429  let method = 'on' + event.type;
2430  if ( this[ method ] ) {
2431    this[ method ]( event );
2432  }
2433};
2434
2435LoadingImage.prototype.onload = function() {
2436  this.confirm( true, 'onload' );
2437  this.unbindEvents();
2438};
2439
2440LoadingImage.prototype.onerror = function() {
2441  this.confirm( false, 'onerror' );
2442  this.unbindEvents();
2443};
2444
2445LoadingImage.prototype.unbindEvents = function() {
2446  this.proxyImage.removeEventListener( 'load', this );
2447  this.proxyImage.removeEventListener( 'error', this );
2448  this.img.removeEventListener( 'load', this );
2449  this.img.removeEventListener( 'error', this );
2450};
2451
2452// -------------------------- Background -------------------------- //
2453
2454function Background( url, element ) {
2455  this.url = url;
2456  this.element = element;
2457  this.img = new Image();
2458}
2459
2460// inherit LoadingImage prototype
2461Background.prototype = Object.create( LoadingImage.prototype );
2462
2463Background.prototype.check = function() {
2464  this.img.addEventListener( 'load', this );
2465  this.img.addEventListener( 'error', this );
2466  this.img.src = this.url;
2467  // check if image is already complete
2468  let isComplete = this.getIsImageComplete();
2469  if ( isComplete ) {
2470    this.confirm( this.img.naturalWidth !== 0, 'naturalWidth' );
2471    this.unbindEvents();
2472  }
2473};
2474
2475Background.prototype.unbindEvents = function() {
2476  this.img.removeEventListener( 'load', this );
2477  this.img.removeEventListener( 'error', this );
2478};
2479
2480Background.prototype.confirm = function( isLoaded, message ) {
2481  this.isLoaded = isLoaded;
2482  this.emitEvent( 'progress', [ this, this.element, message ] );
2483};
2484
2485// -------------------------- jQuery -------------------------- //
2486
2487ImagesLoaded.makeJQueryPlugin = function( jQuery ) {
2488  jQuery = jQuery || window.jQuery;
2489  if ( !jQuery ) return;
2490
2491  // set local variable
2492  $ = jQuery;
2493  // $().imagesLoaded()
2494  $.fn.imagesLoaded = function( options, onAlways ) {
2495    let instance = new ImagesLoaded( this, options, onAlways );
2496    return instance.jqDeferred.promise( $( this ) );
2497  };
2498};
2499// try making plugin
2500ImagesLoaded.makeJQueryPlugin();
2501
2502// --------------------------  -------------------------- //
2503
2504return ImagesLoaded;
2505
2506} );

2574
2575
2576// -------------------------- vars -------------------------- //
2577
2578var jQuery = window.jQuery;
2579
2580// -------------------------- helpers -------------------------- //
2581
2582var trim = String.prototype.trim ?
2583  function( str ) {
2584    return str.trim();
2585  } :
2586  function( str ) {
2587    return str.replace( /^\s+|\s+$/g, '' );
2588  };
2589
2590// -------------------------- isotopeDefinition -------------------------- //
2591
2592  // create an Outlayer layout class
2593  var Isotope = Outlayer.create( 'isotope', {
2594    layoutMode: 'masonry',
2595    isJQueryFiltering: true,
2596    sortAscending: true
2597  });
2598
2599  Isotope.Item = Item;
2600  Isotope.LayoutMode = LayoutMode;
2601
2602  var proto = Isotope.prototype;
2603
2604  proto._create = function() {
2605    this.itemGUID = 0;
2606    // functions that sort items
2607    this._sorters = {};
2608    this._getSorters();
2609    // call super
2610    Outlayer.prototype._create.call( this );
2611
2612    // create layout modes
2613    this.modes = {};
2614    // start filteredItems with all items
2615    this.filteredItems = this.items;
2616    // keep of track of sortBys
2617    this.sortHistory = [ 'original-order' ];
2618    // create from registered layout modes
2619    for ( var name in LayoutMode.modes ) {
2620      this._initLayoutMode( name );
2621    }
2622  };
2623
2624  proto.reloadItems = function() {
2625    // reset item ID counter
2626    this.itemGUID = 0;
2627    // call super
2628    Outlayer.prototype.reloadItems.call( this );
2629  };
2630
2631  proto._itemize = function() {
2632    var items = Outlayer.prototype._itemize.apply( this, arguments );
2633    // assign ID for original-order
2634    for ( var i=0; i < items.length; i++ ) {
2635      var item = items[i];
2636      item.id = this.itemGUID++;
2637    }
2638    this._updateItemsSortData( items );
2639    return items;
2640  };
2641
2642
2643  // -------------------------- layout -------------------------- //
2644
2645  proto._initLayoutMode = function( name ) {
2646    var Mode = LayoutMode.modes[ name ];
2647    // set mode options
2648    // HACK extend initial options, back-fill in default options
2649    var initialOpts = this.options[ name ] || {};
2650    this.options[ name ] = Mode.options ?
2651      utils.extend( Mode.options, initialOpts ) : initialOpts;
2652    // init layout mode instance
2653    this.modes[ name ] = new Mode( this );
2654  };
2655
2656
2657  proto.layout = function() {
2658    // if first time doing layout, do all magic
2659    if ( !this._isLayoutInited && this._getOption('initLayout') ) {
2660      this.arrange();
2661      return;
2662    }
2663    this._layout();
2664  };
2665
2666  // private method to be used in layout() & magic()
2667  proto._layout = function() {
2668    // don't animate first layout
2669    var isInstant = this._getIsInstant();
2670    // layout flow
2671    this._resetLayout();
2672    this._manageStamps();
2673    this.layoutItems( this.filteredItems, isInstant );
2674
2675    // flag for initalized
2676    this._isLayoutInited = true;
2677  };
2678
2679  // filter + sort + layout
2680  proto.arrange = function( opts ) {
2681    // set any options pass
2682    this.option( opts );
2683    this._getIsInstant();
2684    // filter, sort, and layout
2685
2686    // filter
2687    var filtered = this._filter( this.items );
2688    this.filteredItems = filtered.matches;
2689
2690    this._bindArrangeComplete();
2691
2692    if ( this._isInstant ) {
2693      this._noTransition( this._hideReveal, [ filtered ] );
2694    } else {
2695      this._hideReveal( filtered );
2696    }
2697
2698    this._sort();
2699    this._layout();
2700  };
2701  // alias to _init for main plugin method
2702  proto._init = proto.arrange;
2703
2704  proto._hideReveal = function( filtered ) {
2705    this.reveal( filtered.needReveal );
2706    this.hide( filtered.needHide );
2707  };
2708
2709  // HACK
2710  // Don't animate/transition first layout
2711  // Or don't animate/transition other layouts
2712  proto._getIsInstant = function() {
2713    var isLayoutInstant = this._getOption('layoutInstant');
2714    var isInstant = isLayoutInstant !== undefined ? isLayoutInstant :
2715      !this._isLayoutInited;
2716    this._isInstant = isInstant;
2717    return isInstant;
2718  };
2719
2720  // listen for layoutComplete, hideComplete and revealComplete
2721  // to trigger arrangeComplete
2722  proto._bindArrangeComplete = function() {
2723    // listen for 3 events to trigger arrangeComplete
2724    var isLayoutComplete, isHideComplete, isRevealComplete;
2725    var _this = this;
2726    function arrangeParallelCallback() {
2727      if ( isLayoutComplete && isHideComplete && isRevealComplete ) {
2728        _this.dispatchEvent( 'arrangeComplete', null, [ _this.filteredItems ] );
2729      }
2730    }
2731    this.once( 'layoutComplete', function() {
2732      isLayoutComplete = true;
2733      arrangeParallelCallback();
2734    });
2735    this.once( 'hideComplete', function() {
2736      isHideComplete = true;
2737      arrangeParallelCallback();
2738    });
2739    this.once( 'revealComplete', function() {
2740      isRevealComplete = true;
2741      arrangeParallelCallback();
2742    });
2743  };
2744
2745  // -------------------------- filter -------------------------- //
2746
2747  proto._filter = function( items ) {
2748    var filter = this.options.filter;
2749    filter = filter || '*';
2750    var matches = [];
2751    var hiddenMatched = [];
2752    var visibleUnmatched = [];
2753
2754    var test = this._getFilterTest( filter );
2755
2756    // test each item
2757    for ( var i=0; i < items.length; i++ ) {
2758      var item = items[i];
2759      if ( item.isIgnored ) {
2760        continue;
2761      }
2762      // add item to either matched or unmatched group
2763      var isMatched = test( item );
2764      // item.isFilterMatched = isMatched;
2765      // add to matches if its a match
2766      if ( isMatched ) {
2767        matches.push( item );
2768      }
2769      // add to additional group if item needs to be hidden or revealed
2770      if ( isMatched && item.isHidden ) {
2771        hiddenMatched.push( item );
2772      } else if ( !isMatched && !item.isHidden ) {
2773        visibleUnmatched.push( item );
2774      }
2775    }
2776
2777    // return collections of items to be manipulated
2778    return {
2779      matches: matches,
2780      needReveal: hiddenMatched,
2781      needHide: visibleUnmatched
2782    };
2783  };
2784
2785  // get a jQuery, function, or a matchesSelector test given the filter
2786  proto._getFilterTest = function( filter ) {
2787    if ( jQuery && this.options.isJQueryFiltering ) {
2788      // use jQuery
2789      return function( item ) {
2790        return jQuery( item.element ).is( filter );
2791      };
2792    }
2793    if ( typeof filter == 'function' ) {
2794      // use filter as function
2795      return function( item ) {
2796        return filter( item.element );
2797      };
2798    }
2799    // default, use filter as selector string
2800    return function( item ) {
2801      return matchesSelector( item.element, filter );
2802    };
2803  };
2804
2805  // -------------------------- sorting -------------------------- //
2806
2807  /**
2808   * @params {Array} elems
2809   * @public
2810   */
2811  proto.updateSortData = function( elems ) {
2812    // get items
2813    var items;
2814    if ( elems ) {
2815      elems = utils.makeArray( elems );
2816      items = this.getItems( elems );
2817    } else {
2818      // update all items if no elems provided
2819      items = this.items;
2820    }
2821
2822    this._getSorters();
2823    this._updateItemsSortData( items );
2824  };
2825
2826  proto._getSorters = function() {
2827    var getSortData = this.options.getSortData;
2828    for ( var key in getSortData ) {
2829      var sorter = getSortData[ key ];
2830      this._sorters[ key ] = mungeSorter( sorter );
2831    }
2832  };
2833
2834  /**
2835   * @params {Array} items - of Isotope.Items
2836   * @private
2837   */
2838  proto._updateItemsSortData = function( items ) {
2839    // do not update if no items
2840    var len = items && items.length;
2841
2842    for ( var i=0; len && i < len; i++ ) {
2843      var item = items[i];
2844      item.updateSortData();
2845    }
2846  };
2847
2848  // ----- munge sorter ----- //
2849
2850  // encapsulate this, as we just need mungeSorter
2851  // other functions in here are just for munging
2852  var mungeSorter = ( function() {
2853    // add a magic layer to sorters for convienent shorthands
2854    // `.foo-bar` will use the text of .foo-bar querySelector
2855    // `[foo-bar]` will use attribute
2856    // you can also add parser
2857    // `.foo-bar parseInt` will parse that as a number
2858    function mungeSorter( sorter ) {
2859      // if not a string, return function or whatever it is
2860      if ( typeof sorter != 'string' ) {
2861        return sorter;
2862      }
2863      // parse the sorter string
2864      var args = trim( sorter ).split(' ');
2865      var query = args[0];
2866      // check if query looks like [an-attribute]
2867      var attrMatch = query.match( /^\[(.+)\]$/ );
2868      var attr = attrMatch && attrMatch[1];
2869      var getValue = getValueGetter( attr, query );
2870      // use second argument as a parser
2871      var parser = Isotope.sortDataParsers[ args[1] ];
2872      // parse the value, if there was a parser
2873      sorter = parser ? function( elem ) {
2874        return elem && parser( getValue( elem ) );
2875      } :
2876      // otherwise just return value
2877      function( elem ) {
2878        return elem && getValue( elem );
2879      };
2880
2881      return sorter;
2882    }
2883
2884    // get an attribute getter, or get text of the querySelector
2885    function getValueGetter( attr, query ) {
2886      // if query looks like [foo-bar], get attribute
2887      if ( attr ) {
2888        return function getAttribute( elem ) {
2889          return elem.getAttribute( attr );
2890        };
2891      }
2892
2893      // otherwise, assume its a querySelector, and get its text
2894      return function getChildText( elem ) {
2895        var child = elem.querySelector( query );
2896        return child && child.textContent;
2897      };
2898    }
2899
2900    return mungeSorter;
2901  })();
2902
2903  // parsers used in getSortData shortcut strings
2904  Isotope.sortDataParsers = {
2905    'parseInt': function( val ) {
2906      return parseInt( val, 10 );
2907    },
2908    'parseFloat': function( val ) {
2909      return parseFloat( val );
2910    }
2911  };
2912
2913  // ----- sort method ----- //
2914
2915  // sort filteredItem order
2916  proto._sort = function() {
2917    if ( !this.options.sortBy ) {
2918      return;
2919    }
2920    // keep track of sortBy History
2921    var sortBys = utils.makeArray( this.options.sortBy );
2922    if ( !this._getIsSameSortBy( sortBys ) ) {
2923      // concat all sortBy and sortHistory, add to front, oldest goes in last
2924      this.sortHistory = sortBys.concat( this.sortHistory );
2925    }
2926    // sort magic
2927    var itemSorter = getItemSorter( this.sortHistory, this.options.sortAscending );
2928    this.filteredItems.sort( itemSorter );
2929  };
2930
2931  // check if sortBys is same as start of sortHistory
2932  proto._getIsSameSortBy = function( sortBys ) {
2933    for ( var i=0; i < sortBys.length; i++ ) {
2934      if ( sortBys[i] != this.sortHistory[i] ) {
2935        return false;
2936      }
2937    }
2938    return true;
2939  };
2940
2941  // returns a function used for sorting
2942  function getItemSorter( sortBys, sortAsc ) {
2943    return function sorter( itemA, itemB ) {
2944      // cycle through all sortKeys
2945      for ( var i = 0; i < sortBys.length; i++ ) {
2946        var sortBy = sortBys[i];
2947        var a = itemA.sortData[ sortBy ];
2948        var b = itemB.sortData[ sortBy ];
2949        if ( a > b || a < b ) {
2950          // if sortAsc is an object, use the value given the sortBy key
2951          var isAscending = sortAsc[ sortBy ] !== undefined ? sortAsc[ sortBy ] : sortAsc;
2952          var direction = isAscending ? 1 : -1;
2953          return ( a > b ? 1 : -1 ) * direction;
2954        }
2955      }
2956      return 0;
2957    };
2958  }
2959
2960  // -------------------------- methods -------------------------- //
2961
2962  // get layout mode
2963  proto._mode = function() {
2964    var layoutMode = this.options.layoutMode;
2965    var mode = this.modes[ layoutMode ];
2966    if ( !mode ) {
2967      // TODO console.error
2968      throw new Error( 'No layout mode: ' + layoutMode );
2969    }
2970    // HACK sync mode's options
2971    // any options set after init for layout mode need to be synced
2972    mode.options = this.options[ layoutMode ];
2973    return mode;
2974  };
2975
2976  proto._resetLayout = function() {
2977    // trigger original reset layout
2978    Outlayer.prototype._resetLayout.call( this );
2979    this._mode()._resetLayout();
2980  };
2981
2982  proto._getItemLayoutPosition = function( item  ) {
2983    return this._mode()._getItemLayoutPosition( item );
2984  };
2985
2986  proto._manageStamp = function( stamp ) {
2987    this._mode()._manageStamp( stamp );
2988  };
2989
2990  proto._getContainerSize = function() {
2991    return this._mode()._getContainerSize();
2992  };
2993
2994  proto.needsResizeLayout = function() {
2995    return this._mode().needsResizeLayout();
2996  };
2997
2998  // -------------------------- adding & removing -------------------------- //
2999
3000  // HEADS UP overwrites default Outlayer appended
3001  proto.appended = function( elems ) {
3002    var items = this.addItems( elems );
3003    if ( !items.length ) {
3004      return;
3005    }
3006    // filter, layout, reveal new items
3007    var filteredItems = this._filterRevealAdded( items );
3008    // add to filteredItems
3009    this.filteredItems = this.filteredItems.concat( filteredItems );
3010  };
3011
3012  // HEADS UP overwrites default Outlayer prepended
3013  proto.prepended = function( elems ) {
3014    var items = this._itemize( elems );
3015    if ( !items.length ) {
3016      return;
3017    }
3018    // start new layout
3019    this._resetLayout();
3020    this._manageStamps();
3021    // filter, layout, reveal new items
3022    var filteredItems = this._filterRevealAdded( items );
3023    // layout previous items
3024    this.layoutItems( this.filteredItems );
3025    // add to items and filteredItems
3026    this.filteredItems = filteredItems.concat( this.filteredItems );
3027    this.items = items.concat( this.items );
3028  };
3029
3030  proto._filterRevealAdded = function( items ) {
3031    var filtered = this._filter( items );
3032    this.hide( filtered.needHide );
3033    // reveal all new items
3034    this.reveal( filtered.matches );
3035    // layout new items, no transition
3036    this.layoutItems( filtered.matches, true );
3037    return filtered.matches;
3038  };
3039
3040  /**
3041   * Filter, sort, and layout newly-appended item elements
3042   * @param {Array or NodeList or Element} elems
3043   */
3044  proto.insert = function( elems ) {
3045    var items = this.addItems( elems );
3046    if ( !items.length ) {
3047      return;
3048    }
3049    // append item elements
3050    var i, item;
3051    var len = items.length;
3052    for ( i=0; i < len; i++ ) {
3053      item = items[i];
3054      this.element.appendChild( item.element );
3055    }
3056    // filter new stuff
3057    var filteredInsertItems = this._filter( items ).matches;
3058    // set flag
3059    for ( i=0; i < len; i++ ) {
3060      items[i].isLayoutInstant = true;
3061    }
3062    this.arrange();
3063    // reset flag
3064    for ( i=0; i < len; i++ ) {
3065      delete items[i].isLayoutInstant;
3066    }
3067    this.reveal( filteredInsertItems );
3068  };
3069
3070  var _remove = proto.remove;
3071  proto.remove = function( elems ) {
3072    elems = utils.makeArray( elems );
3073    var removeItems = this.getItems( elems );
3074    // do regular thing
3075    _remove.call( this, elems );
3076    // bail if no items to remove
3077    var len = removeItems && removeItems.length;
3078    // remove elems from filteredItems
3079    for ( var i=0; len && i < len; i++ ) {
3080      var item = removeItems[i];
3081      // remove item from collection
3082      utils.removeFrom( this.filteredItems, item );
3083    }
3084  };
3085
3086  proto.shuffle = function() {
3087    // update random sortData
3088    for ( var i=0; i < this.items.length; i++ ) {
3089      var item = this.items[i];
3090      item.sortData.random = Math.random();
3091    }
3092    this.options.sortBy = 'random';
3093    this._sort();
3094    this._layout();
3095  };
3096
3097  /**
3098   * trigger fn without transition
3099   * kind of hacky to have this in the first place
3100   * @param {Function} fn
3101   * @param {Array} args
3102   * @returns ret
3103   * @private
3104   */
3105  proto._noTransition = function( fn, args ) {
3106    // save transitionDuration before disabling
3107    var transitionDuration = this.options.transitionDuration;
3108    // disable transition
3109    this.options.transitionDuration = 0;
3110    // do it
3111    var returnValue = fn.apply( this, args );
3112    // re-enable transition for reveal
3113    this.options.transitionDuration = transitionDuration;
3114    return returnValue;
3115  };
3116
3117  // ----- helper methods ----- //
3118
3119  /**
3120   * getter method for getting filtered item elements
3121   * @returns {Array} elems - collection of item elements
3122   */
3123  proto.getFilteredItemElements = function() {
3124    return this.filteredItems.map( function( item ) {
3125      return item.element;
3126    });
3127  };
3128
3129  // -----  ----- //
3130
3131  return Isotope;
3132
3133}));
3134