{"version":3,"sources":["webpack:///./node_modules/shufflejs/dist/shuffle.esm.js"],"names":["_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","_createClass","protoProps","staticProps","prototype","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","__proto__","_setPrototypeOf","p","_possibleConstructorReturn","self","call","ReferenceError","_assertThisInitialized","E","on","name","callback","ctx","e","this","push","fn","once","listener","off","apply","arguments","_","emit","data","slice","evtArr","len","evts","liveEvents","tinyEmitter","TinyEmitter","proto","Element","vendor","matches","matchesSelector","webkitMatchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","el","selector","nodeType","nodes","parentNode","querySelectorAll","throttleit","func","wait","args","rtn","timeoutID","last","delta","Date","setTimeout","noop","getNumber","value","parseFloat","Point","x","y","a","b","Rect","w","h","id","left","top","width","height","Classes","BASE","SHUFFLE_ITEM","VISIBLE","HIDDEN","ShuffleItem","element","isVisible","isHidden","classList","remove","add","removeAttribute","setAttribute","addClasses","applyCss","Css","INITIAL","scale","Scale","point","classes","_this","forEach","className","_this2","obj","_this3","keys","style","removeClasses","position","visibility","willChange","before","opacity","after","transitionDelay","testComputedSize","document","body","documentElement","createElement","cssText","appendChild","window","getComputedStyle","removeChild","getNumberStyle","styles","undefined","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","defaults","reverse","by","compare","randomize","sorter","arr","options","opts","assign","original","Array","from","revert","array","n","Math","floor","random","temp","sort","valA","valB","transitions","eventName","count","cancelTransitionEnd","removeEventListener","onTransitionEnd","evt","currentTarget","addEventListener","arrayMax","max","getColumnSpan","itemWidth","columnWidth","columns","threshold","columnSpan","abs","round","min","ceil","getAvailablePositions","positions","available","getShortColumn","buffer","minPosition","getCenteredPositions","itemRects","containerWidth","rowMap","itemRect","rects","rows","centeredRows","intersectingRect","lastItem","end","offset","finalRects","canMove","newRects","every","r","newRect","noOverlap","some","intersects","rowIndex","findIndex","items","includes","splice","concat","map","arrayUnique","Set","id$1","Shuffle","_TinyEmitter","delimeter","delimiter","lastSort","group","ALL_ITEMS","lastFilter","isEnabled","isDestroyed","isInitialized","_transitions","isTransitioning","_queue","_getElementOption","_init","subClass","superClass","create","constructor","_inherits","_getItems","sizer","_initItems","_onResize","_getResizeFunction","readyState","layout","bind","onLoad","containerCss","getSize","_validateStyles","_setColumns","filter","initialSort","offsetWidth","setItemTransitions","transition","speed","easing","resizeFunction","_handleResize","throttle","throttleTime","option","querySelector","jquery","overflow","category","collection","set","_getFilteredSets","_toggleFilterClasses","visible","hidden","item","_doesPassFilter","attr","getAttribute","FILTER_ATTRIBUTE_KEY","split","JSON","parse","testCategory","isArray","filterMode","FilterMode","ANY","_ref","show","hide","init","dispose","visibleItems","_getFilteredItems","_this$options","positionProps","useTransforms","cssProps","k","replace","str","m1","toLowerCase","properties","join","transitionDuration","transitionTimingFunction","transitionProperty","children","itemSelector","indexOf","gutterSize","size","gutterWidth","gutter","_getGutterSize","_getColumnSize","calculatedColumns","columnThreshold","cols","colWidth","_getContainerSize","index","staggerAmount","staggerAmountMax","shuffle","_this4","itemPositions","_getNextPositions","equals","getStylesForTransition","_getStaggerAmount","_this5","isCentered","itemsData","itemSize","_getItemPosition","getTransformedPositions","gridSize","total","span","setY","shortColumnIndex","setHeight","getItemPosition","_this6","_getConcealedItems","update","styleObject","roundTransforms","transform","itemCallback","done","_this7","_whenTransitionDone","_cancelMovement","hasSpeed","hasQueue","_startTransitions","_styleImmediately","_dispatch","EventType","LAYOUT","_this8","fns","context","pending","finished","results","maybeDone","err","result","arrayParallel","_getTransitionFunction","_movementFinished","objects","elements","_skipTransitions","sortOptions","_filter","_shrink","_updateItemCount","_resetCols","_layout","_processQueue","_setContainerSize","isOnlyLayout","newItems","_this9","sortedItems","_mergeNewItems","allSortedItemsSet","isNewItem","applyHiddenState","isUpdateLayout","_this10","oldItems","getItemByElement","_disposeItems","REMOVED","find","_this11","includeMargins","marginLeft","marginRight","marginTop","marginBottom","duration","delay","ALL","__sorter","__getColumnSpan","__getAvailablePositions","__getShortColumn","__getCenteredPositions"],"mappings":"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","file":"js/1.f859ba8d.chunk.js","sourcesContent":["function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nfunction E () {\n  // Keep this empty so it's easier to inherit from\n  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n}\n\nE.prototype = {\n  on: function (name, callback, ctx) {\n    var e = this.e || (this.e = {});\n\n    (e[name] || (e[name] = [])).push({\n      fn: callback,\n      ctx: ctx\n    });\n\n    return this;\n  },\n\n  once: function (name, callback, ctx) {\n    var self = this;\n    function listener () {\n      self.off(name, listener);\n      callback.apply(ctx, arguments);\n    }\n    listener._ = callback;\n    return this.on(name, listener, ctx);\n  },\n\n  emit: function (name) {\n    var data = [].slice.call(arguments, 1);\n    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n    var i = 0;\n    var len = evtArr.length;\n\n    for (i; i < len; i++) {\n      evtArr[i].fn.apply(evtArr[i].ctx, data);\n    }\n\n    return this;\n  },\n\n  off: function (name, callback) {\n    var e = this.e || (this.e = {});\n    var evts = e[name];\n    var liveEvents = [];\n\n    if (evts && callback) {\n      for (var i = 0, len = evts.length; i < len; i++) {\n        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n          liveEvents.push(evts[i]);\n      }\n    }\n\n    // Remove event from queue to prevent memory leak\n    // Suggested by https://github.com/lazd\n    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n    (liveEvents.length)\n      ? e[name] = liveEvents\n      : delete e[name];\n\n    return this;\n  }\n};\n\nvar tinyEmitter = E;\nvar TinyEmitter = E;\ntinyEmitter.TinyEmitter = TinyEmitter;\n\nvar proto = typeof Element !== 'undefined' ? Element.prototype : {};\nvar vendor = proto.matches\n  || proto.matchesSelector\n  || proto.webkitMatchesSelector\n  || proto.mozMatchesSelector\n  || proto.msMatchesSelector\n  || proto.oMatchesSelector;\n\nvar matchesSelector = match;\n\n/**\n * Match `el` to `selector`.\n *\n * @param {Element} el\n * @param {String} selector\n * @return {Boolean}\n * @api public\n */\n\nfunction match(el, selector) {\n  if (!el || el.nodeType !== 1) return false;\n  if (vendor) return vendor.call(el, selector);\n  var nodes = el.parentNode.querySelectorAll(selector);\n  for (var i = 0; i < nodes.length; i++) {\n    if (nodes[i] == el) return true;\n  }\n  return false;\n}\n\nvar throttleit = throttle;\n\n/**\n * Returns a new function that, when invoked, invokes `func` at most once per `wait` milliseconds.\n *\n * @param {Function} func Function to wrap.\n * @param {Number} wait Number of milliseconds that must elapse between `func` invocations.\n * @return {Function} A new function that wraps the `func` function passed in.\n */\n\nfunction throttle (func, wait) {\n  var ctx, args, rtn, timeoutID; // caching\n  var last = 0;\n\n  return function throttled () {\n    ctx = this;\n    args = arguments;\n    var delta = new Date() - last;\n    if (!timeoutID)\n      if (delta >= wait) call();\n      else timeoutID = setTimeout(call, wait - delta);\n    return rtn;\n  };\n\n  function call () {\n    timeoutID = 0;\n    last = +new Date();\n    rtn = func.apply(ctx, args);\n    ctx = null;\n    args = null;\n  }\n}\n\nvar arrayParallel = function parallel(fns, context, callback) {\n  if (!callback) {\n    if (typeof context === 'function') {\n      callback = context;\n      context = null;\n    } else {\n      callback = noop;\n    }\n  }\n\n  var pending = fns && fns.length;\n  if (!pending) return callback(null, []);\n\n  var finished = false;\n  var results = new Array(pending);\n\n  fns.forEach(context ? function (fn, i) {\n    fn.call(context, maybeDone(i));\n  } : function (fn, i) {\n    fn(maybeDone(i));\n  });\n\n  function maybeDone(i) {\n    return function (err, result) {\n      if (finished) return;\n\n      if (err) {\n        callback(err, results);\n        finished = true;\n        return\n      }\n\n      results[i] = result;\n\n      if (!--pending) callback(null, results);\n    }\n  }\n};\n\nfunction noop() {}\n\n/**\n * Always returns a numeric value, given a value. Logic from jQuery's `isNumeric`.\n * @param {*} value Possibly numeric value.\n * @return {number} `value` or zero if `value` isn't numeric.\n */\nfunction getNumber(value) {\n  return parseFloat(value) || 0;\n}\n\nvar Point =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Represents a coordinate pair.\n   * @param {number} [x=0] X.\n   * @param {number} [y=0] Y.\n   */\n  function Point(x, y) {\n    _classCallCheck(this, Point);\n\n    this.x = getNumber(x);\n    this.y = getNumber(y);\n  }\n  /**\n   * Whether two points are equal.\n   * @param {Point} a Point A.\n   * @param {Point} b Point B.\n   * @return {boolean}\n   */\n\n\n  _createClass(Point, null, [{\n    key: \"equals\",\n    value: function equals(a, b) {\n      return a.x === b.x && a.y === b.y;\n    }\n  }]);\n\n  return Point;\n}();\n\nvar Rect =\n/*#__PURE__*/\nfunction () {\n  /**\n   * Class for representing rectangular regions.\n   * https://github.com/google/closure-library/blob/master/closure/goog/math/rect.js\n   * @param {number} x Left.\n   * @param {number} y Top.\n   * @param {number} w Width.\n   * @param {number} h Height.\n   * @param {number} id Identifier\n   * @constructor\n   */\n  function Rect(x, y, w, h, id) {\n    _classCallCheck(this, Rect);\n\n    this.id = id;\n    /** @type {number} */\n\n    this.left = x;\n    /** @type {number} */\n\n    this.top = y;\n    /** @type {number} */\n\n    this.width = w;\n    /** @type {number} */\n\n    this.height = h;\n  }\n  /**\n   * Returns whether two rectangles intersect.\n   * @param {Rect} a A Rectangle.\n   * @param {Rect} b A Rectangle.\n   * @return {boolean} Whether a and b intersect.\n   */\n\n\n  _createClass(Rect, null, [{\n    key: \"intersects\",\n    value: function intersects(a, b) {\n      return a.left < b.left + b.width && b.left < a.left + a.width && a.top < b.top + b.height && b.top < a.top + a.height;\n    }\n  }]);\n\n  return Rect;\n}();\n\nvar Classes = {\n  BASE: 'shuffle',\n  SHUFFLE_ITEM: 'shuffle-item',\n  VISIBLE: 'shuffle-item--visible',\n  HIDDEN: 'shuffle-item--hidden'\n};\n\nvar id = 0;\n\nvar ShuffleItem =\n/*#__PURE__*/\nfunction () {\n  function ShuffleItem(element) {\n    _classCallCheck(this, ShuffleItem);\n\n    id += 1;\n    this.id = id;\n    this.element = element;\n    /**\n     * Used to separate items for layout and shrink.\n     */\n\n    this.isVisible = true;\n    /**\n     * Used to determine if a transition will happen. By the time the _layout\n     * and _shrink methods get the ShuffleItem instances, the `isVisible` value\n     * has already been changed by the separation methods, so this property is\n     * needed to know if the item was visible/hidden before the shrink/layout.\n     */\n\n    this.isHidden = false;\n  }\n\n  _createClass(ShuffleItem, [{\n    key: \"show\",\n    value: function show() {\n      this.isVisible = true;\n      this.element.classList.remove(Classes.HIDDEN);\n      this.element.classList.add(Classes.VISIBLE);\n      this.element.removeAttribute('aria-hidden');\n    }\n  }, {\n    key: \"hide\",\n    value: function hide() {\n      this.isVisible = false;\n      this.element.classList.remove(Classes.VISIBLE);\n      this.element.classList.add(Classes.HIDDEN);\n      this.element.setAttribute('aria-hidden', true);\n    }\n  }, {\n    key: \"init\",\n    value: function init() {\n      this.addClasses([Classes.SHUFFLE_ITEM, Classes.VISIBLE]);\n      this.applyCss(ShuffleItem.Css.INITIAL);\n      this.scale = ShuffleItem.Scale.VISIBLE;\n      this.point = new Point();\n    }\n  }, {\n    key: \"addClasses\",\n    value: function addClasses(classes) {\n      var _this = this;\n\n      classes.forEach(function (className) {\n        _this.element.classList.add(className);\n      });\n    }\n  }, {\n    key: \"removeClasses\",\n    value: function removeClasses(classes) {\n      var _this2 = this;\n\n      classes.forEach(function (className) {\n        _this2.element.classList.remove(className);\n      });\n    }\n  }, {\n    key: \"applyCss\",\n    value: function applyCss(obj) {\n      var _this3 = this;\n\n      Object.keys(obj).forEach(function (key) {\n        _this3.element.style[key] = obj[key];\n      });\n    }\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      this.removeClasses([Classes.HIDDEN, Classes.VISIBLE, Classes.SHUFFLE_ITEM]);\n      this.element.removeAttribute('style');\n      this.element = null;\n    }\n  }]);\n\n  return ShuffleItem;\n}();\n\nShuffleItem.Css = {\n  INITIAL: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    visibility: 'visible',\n    willChange: 'transform'\n  },\n  VISIBLE: {\n    before: {\n      opacity: 1,\n      visibility: 'visible'\n    },\n    after: {\n      transitionDelay: ''\n    }\n  },\n  HIDDEN: {\n    before: {\n      opacity: 0\n    },\n    after: {\n      visibility: 'hidden',\n      transitionDelay: ''\n    }\n  }\n};\nShuffleItem.Scale = {\n  VISIBLE: 1,\n  HIDDEN: 0.001\n};\n\nvar value = null;\nvar testComputedSize = (function () {\n  if (value !== null) {\n    return value;\n  }\n\n  var element = document.body || document.documentElement;\n  var e = document.createElement('div');\n  e.style.cssText = 'width:10px;padding:2px;box-sizing:border-box;';\n  element.appendChild(e);\n  value = window.getComputedStyle(e, null).width === '10px';\n  element.removeChild(e);\n  return value;\n});\n\n/**\n * Retrieve the computed style for an element, parsed as a float.\n * @param {Element} element Element to get style for.\n * @param {string} style Style property.\n * @param {CSSStyleDeclaration} [styles] Optionally include clean styles to\n *     use instead of asking for them again.\n * @return {number} The parsed computed value or zero if that fails because IE\n *     will return 'auto' when the element doesn't have margins instead of\n *     the computed style.\n */\n\nfunction getNumberStyle(element, style) {\n  var styles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : window.getComputedStyle(element, null);\n  var value = getNumber(styles[style]); // Support IE<=11 and W3C spec.\n\n  if (!testComputedSize() && style === 'width') {\n    value += getNumber(styles.paddingLeft) + getNumber(styles.paddingRight) + getNumber(styles.borderLeftWidth) + getNumber(styles.borderRightWidth);\n  } else if (!testComputedSize() && style === 'height') {\n    value += getNumber(styles.paddingTop) + getNumber(styles.paddingBottom) + getNumber(styles.borderTopWidth) + getNumber(styles.borderBottomWidth);\n  }\n\n  return value;\n}\n\n/**\n * Fisher-Yates shuffle.\n * http://stackoverflow.com/a/962890/373422\n * https://bost.ocks.org/mike/shuffle/\n * @param {Array} array Array to shuffle.\n * @return {Array} Randomly sorted array.\n */\nfunction randomize(array) {\n  var n = array.length;\n\n  while (n) {\n    n -= 1;\n    var i = Math.floor(Math.random() * (n + 1));\n    var temp = array[i];\n    array[i] = array[n];\n    array[n] = temp;\n  }\n\n  return array;\n}\n\nvar defaults = {\n  // Use array.reverse() to reverse the results\n  reverse: false,\n  // Sorting function\n  by: null,\n  // Custom sort function\n  compare: null,\n  // If true, this will skip the sorting and return a randomized order in the array\n  randomize: false,\n  // Determines which property of each item in the array is passed to the\n  // sorting method.\n  key: 'element'\n};\n/**\n * You can return `undefined` from the `by` function to revert to DOM order.\n * @param {Array<T>} arr Array to sort.\n * @param {SortOptions} options Sorting options.\n * @return {Array<T>}\n */\n\nfunction sorter(arr, options) {\n  var opts = Object.assign({}, defaults, options);\n  var original = Array.from(arr);\n  var revert = false;\n\n  if (!arr.length) {\n    return [];\n  }\n\n  if (opts.randomize) {\n    return randomize(arr);\n  } // Sort the elements by the opts.by function.\n  // If we don't have opts.by, default to DOM order\n\n\n  if (typeof opts.by === 'function') {\n    arr.sort(function (a, b) {\n      // Exit early if we already know we want to revert\n      if (revert) {\n        return 0;\n      }\n\n      var valA = opts.by(a[opts.key]);\n      var valB = opts.by(b[opts.key]); // If both values are undefined, use the DOM order\n\n      if (valA === undefined && valB === undefined) {\n        revert = true;\n        return 0;\n      }\n\n      if (valA < valB || valA === 'sortFirst' || valB === 'sortLast') {\n        return -1;\n      }\n\n      if (valA > valB || valA === 'sortLast' || valB === 'sortFirst') {\n        return 1;\n      }\n\n      return 0;\n    });\n  } else if (typeof opts.compare === 'function') {\n    arr.sort(opts.compare);\n  } // Revert to the original array if necessary\n\n\n  if (revert) {\n    return original;\n  }\n\n  if (opts.reverse) {\n    arr.reverse();\n  }\n\n  return arr;\n}\n\nvar transitions = {};\nvar eventName = 'transitionend';\nvar count = 0;\n\nfunction uniqueId() {\n  count += 1;\n  return eventName + count;\n}\n\nfunction cancelTransitionEnd(id) {\n  if (transitions[id]) {\n    transitions[id].element.removeEventListener(eventName, transitions[id].listener);\n    transitions[id] = null;\n    return true;\n  }\n\n  return false;\n}\nfunction onTransitionEnd(element, callback) {\n  var id = uniqueId();\n\n  var listener = function listener(evt) {\n    if (evt.currentTarget === evt.target) {\n      cancelTransitionEnd(id);\n      callback(evt);\n    }\n  };\n\n  element.addEventListener(eventName, listener);\n  transitions[id] = {\n    element: element,\n    listener: listener\n  };\n  return id;\n}\n\nfunction arrayMax(array) {\n  return Math.max.apply(Math, array); // eslint-disable-line prefer-spread\n}\n\nfunction arrayMin(array) {\n  return Math.min.apply(Math, array); // eslint-disable-line prefer-spread\n}\n\n/**\n * Determine the number of columns an items spans.\n * @param {number} itemWidth Width of the item.\n * @param {number} columnWidth Width of the column (includes gutter).\n * @param {number} columns Total number of columns\n * @param {number} threshold A buffer value for the size of the column to fit.\n * @return {number}\n */\n\nfunction getColumnSpan(itemWidth, columnWidth, columns, threshold) {\n  var columnSpan = itemWidth / columnWidth; // If the difference between the rounded column span number and the\n  // calculated column span number is really small, round the number to\n  // make it fit.\n\n  if (Math.abs(Math.round(columnSpan) - columnSpan) < threshold) {\n    // e.g. columnSpan = 4.0089945390298745\n    columnSpan = Math.round(columnSpan);\n  } // Ensure the column span is not more than the amount of columns in the whole layout.\n\n\n  return Math.min(Math.ceil(columnSpan), columns);\n}\n/**\n * Retrieves the column set to use for placement.\n * @param {number} columnSpan The number of columns this current item spans.\n * @param {number} columns The total columns in the grid.\n * @return {Array.<number>} An array of numbers represeting the column set.\n */\n\nfunction getAvailablePositions(positions, columnSpan, columns) {\n  // The item spans only one column.\n  if (columnSpan === 1) {\n    return positions;\n  } // The item spans more than one column, figure out how many different\n  // places it could fit horizontally.\n  // The group count is the number of places within the positions this block\n  // could fit, ignoring the current positions of items.\n  // Imagine a 2 column brick as the second item in a 4 column grid with\n  // 10px height each. Find the places it would fit:\n  // [20, 10, 10, 0]\n  //  |   |   |\n  //  *   *   *\n  //\n  // Then take the places which fit and get the bigger of the two:\n  // max([20, 10]), max([10, 10]), max([10, 0]) = [20, 10, 10]\n  //\n  // Next, find the first smallest number (the short column).\n  // [20, 10, 10]\n  //      |\n  //      *\n  //\n  // And that's where it should be placed!\n  //\n  // Another example where the second column's item extends past the first:\n  // [10, 20, 10, 0] => [20, 20, 10] => 10\n\n\n  var available = []; // For how many possible positions for this item there are.\n\n  for (var i = 0; i <= columns - columnSpan; i++) {\n    // Find the bigger value for each place it could fit.\n    available.push(arrayMax(positions.slice(i, i + columnSpan)));\n  }\n\n  return available;\n}\n/**\n * Find index of short column, the first from the left where this item will go.\n *\n * @param {Array.<number>} positions The array to search for the smallest number.\n * @param {number} buffer Optional buffer which is very useful when the height\n *     is a percentage of the width.\n * @return {number} Index of the short column.\n */\n\nfunction getShortColumn(positions, buffer) {\n  var minPosition = arrayMin(positions);\n\n  for (var i = 0, len = positions.length; i < len; i++) {\n    if (positions[i] >= minPosition - buffer && positions[i] <= minPosition + buffer) {\n      return i;\n    }\n  }\n\n  return 0;\n}\n/**\n * Determine the location of the next item, based on its size.\n * @param {Object} itemSize Object with width and height.\n * @param {Array.<number>} positions Positions of the other current items.\n * @param {number} gridSize The column width or row height.\n * @param {number} total The total number of columns or rows.\n * @param {number} threshold Buffer value for the column to fit.\n * @param {number} buffer Vertical buffer for the height of items.\n * @return {Point}\n */\n\nfunction getItemPosition(_ref) {\n  var itemSize = _ref.itemSize,\n      positions = _ref.positions,\n      gridSize = _ref.gridSize,\n      total = _ref.total,\n      threshold = _ref.threshold,\n      buffer = _ref.buffer;\n  var span = getColumnSpan(itemSize.width, gridSize, total, threshold);\n  var setY = getAvailablePositions(positions, span, total);\n  var shortColumnIndex = getShortColumn(setY, buffer); // Position the item\n\n  var point = new Point(gridSize * shortColumnIndex, setY[shortColumnIndex]); // Update the columns array with the new values for each column.\n  // e.g. before the update the columns could be [250, 0, 0, 0] for an item\n  // which spans 2 columns. After it would be [250, itemHeight, itemHeight, 0].\n\n  var setHeight = setY[shortColumnIndex] + itemSize.height;\n\n  for (var i = 0; i < span; i++) {\n    positions[shortColumnIndex + i] = setHeight;\n  }\n\n  return point;\n}\n/**\n * This method attempts to center items. This method could potentially be slow\n * with a large number of items because it must place items, then check every\n * previous item to ensure there is no overlap.\n * @param {Array.<Rect>} itemRects Item data objects.\n * @param {number} containerWidth Width of the containing element.\n * @return {Array.<Point>}\n */\n\nfunction getCenteredPositions(itemRects, containerWidth) {\n  var rowMap = {}; // Populate rows by their offset because items could jump between rows like:\n  // a   c\n  //  bbb\n\n  itemRects.forEach(function (itemRect) {\n    if (rowMap[itemRect.top]) {\n      // Push the point to the last row array.\n      rowMap[itemRect.top].push(itemRect);\n    } else {\n      // Start of a new row.\n      rowMap[itemRect.top] = [itemRect];\n    }\n  }); // For each row, find the end of the last item, then calculate\n  // the remaining space by dividing it by 2. Then add that\n  // offset to the x position of each point.\n\n  var rects = [];\n  var rows = [];\n  var centeredRows = [];\n  Object.keys(rowMap).forEach(function (key) {\n    var itemRects = rowMap[key];\n    rows.push(itemRects);\n    var lastItem = itemRects[itemRects.length - 1];\n    var end = lastItem.left + lastItem.width;\n    var offset = Math.round((containerWidth - end) / 2);\n    var finalRects = itemRects;\n    var canMove = false;\n\n    if (offset > 0) {\n      var newRects = [];\n      canMove = itemRects.every(function (r) {\n        var newRect = new Rect(r.left + offset, r.top, r.width, r.height, r.id); // Check all current rects to make sure none overlap.\n\n        var noOverlap = !rects.some(function (r) {\n          return Rect.intersects(newRect, r);\n        });\n        newRects.push(newRect);\n        return noOverlap;\n      }); // If none of the rectangles overlapped, the whole group can be centered.\n\n      if (canMove) {\n        finalRects = newRects;\n      }\n    } // If the items are not going to be offset, ensure that the original\n    // placement for this row will not overlap previous rows (row-spanning\n    // elements could be in the way).\n\n\n    if (!canMove) {\n      var intersectingRect;\n      var hasOverlap = itemRects.some(function (itemRect) {\n        return rects.some(function (r) {\n          var intersects = Rect.intersects(itemRect, r);\n\n          if (intersects) {\n            intersectingRect = r;\n          }\n\n          return intersects;\n        });\n      }); // If there is any overlap, replace the overlapping row with the original.\n\n      if (hasOverlap) {\n        var rowIndex = centeredRows.findIndex(function (items) {\n          return items.includes(intersectingRect);\n        });\n        centeredRows.splice(rowIndex, 1, rows[rowIndex]);\n      }\n    }\n\n    rects = rects.concat(finalRects);\n    centeredRows.push(finalRects);\n  }); // Reduce array of arrays to a single array of points.\n  // https://stackoverflow.com/a/10865042/373422\n  // Then reset sort back to how the items were passed to this method.\n  // Remove the wrapper object with index, map to a Point.\n\n  return [].concat.apply([], centeredRows) // eslint-disable-line prefer-spread\n  .sort(function (a, b) {\n    return a.id - b.id;\n  }).map(function (itemRect) {\n    return new Point(itemRect.left, itemRect.top);\n  });\n}\n\n/**\n * Hyphenates a javascript style string to a css one. For example:\n * MozBoxSizing -> -moz-box-sizing.\n * @param {string} str The string to hyphenate.\n * @return {string} The hyphenated string.\n */\nfunction hyphenate(str) {\n  return str.replace(/([A-Z])/g, function (str, m1) {\n    return \"-\".concat(m1.toLowerCase());\n  });\n}\n\nfunction arrayUnique(x) {\n  return Array.from(new Set(x));\n} // Used for unique instance variables\n\n\nvar id$1 = 0;\n\nvar Shuffle =\n/*#__PURE__*/\nfunction (_TinyEmitter) {\n  _inherits(Shuffle, _TinyEmitter);\n\n  /**\n   * Categorize, sort, and filter a responsive grid of items.\n   *\n   * @param {Element} element An element which is the parent container for the grid items.\n   * @param {Object} [options=Shuffle.options] Options object.\n   * @constructor\n   */\n  function Shuffle(element) {\n    var _this;\n\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n    _classCallCheck(this, Shuffle);\n\n    _this = _possibleConstructorReturn(this, _getPrototypeOf(Shuffle).call(this));\n    _this.options = Object.assign({}, Shuffle.options, options); // Allow misspelling of delimiter since that's how it used to be.\n    // Remove in v6.\n\n    if (_this.options.delimeter) {\n      _this.options.delimiter = _this.options.delimeter;\n    }\n\n    _this.lastSort = {};\n    _this.group = Shuffle.ALL_ITEMS;\n    _this.lastFilter = Shuffle.ALL_ITEMS;\n    _this.isEnabled = true;\n    _this.isDestroyed = false;\n    _this.isInitialized = false;\n    _this._transitions = [];\n    _this.isTransitioning = false;\n    _this._queue = [];\n\n    var el = _this._getElementOption(element);\n\n    if (!el) {\n      throw new TypeError('Shuffle needs to be initialized with an element.');\n    }\n\n    _this.element = el;\n    _this.id = 'shuffle_' + id$1;\n    id$1 += 1;\n\n    _this._init();\n\n    _this.isInitialized = true;\n    return _this;\n  }\n\n  _createClass(Shuffle, [{\n    key: \"_init\",\n    value: function _init() {\n      this.items = this._getItems();\n      this.options.sizer = this._getElementOption(this.options.sizer); // Add class and invalidate styles\n\n      this.element.classList.add(Shuffle.Classes.BASE); // Set initial css for each item\n\n      this._initItems(this.items); // Bind resize events\n\n\n      this._onResize = this._getResizeFunction();\n      window.addEventListener('resize', this._onResize); // If the page has not already emitted the `load` event, call layout on load.\n      // This avoids layout issues caused by images and fonts loading after the\n      // instance has been initialized.\n\n      if (document.readyState !== 'complete') {\n        var layout = this.layout.bind(this);\n        window.addEventListener('load', function onLoad() {\n          window.removeEventListener('load', onLoad);\n          layout();\n        });\n      } // Get container css all in one request. Causes reflow\n\n\n      var containerCss = window.getComputedStyle(this.element, null);\n      var containerWidth = Shuffle.getSize(this.element).width; // Add styles to the container if it doesn't have them.\n\n      this._validateStyles(containerCss); // We already got the container's width above, no need to cause another\n      // reflow getting it again... Calculate the number of columns there will be\n\n\n      this._setColumns(containerWidth); // Kick off!\n\n\n      this.filter(this.options.group, this.options.initialSort); // The shuffle items haven't had transitions set on them yet so the user\n      // doesn't see the first layout. Set them now that the first layout is done.\n      // First, however, a synchronous layout must be caused for the previous\n      // styles to be applied without transitions.\n\n      this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n\n      this.setItemTransitions(this.items);\n      this.element.style.transition = \"height \".concat(this.options.speed, \"ms \").concat(this.options.easing);\n    }\n    /**\n     * Returns a throttled and proxied function for the resize handler.\n     * @return {function}\n     * @private\n     */\n\n  }, {\n    key: \"_getResizeFunction\",\n    value: function _getResizeFunction() {\n      var resizeFunction = this._handleResize.bind(this);\n\n      return this.options.throttle ? this.options.throttle(resizeFunction, this.options.throttleTime) : resizeFunction;\n    }\n    /**\n     * Retrieve an element from an option.\n     * @param {string|jQuery|Element} option The option to check.\n     * @return {?Element} The plain element or null.\n     * @private\n     */\n\n  }, {\n    key: \"_getElementOption\",\n    value: function _getElementOption(option) {\n      // If column width is a string, treat is as a selector and search for the\n      // sizer element within the outermost container\n      if (typeof option === 'string') {\n        return this.element.querySelector(option);\n      } // Check for an element\n\n\n      if (option && option.nodeType && option.nodeType === 1) {\n        return option;\n      } // Check for jQuery object\n\n\n      if (option && option.jquery) {\n        return option[0];\n      }\n\n      return null;\n    }\n    /**\n     * Ensures the shuffle container has the css styles it needs applied to it.\n     * @param {Object} styles Key value pairs for position and overflow.\n     * @private\n     */\n\n  }, {\n    key: \"_validateStyles\",\n    value: function _validateStyles(styles) {\n      // Position cannot be static.\n      if (styles.position === 'static') {\n        this.element.style.position = 'relative';\n      } // Overflow has to be hidden.\n\n\n      if (styles.overflow !== 'hidden') {\n        this.element.style.overflow = 'hidden';\n      }\n    }\n    /**\n     * Filter the elements by a category.\n     * @param {string|string[]|function(Element):boolean} [category] Category to\n     *     filter by. If it's given, the last category will be used to filter the items.\n     * @param {Array} [collection] Optionally filter a collection. Defaults to\n     *     all the items.\n     * @return {{visible: ShuffleItem[], hidden: ShuffleItem[]}}\n     * @private\n     */\n\n  }, {\n    key: \"_filter\",\n    value: function _filter() {\n      var category = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.lastFilter;\n      var collection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.items;\n\n      var set = this._getFilteredSets(category, collection); // Individually add/remove hidden/visible classes\n\n\n      this._toggleFilterClasses(set); // Save the last filter in case elements are appended.\n\n\n      this.lastFilter = category; // This is saved mainly because providing a filter function (like searching)\n      // will overwrite the `lastFilter` property every time its called.\n\n      if (typeof category === 'string') {\n        this.group = category;\n      }\n\n      return set;\n    }\n    /**\n     * Returns an object containing the visible and hidden elements.\n     * @param {string|string[]|function(Element):boolean} category Category or function to filter by.\n     * @param {ShuffleItem[]} items A collection of items to filter.\n     * @return {{visible: ShuffleItem[], hidden: ShuffleItem[]}}\n     * @private\n     */\n\n  }, {\n    key: \"_getFilteredSets\",\n    value: function _getFilteredSets(category, items) {\n      var _this2 = this;\n\n      var visible = [];\n      var hidden = []; // category === 'all', add visible class to everything\n\n      if (category === Shuffle.ALL_ITEMS) {\n        visible = items; // Loop through each item and use provided function to determine\n        // whether to hide it or not.\n      } else {\n        items.forEach(function (item) {\n          if (_this2._doesPassFilter(category, item.element)) {\n            visible.push(item);\n          } else {\n            hidden.push(item);\n          }\n        });\n      }\n\n      return {\n        visible: visible,\n        hidden: hidden\n      };\n    }\n    /**\n     * Test an item to see if it passes a category.\n     * @param {string|string[]|function():boolean} category Category or function to filter by.\n     * @param {Element} element An element to test.\n     * @return {boolean} Whether it passes the category/filter.\n     * @private\n     */\n\n  }, {\n    key: \"_doesPassFilter\",\n    value: function _doesPassFilter(category, element) {\n      if (typeof category === 'function') {\n        return category.call(element, element, this);\n      } // Check each element's data-groups attribute against the given category.\n\n\n      var attr = element.getAttribute('data-' + Shuffle.FILTER_ATTRIBUTE_KEY);\n      var keys = this.options.delimiter ? attr.split(this.options.delimiter) : JSON.parse(attr);\n\n      function testCategory(category) {\n        return keys.includes(category);\n      }\n\n      if (Array.isArray(category)) {\n        if (this.options.filterMode === Shuffle.FilterMode.ANY) {\n          return category.some(testCategory);\n        }\n\n        return category.every(testCategory);\n      }\n\n      return keys.includes(category);\n    }\n    /**\n     * Toggles the visible and hidden class names.\n     * @param {{visible, hidden}} Object with visible and hidden arrays.\n     * @private\n     */\n\n  }, {\n    key: \"_toggleFilterClasses\",\n    value: function _toggleFilterClasses(_ref) {\n      var visible = _ref.visible,\n          hidden = _ref.hidden;\n      visible.forEach(function (item) {\n        item.show();\n      });\n      hidden.forEach(function (item) {\n        item.hide();\n      });\n    }\n    /**\n     * Set the initial css for each item\n     * @param {ShuffleItem[]} items Set to initialize.\n     * @private\n     */\n\n  }, {\n    key: \"_initItems\",\n    value: function _initItems(items) {\n      items.forEach(function (item) {\n        item.init();\n      });\n    }\n    /**\n     * Remove element reference and styles.\n     * @param {ShuffleItem[]} items Set to dispose.\n     * @private\n     */\n\n  }, {\n    key: \"_disposeItems\",\n    value: function _disposeItems(items) {\n      items.forEach(function (item) {\n        item.dispose();\n      });\n    }\n    /**\n     * Updates the visible item count.\n     * @private\n     */\n\n  }, {\n    key: \"_updateItemCount\",\n    value: function _updateItemCount() {\n      this.visibleItems = this._getFilteredItems().length;\n    }\n    /**\n     * Sets css transform transition on a group of elements. This is not executed\n     * at the same time as `item.init` so that transitions don't occur upon\n     * initialization of a new Shuffle instance.\n     * @param {ShuffleItem[]} items Shuffle items to set transitions on.\n     * @protected\n     */\n\n  }, {\n    key: \"setItemTransitions\",\n    value: function setItemTransitions(items) {\n      var _this$options = this.options,\n          speed = _this$options.speed,\n          easing = _this$options.easing;\n      var positionProps = this.options.useTransforms ? ['transform'] : ['top', 'left']; // Allow users to transtion other properties if they exist in the `before`\n      // css mapping of the shuffle item.\n\n      var cssProps = Object.keys(ShuffleItem.Css.HIDDEN.before).map(function (k) {\n        return hyphenate(k);\n      });\n      var properties = positionProps.concat(cssProps).join();\n      items.forEach(function (item) {\n        item.element.style.transitionDuration = speed + 'ms';\n        item.element.style.transitionTimingFunction = easing;\n        item.element.style.transitionProperty = properties;\n      });\n    }\n  }, {\n    key: \"_getItems\",\n    value: function _getItems() {\n      var _this3 = this;\n\n      return Array.from(this.element.children).filter(function (el) {\n        return matchesSelector(el, _this3.options.itemSelector);\n      }).map(function (el) {\n        return new ShuffleItem(el);\n      });\n    }\n    /**\n     * Combine the current items array with a new one and sort it by DOM order.\n     * @param {ShuffleItem[]} items Items to track.\n     * @return {ShuffleItem[]}\n     */\n\n  }, {\n    key: \"_mergeNewItems\",\n    value: function _mergeNewItems(items) {\n      var children = Array.from(this.element.children);\n      return sorter(this.items.concat(items), {\n        by: function by(element) {\n          return children.indexOf(element);\n        }\n      });\n    }\n  }, {\n    key: \"_getFilteredItems\",\n    value: function _getFilteredItems() {\n      return this.items.filter(function (item) {\n        return item.isVisible;\n      });\n    }\n  }, {\n    key: \"_getConcealedItems\",\n    value: function _getConcealedItems() {\n      return this.items.filter(function (item) {\n        return !item.isVisible;\n      });\n    }\n    /**\n     * Returns the column size, based on column width and sizer options.\n     * @param {number} containerWidth Size of the parent container.\n     * @param {number} gutterSize Size of the gutters.\n     * @return {number}\n     * @private\n     */\n\n  }, {\n    key: \"_getColumnSize\",\n    value: function _getColumnSize(containerWidth, gutterSize) {\n      var size; // If the columnWidth property is a function, then the grid is fluid\n\n      if (typeof this.options.columnWidth === 'function') {\n        size = this.options.columnWidth(containerWidth); // columnWidth option isn't a function, are they using a sizing element?\n      } else if (this.options.sizer) {\n        size = Shuffle.getSize(this.options.sizer).width; // if not, how about the explicitly set option?\n      } else if (this.options.columnWidth) {\n        size = this.options.columnWidth; // or use the size of the first item\n      } else if (this.items.length > 0) {\n        size = Shuffle.getSize(this.items[0].element, true).width; // if there's no items, use size of container\n      } else {\n        size = containerWidth;\n      } // Don't let them set a column width of zero.\n\n\n      if (size === 0) {\n        size = containerWidth;\n      }\n\n      return size + gutterSize;\n    }\n    /**\n     * Returns the gutter size, based on gutter width and sizer options.\n     * @param {number} containerWidth Size of the parent container.\n     * @return {number}\n     * @private\n     */\n\n  }, {\n    key: \"_getGutterSize\",\n    value: function _getGutterSize(containerWidth) {\n      var size;\n\n      if (typeof this.options.gutterWidth === 'function') {\n        size = this.options.gutterWidth(containerWidth);\n      } else if (this.options.sizer) {\n        size = getNumberStyle(this.options.sizer, 'marginLeft');\n      } else {\n        size = this.options.gutterWidth;\n      }\n\n      return size;\n    }\n    /**\n     * Calculate the number of columns to be used. Gets css if using sizer element.\n     * @param {number} [containerWidth] Optionally specify a container width if\n     *    it's already available.\n     */\n\n  }, {\n    key: \"_setColumns\",\n    value: function _setColumns() {\n      var containerWidth = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : Shuffle.getSize(this.element).width;\n\n      var gutter = this._getGutterSize(containerWidth);\n\n      var columnWidth = this._getColumnSize(containerWidth, gutter);\n\n      var calculatedColumns = (containerWidth + gutter) / columnWidth; // Widths given from getStyles are not precise enough...\n\n      if (Math.abs(Math.round(calculatedColumns) - calculatedColumns) < this.options.columnThreshold) {\n        // e.g. calculatedColumns = 11.998876\n        calculatedColumns = Math.round(calculatedColumns);\n      }\n\n      this.cols = Math.max(Math.floor(calculatedColumns || 0), 1);\n      this.containerWidth = containerWidth;\n      this.colWidth = columnWidth;\n    }\n    /**\n     * Adjust the height of the grid\n     */\n\n  }, {\n    key: \"_setContainerSize\",\n    value: function _setContainerSize() {\n      this.element.style.height = this._getContainerSize() + 'px';\n    }\n    /**\n     * Based on the column heights, it returns the biggest one.\n     * @return {number}\n     * @private\n     */\n\n  }, {\n    key: \"_getContainerSize\",\n    value: function _getContainerSize() {\n      return arrayMax(this.positions);\n    }\n    /**\n     * Get the clamped stagger amount.\n     * @param {number} index Index of the item to be staggered.\n     * @return {number}\n     */\n\n  }, {\n    key: \"_getStaggerAmount\",\n    value: function _getStaggerAmount(index) {\n      return Math.min(index * this.options.staggerAmount, this.options.staggerAmountMax);\n    }\n    /**\n     * Emit an event from this instance.\n     * @param {string} name Event name.\n     * @param {Object} [data={}] Optional object data.\n     */\n\n  }, {\n    key: \"_dispatch\",\n    value: function _dispatch(name) {\n      var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (this.isDestroyed) {\n        return;\n      }\n\n      data.shuffle = this;\n      this.emit(name, data);\n    }\n    /**\n     * Zeros out the y columns array, which is used to determine item placement.\n     * @private\n     */\n\n  }, {\n    key: \"_resetCols\",\n    value: function _resetCols() {\n      var i = this.cols;\n      this.positions = [];\n\n      while (i) {\n        i -= 1;\n        this.positions.push(0);\n      }\n    }\n    /**\n     * Loops through each item that should be shown and calculates the x, y position.\n     * @param {ShuffleItem[]} items Array of items that will be shown/layed\n     *     out in order in their array.\n     */\n\n  }, {\n    key: \"_layout\",\n    value: function _layout(items) {\n      var _this4 = this;\n\n      var itemPositions = this._getNextPositions(items);\n\n      var count = 0;\n      items.forEach(function (item, i) {\n        function callback() {\n          item.applyCss(ShuffleItem.Css.VISIBLE.after);\n        } // If the item will not change its position, do not add it to the render\n        // queue. Transitions don't fire when setting a property to the same value.\n\n\n        if (Point.equals(item.point, itemPositions[i]) && !item.isHidden) {\n          item.applyCss(ShuffleItem.Css.VISIBLE.before);\n          callback();\n          return;\n        }\n\n        item.point = itemPositions[i];\n        item.scale = ShuffleItem.Scale.VISIBLE;\n        item.isHidden = false; // Clone the object so that the `before` object isn't modified when the\n        // transition delay is added.\n\n        var styles = _this4.getStylesForTransition(item, ShuffleItem.Css.VISIBLE.before);\n\n        styles.transitionDelay = _this4._getStaggerAmount(count) + 'ms';\n\n        _this4._queue.push({\n          item: item,\n          styles: styles,\n          callback: callback\n        });\n\n        count += 1;\n      });\n    }\n    /**\n     * Return an array of Point instances representing the future positions of\n     * each item.\n     * @param {ShuffleItem[]} items Array of sorted shuffle items.\n     * @return {Point[]}\n     * @private\n     */\n\n  }, {\n    key: \"_getNextPositions\",\n    value: function _getNextPositions(items) {\n      var _this5 = this;\n\n      // If position data is going to be changed, add the item's size to the\n      // transformer to allow for calculations.\n      if (this.options.isCentered) {\n        var itemsData = items.map(function (item, i) {\n          var itemSize = Shuffle.getSize(item.element, true);\n\n          var point = _this5._getItemPosition(itemSize);\n\n          return new Rect(point.x, point.y, itemSize.width, itemSize.height, i);\n        });\n        return this.getTransformedPositions(itemsData, this.containerWidth);\n      } // If no transforms are going to happen, simply return an array of the\n      // future points of each item.\n\n\n      return items.map(function (item) {\n        return _this5._getItemPosition(Shuffle.getSize(item.element, true));\n      });\n    }\n    /**\n     * Determine the location of the next item, based on its size.\n     * @param {{width: number, height: number}} itemSize Object with width and height.\n     * @return {Point}\n     * @private\n     */\n\n  }, {\n    key: \"_getItemPosition\",\n    value: function _getItemPosition(itemSize) {\n      return getItemPosition({\n        itemSize: itemSize,\n        positions: this.positions,\n        gridSize: this.colWidth,\n        total: this.cols,\n        threshold: this.options.columnThreshold,\n        buffer: this.options.buffer\n      });\n    }\n    /**\n     * Mutate positions before they're applied.\n     * @param {Rect[]} itemRects Item data objects.\n     * @param {number} containerWidth Width of the containing element.\n     * @return {Point[]}\n     * @protected\n     */\n\n  }, {\n    key: \"getTransformedPositions\",\n    value: function getTransformedPositions(itemRects, containerWidth) {\n      return getCenteredPositions(itemRects, containerWidth);\n    }\n    /**\n     * Hides the elements that don't match our filter.\n     * @param {ShuffleItem[]} collection Collection to shrink.\n     * @private\n     */\n\n  }, {\n    key: \"_shrink\",\n    value: function _shrink() {\n      var _this6 = this;\n\n      var collection = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._getConcealedItems();\n      var count = 0;\n      collection.forEach(function (item) {\n        function callback() {\n          item.applyCss(ShuffleItem.Css.HIDDEN.after);\n        } // Continuing would add a transitionend event listener to the element, but\n        // that listener would not execute because the transform and opacity would\n        // stay the same.\n        // The callback is executed here because it is not guaranteed to be called\n        // after the transitionend event because the transitionend could be\n        // canceled if another animation starts.\n\n\n        if (item.isHidden) {\n          item.applyCss(ShuffleItem.Css.HIDDEN.before);\n          callback();\n          return;\n        }\n\n        item.scale = ShuffleItem.Scale.HIDDEN;\n        item.isHidden = true;\n\n        var styles = _this6.getStylesForTransition(item, ShuffleItem.Css.HIDDEN.before);\n\n        styles.transitionDelay = _this6._getStaggerAmount(count) + 'ms';\n\n        _this6._queue.push({\n          item: item,\n          styles: styles,\n          callback: callback\n        });\n\n        count += 1;\n      });\n    }\n    /**\n     * Resize handler.\n     * @private\n     */\n\n  }, {\n    key: \"_handleResize\",\n    value: function _handleResize() {\n      // If shuffle is disabled, destroyed, don't do anything\n      if (!this.isEnabled || this.isDestroyed) {\n        return;\n      }\n\n      this.update();\n    }\n    /**\n     * Returns styles which will be applied to the an item for a transition.\n     * @param {ShuffleItem} item Item to get styles for. Should have updated\n     *   scale and point properties.\n     * @param {Object} styleObject Extra styles that will be used in the transition.\n     * @return {!Object} Transforms for transitions, left/top for animate.\n     * @protected\n     */\n\n  }, {\n    key: \"getStylesForTransition\",\n    value: function getStylesForTransition(item, styleObject) {\n      // Clone the object to avoid mutating the original.\n      var styles = Object.assign({}, styleObject);\n\n      if (this.options.useTransforms) {\n        var x = this.options.roundTransforms ? Math.round(item.point.x) : item.point.x;\n        var y = this.options.roundTransforms ? Math.round(item.point.y) : item.point.y;\n        styles.transform = \"translate(\".concat(x, \"px, \").concat(y, \"px) scale(\").concat(item.scale, \")\");\n      } else {\n        styles.left = item.point.x + 'px';\n        styles.top = item.point.y + 'px';\n      }\n\n      return styles;\n    }\n    /**\n     * Listen for the transition end on an element and execute the itemCallback\n     * when it finishes.\n     * @param {Element} element Element to listen on.\n     * @param {function} itemCallback Callback for the item.\n     * @param {function} done Callback to notify `parallel` that this one is done.\n     */\n\n  }, {\n    key: \"_whenTransitionDone\",\n    value: function _whenTransitionDone(element, itemCallback, done) {\n      var id = onTransitionEnd(element, function (evt) {\n        itemCallback();\n        done(null, evt);\n      });\n\n      this._transitions.push(id);\n    }\n    /**\n     * Return a function which will set CSS styles and call the `done` function\n     * when (if) the transition finishes.\n     * @param {Object} opts Transition object.\n     * @return {function} A function to be called with a `done` function.\n     */\n\n  }, {\n    key: \"_getTransitionFunction\",\n    value: function _getTransitionFunction(opts) {\n      var _this7 = this;\n\n      return function (done) {\n        opts.item.applyCss(opts.styles);\n\n        _this7._whenTransitionDone(opts.item.element, opts.callback, done);\n      };\n    }\n    /**\n     * Execute the styles gathered in the style queue. This applies styles to elements,\n     * triggering transitions.\n     * @private\n     */\n\n  }, {\n    key: \"_processQueue\",\n    value: function _processQueue() {\n      if (this.isTransitioning) {\n        this._cancelMovement();\n      }\n\n      var hasSpeed = this.options.speed > 0;\n      var hasQueue = this._queue.length > 0;\n\n      if (hasQueue && hasSpeed && this.isInitialized) {\n        this._startTransitions(this._queue);\n      } else if (hasQueue) {\n        this._styleImmediately(this._queue);\n\n        this._dispatch(Shuffle.EventType.LAYOUT); // A call to layout happened, but none of the newly visible items will\n        // change position or the transition duration is zero, which will not trigger\n        // the transitionend event.\n\n      } else {\n        this._dispatch(Shuffle.EventType.LAYOUT);\n      } // Remove everything in the style queue\n\n\n      this._queue.length = 0;\n    }\n    /**\n     * Wait for each transition to finish, the emit the layout event.\n     * @param {Object[]} transitions Array of transition objects.\n     */\n\n  }, {\n    key: \"_startTransitions\",\n    value: function _startTransitions(transitions) {\n      var _this8 = this;\n\n      // Set flag that shuffle is currently in motion.\n      this.isTransitioning = true; // Create an array of functions to be called.\n\n      var callbacks = transitions.map(function (obj) {\n        return _this8._getTransitionFunction(obj);\n      });\n      arrayParallel(callbacks, this._movementFinished.bind(this));\n    }\n  }, {\n    key: \"_cancelMovement\",\n    value: function _cancelMovement() {\n      // Remove the transition end event for each listener.\n      this._transitions.forEach(cancelTransitionEnd); // Reset the array.\n\n\n      this._transitions.length = 0; // Show it's no longer active.\n\n      this.isTransitioning = false;\n    }\n    /**\n     * Apply styles without a transition.\n     * @param {Object[]} objects Array of transition objects.\n     * @private\n     */\n\n  }, {\n    key: \"_styleImmediately\",\n    value: function _styleImmediately(objects) {\n      if (objects.length) {\n        var elements = objects.map(function (obj) {\n          return obj.item.element;\n        });\n\n        Shuffle._skipTransitions(elements, function () {\n          objects.forEach(function (obj) {\n            obj.item.applyCss(obj.styles);\n            obj.callback();\n          });\n        });\n      }\n    }\n  }, {\n    key: \"_movementFinished\",\n    value: function _movementFinished() {\n      this._transitions.length = 0;\n      this.isTransitioning = false;\n\n      this._dispatch(Shuffle.EventType.LAYOUT);\n    }\n    /**\n     * The magic. This is what makes the plugin 'shuffle'\n     * @param {string|string[]|function(Element):boolean} [category] Category to filter by.\n     *     Can be a function, string, or array of strings.\n     * @param {SortOptions} [sortOptions] A sort object which can sort the visible set\n     */\n\n  }, {\n    key: \"filter\",\n    value: function filter(category, sortOptions) {\n      if (!this.isEnabled) {\n        return;\n      }\n\n      if (!category || category && category.length === 0) {\n        category = Shuffle.ALL_ITEMS; // eslint-disable-line no-param-reassign\n      }\n\n      this._filter(category); // Shrink each hidden item\n\n\n      this._shrink(); // How many visible elements?\n\n\n      this._updateItemCount(); // Update transforms on visible elements so they will animate to their new positions.\n\n\n      this.sort(sortOptions);\n    }\n    /**\n     * Gets the visible elements, sorts them, and passes them to layout.\n     * @param {SortOptions} [sortOptions] The options object to pass to `sorter`.\n     */\n\n  }, {\n    key: \"sort\",\n    value: function sort() {\n      var sortOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.lastSort;\n\n      if (!this.isEnabled) {\n        return;\n      }\n\n      this._resetCols();\n\n      var items = sorter(this._getFilteredItems(), sortOptions);\n\n      this._layout(items); // `_layout` always happens after `_shrink`, so it's safe to process the style\n      // queue here with styles from the shrink method.\n\n\n      this._processQueue(); // Adjust the height of the container.\n\n\n      this._setContainerSize();\n\n      this.lastSort = sortOptions;\n    }\n    /**\n     * Reposition everything.\n     * @param {boolean} [isOnlyLayout=false] If true, column and gutter widths won't be recalculated.\n     */\n\n  }, {\n    key: \"update\",\n    value: function update() {\n      var isOnlyLayout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n      if (this.isEnabled) {\n        if (!isOnlyLayout) {\n          // Get updated colCount\n          this._setColumns();\n        } // Layout items\n\n\n        this.sort();\n      }\n    }\n    /**\n     * Use this instead of `update()` if you don't need the columns and gutters updated\n     * Maybe an image inside `shuffle` loaded (and now has a height), which means calculations\n     * could be off.\n     */\n\n  }, {\n    key: \"layout\",\n    value: function layout() {\n      this.update(true);\n    }\n    /**\n     * New items have been appended to shuffle. Mix them in with the current\n     * filter or sort status.\n     * @param {Element[]} newItems Collection of new items.\n     */\n\n  }, {\n    key: \"add\",\n    value: function add(newItems) {\n      var _this9 = this;\n\n      var items = arrayUnique(newItems).map(function (el) {\n        return new ShuffleItem(el);\n      }); // Add classes and set initial positions.\n\n      this._initItems(items); // Determine which items will go with the current filter.\n\n\n      this._resetCols();\n\n      var allItems = this._mergeNewItems(items);\n\n      var sortedItems = sorter(allItems, this.lastSort);\n\n      var allSortedItemsSet = this._filter(this.lastFilter, sortedItems);\n\n      var isNewItem = function isNewItem(item) {\n        return items.includes(item);\n      };\n\n      var applyHiddenState = function applyHiddenState(item) {\n        item.scale = ShuffleItem.Scale.HIDDEN;\n        item.isHidden = true;\n        item.applyCss(ShuffleItem.Css.HIDDEN.before);\n        item.applyCss(ShuffleItem.Css.HIDDEN.after);\n      }; // Layout all items again so that new items get positions.\n      // Synchonously apply positions.\n\n\n      var itemPositions = this._getNextPositions(allSortedItemsSet.visible);\n\n      allSortedItemsSet.visible.forEach(function (item, i) {\n        if (isNewItem(item)) {\n          item.point = itemPositions[i];\n          applyHiddenState(item);\n          item.applyCss(_this9.getStylesForTransition(item, {}));\n        }\n      });\n      allSortedItemsSet.hidden.forEach(function (item) {\n        if (isNewItem(item)) {\n          applyHiddenState(item);\n        }\n      }); // Cause layout so that the styles above are applied.\n\n      this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n      // Add transition to each item.\n\n      this.setItemTransitions(items); // Update the list of items.\n\n      this.items = this._mergeNewItems(items); // Update layout/visibility of new and old items.\n\n      this.filter(this.lastFilter);\n    }\n    /**\n     * Disables shuffle from updating dimensions and layout on resize\n     */\n\n  }, {\n    key: \"disable\",\n    value: function disable() {\n      this.isEnabled = false;\n    }\n    /**\n     * Enables shuffle again\n     * @param {boolean} [isUpdateLayout=true] if undefined, shuffle will update columns and gutters\n     */\n\n  }, {\n    key: \"enable\",\n    value: function enable() {\n      var isUpdateLayout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n      this.isEnabled = true;\n\n      if (isUpdateLayout) {\n        this.update();\n      }\n    }\n    /**\n     * Remove 1 or more shuffle items.\n     * @param {Element[]} elements An array containing one or more\n     *     elements in shuffle\n     * @return {Shuffle} The shuffle instance.\n     */\n\n  }, {\n    key: \"remove\",\n    value: function remove(elements) {\n      var _this10 = this;\n\n      if (!elements.length) {\n        return;\n      }\n\n      var collection = arrayUnique(elements);\n      var oldItems = collection.map(function (element) {\n        return _this10.getItemByElement(element);\n      }).filter(function (item) {\n        return !!item;\n      });\n\n      var handleLayout = function handleLayout() {\n        _this10._disposeItems(oldItems); // Remove the collection in the callback\n\n\n        collection.forEach(function (element) {\n          element.parentNode.removeChild(element);\n        });\n\n        _this10._dispatch(Shuffle.EventType.REMOVED, {\n          collection: collection\n        });\n      }; // Hide collection first.\n\n\n      this._toggleFilterClasses({\n        visible: [],\n        hidden: oldItems\n      });\n\n      this._shrink(oldItems);\n\n      this.sort(); // Update the list of items here because `remove` could be called again\n      // with an item that is in the process of being removed.\n\n      this.items = this.items.filter(function (item) {\n        return !oldItems.includes(item);\n      });\n\n      this._updateItemCount();\n\n      this.once(Shuffle.EventType.LAYOUT, handleLayout);\n    }\n    /**\n     * Retrieve a shuffle item by its element.\n     * @param {Element} element Element to look for.\n     * @return {?ShuffleItem} A shuffle item or undefined if it's not found.\n     */\n\n  }, {\n    key: \"getItemByElement\",\n    value: function getItemByElement(element) {\n      return this.items.find(function (item) {\n        return item.element === element;\n      });\n    }\n    /**\n     * Dump the elements currently stored and reinitialize all child elements which\n     * match the `itemSelector`.\n     */\n\n  }, {\n    key: \"resetItems\",\n    value: function resetItems() {\n      var _this11 = this;\n\n      // Remove refs to current items.\n      this._disposeItems(this.items);\n\n      this.isInitialized = false; // Find new items in the DOM.\n\n      this.items = this._getItems(); // Set initial styles on the new items.\n\n      this._initItems(this.items);\n\n      this.once(Shuffle.EventType.LAYOUT, function () {\n        // Add transition to each item.\n        _this11.setItemTransitions(_this11.items);\n\n        _this11.isInitialized = true;\n      }); // Lay out all items.\n\n      this.filter(this.lastFilter);\n    }\n    /**\n     * Destroys shuffle, removes events, styles, and classes\n     */\n\n  }, {\n    key: \"destroy\",\n    value: function destroy() {\n      this._cancelMovement();\n\n      window.removeEventListener('resize', this._onResize); // Reset container styles\n\n      this.element.classList.remove('shuffle');\n      this.element.removeAttribute('style'); // Reset individual item styles\n\n      this._disposeItems(this.items);\n\n      this.items.length = 0;\n      this._transitions.length = 0; // Null DOM references\n\n      this.options.sizer = null;\n      this.element = null; // Set a flag so if a debounced resize has been triggered,\n      // it can first check if it is actually isDestroyed and not doing anything\n\n      this.isDestroyed = true;\n      this.isEnabled = false;\n    }\n    /**\n     * Returns the outer width of an element, optionally including its margins.\n     *\n     * There are a few different methods for getting the width of an element, none of\n     * which work perfectly for all Shuffle's use cases.\n     *\n     * 1. getBoundingClientRect() `left` and `right` properties.\n     *   - Accounts for transform scaled elements, making it useless for Shuffle\n     *   elements which have shrunk.\n     * 2. The `offsetWidth` property.\n     *   - This value stays the same regardless of the elements transform property,\n     *   however, it does not return subpixel values.\n     * 3. getComputedStyle()\n     *   - This works great Chrome, Firefox, Safari, but IE<=11 does not include\n     *   padding and border when box-sizing: border-box is set, requiring a feature\n     *   test and extra work to add the padding back for IE and other browsers which\n     *   follow the W3C spec here.\n     *\n     * @param {Element} element The element.\n     * @param {boolean} [includeMargins=false] Whether to include margins.\n     * @return {{width: number, height: number}} The width and height.\n     */\n\n  }], [{\n    key: \"getSize\",\n    value: function getSize(element) {\n      var includeMargins = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      // Store the styles so that they can be used by others without asking for it again.\n      var styles = window.getComputedStyle(element, null);\n      var width = getNumberStyle(element, 'width', styles);\n      var height = getNumberStyle(element, 'height', styles);\n\n      if (includeMargins) {\n        var marginLeft = getNumberStyle(element, 'marginLeft', styles);\n        var marginRight = getNumberStyle(element, 'marginRight', styles);\n        var marginTop = getNumberStyle(element, 'marginTop', styles);\n        var marginBottom = getNumberStyle(element, 'marginBottom', styles);\n        width += marginLeft + marginRight;\n        height += marginTop + marginBottom;\n      }\n\n      return {\n        width: width,\n        height: height\n      };\n    }\n    /**\n     * Change a property or execute a function which will not have a transition\n     * @param {Element[]} elements DOM elements that won't be transitioned.\n     * @param {function} callback A function which will be called while transition\n     *     is set to 0ms.\n     * @private\n     */\n\n  }, {\n    key: \"_skipTransitions\",\n    value: function _skipTransitions(elements, callback) {\n      var zero = '0ms'; // Save current duration and delay.\n\n      var data = elements.map(function (element) {\n        var style = element.style;\n        var duration = style.transitionDuration;\n        var delay = style.transitionDelay; // Set the duration to zero so it happens immediately\n\n        style.transitionDuration = zero;\n        style.transitionDelay = zero;\n        return {\n          duration: duration,\n          delay: delay\n        };\n      });\n      callback(); // Cause forced synchronous layout.\n\n      elements[0].offsetWidth; // eslint-disable-line no-unused-expressions\n      // Put the duration back\n\n      elements.forEach(function (element, i) {\n        element.style.transitionDuration = data[i].duration;\n        element.style.transitionDelay = data[i].delay;\n      });\n    }\n  }]);\n\n  return Shuffle;\n}(tinyEmitter);\n\nShuffle.ShuffleItem = ShuffleItem;\nShuffle.ALL_ITEMS = 'all';\nShuffle.FILTER_ATTRIBUTE_KEY = 'groups';\n/** @enum {string} */\n\nShuffle.EventType = {\n  LAYOUT: 'shuffle:layout',\n  REMOVED: 'shuffle:removed'\n};\n/** @enum {string} */\n\nShuffle.Classes = Classes;\n/** @enum {string} */\n\nShuffle.FilterMode = {\n  ANY: 'any',\n  ALL: 'all'\n}; // Overrideable options\n\nShuffle.options = {\n  // Initial filter group.\n  group: Shuffle.ALL_ITEMS,\n  // Transition/animation speed (milliseconds).\n  speed: 250,\n  // CSS easing function to use.\n  easing: 'cubic-bezier(0.4, 0.0, 0.2, 1)',\n  // e.g. '.picture-item'.\n  itemSelector: '*',\n  // Element or selector string. Use an element to determine the size of columns\n  // and gutters.\n  sizer: null,\n  // A static number or function that tells the plugin how wide the gutters\n  // between columns are (in pixels).\n  gutterWidth: 0,\n  // A static number or function that returns a number which tells the plugin\n  // how wide the columns are (in pixels).\n  columnWidth: 0,\n  // If your group is not json, and is comma delimeted, you could set delimiter\n  // to ','.\n  delimiter: null,\n  // Useful for percentage based heights when they might not always be exactly\n  // the same (in pixels).\n  buffer: 0,\n  // Reading the width of elements isn't precise enough and can cause columns to\n  // jump between values.\n  columnThreshold: 0.01,\n  // Shuffle can be isInitialized with a sort object. It is the same object\n  // given to the sort method.\n  initialSort: null,\n  // By default, shuffle will throttle resize events. This can be changed or\n  // removed.\n  throttle: throttleit,\n  // How often shuffle can be called on resize (in milliseconds).\n  throttleTime: 300,\n  // Transition delay offset for each item in milliseconds.\n  staggerAmount: 15,\n  // Maximum stagger delay in milliseconds.\n  staggerAmountMax: 150,\n  // Whether to use transforms or absolute positioning.\n  useTransforms: true,\n  // Affects using an array with filter. e.g. `filter(['one', 'two'])`. With \"any\",\n  // the element passes the test if any of its groups are in the array. With \"all\",\n  // the element only passes if all groups are in the array.\n  filterMode: Shuffle.FilterMode.ANY,\n  // Attempt to center grid items in each row.\n  isCentered: false,\n  // Whether to round pixel values used in translate(x, y). This usually avoids\n  // blurriness.\n  roundTransforms: true\n};\nShuffle.Point = Point;\nShuffle.Rect = Rect; // Expose for testing. Hack at your own risk.\n\nShuffle.__sorter = sorter;\nShuffle.__getColumnSpan = getColumnSpan;\nShuffle.__getAvailablePositions = getAvailablePositions;\nShuffle.__getShortColumn = getShortColumn;\nShuffle.__getCenteredPositions = getCenteredPositions;\n\nexport default Shuffle;\n//# sourceMappingURL=shuffle.esm.js.map\n"],"sourceRoot":""}