{"version":3,"file":"Forsvaret.58.304a1b16d21b6c8ef943.chunk.js","mappings":"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","sources":["webpack://Forsvaret/./node_modules/decode-uri-component/index.js","webpack://Forsvaret/./node_modules/query-string/index.js","webpack://Forsvaret/./node_modules/shufflejs/dist/shuffle.esm.js","webpack://Forsvaret/./node_modules/split-on-first/index.js","webpack://Forsvaret/./node_modules/strict-uri-encode/index.js","webpack://Forsvaret/./node_modules/core-js/modules/es6.array.find-index.js","webpack://Forsvaret/./node_modules/core-js/modules/es6.number.is-nan.js"],"sourcesContent":["'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp('(' + token + ')|([^%]+?)', 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn [decodeURIComponent(components.join(''))];\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher) || [];\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher) || [];\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\t\t\t\tif (value === undefined) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (value === undefined) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\t\treturn key => (result, value, index) => {\n\t\t\t\tif (value === null || value === undefined || value.length === 0) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (index === 0) {\n\t\t\t\t\treturn [[encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(',')];\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (value === undefined) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.split('').indexOf(',') > -1;\n\t\t\t\tconst newValue = isArray ? value.split(',') : value;\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(input, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof input !== 'string') {\n\t\treturn ret;\n\t}\n\n\tinput = input.trim().replace(/^[?#&]/, '');\n\n\tif (!input) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of input.split('&')) {\n\t\tlet [key, value] = splitOnFirst(param.replace(/\\+/g, ' '), '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none'\n\t}, options);\n\n\tconst formatter = encoderForArrayFormat(options);\n\tconst keys = Object.keys(object);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (input, options) => {\n\treturn {\n\t\turl: removeHash(input).split('?')[0] || '',\n\t\tquery: parse(extract(input), options)\n\t};\n};\n","function 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;\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 classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function 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\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\nvar inherits = function (subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      enumerable: false,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar possibleConstructorReturn = function (self, call) {\n  if (!self) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n};\n\nvar Point = function () {\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  /**\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  return Point;\n}();\n\nvar Rect = function () {\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\n    /** @type {number} */\n    this.left = x;\n\n    /** @type {number} */\n    this.top = y;\n\n    /** @type {number} */\n    this.width = w;\n\n    /** @type {number} */\n    this.height = h;\n  }\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  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 = function () {\n  function ShuffleItem(element) {\n    classCallCheck(this, ShuffleItem);\n\n    id += 1;\n    this.id = id;\n    this.element = element;\n\n    /**\n     * Used to separate items for layout and shrink.\n     */\n    this.isVisible = true;\n\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    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\n      this.element.removeAttribute('style');\n      this.element = null;\n    }\n  }]);\n  return ShuffleItem;\n}();\n\nShuffleItem.Css = {\n  INITIAL: {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    visibility: 'visible',\n    'will-change': '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};\n\nShuffleItem.Scale = {\n  VISIBLE: 1,\n  HIDDEN: 0.001\n};\n\nvar element = document.body || document.documentElement;\nvar e = document.createElement('div');\ne.style.cssText = 'width:10px;padding:2px;box-sizing:border-box;';\nelement.appendChild(e);\n\nvar _window$getComputedSt = window.getComputedStyle(e, null),\n    width = _window$getComputedSt.width;\n\nvar ret = width === '10px';\n\nelement.removeChild(e);\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 */\nfunction getNumberStyle(element, style) {\n  var styles = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : window.getComputedStyle(element, null);\n\n  var value = getNumber(styles[style]);\n\n  // Support IE<=11 and W3C spec.\n  if (!ret && style === 'width') {\n    value += getNumber(styles.paddingLeft) + getNumber(styles.paddingRight) + getNumber(styles.borderLeftWidth) + getNumber(styles.borderRightWidth);\n  } else if (!ret && 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$1 = {\n  // Use array.reverse() to reverse the results\n  reverse: false,\n\n  // Sorting function\n  by: null,\n\n  // Custom sort function\n  compare: null,\n\n  // If true, this will skip the sorting and return a randomized order in the array\n  randomize: false,\n\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.\nfunction sorter(arr, options) {\n  var opts = Object.assign({}, defaults$1, 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  }\n\n  // Sort the elements by the opts.by function.\n  // If we don't have opts.by, default to DOM order\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]);\n\n      // If both values are undefined, use the DOM order\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  }\n\n  // Revert to the original array if necessary\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}\n\nfunction onTransitionEnd(element, callback) {\n  var id = uniqueId();\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\n  transitions[id] = { element: element, 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 */\nfunction getColumnSpan(itemWidth, columnWidth, columns, threshold) {\n  var columnSpan = itemWidth / columnWidth;\n\n  // 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  if (Math.abs(Math.round(columnSpan) - columnSpan) < threshold) {\n    // e.g. columnSpan = 4.0089945390298745\n    columnSpan = Math.round(columnSpan);\n  }\n\n  // Ensure the column span is not more than the amount of columns in the whole layout.\n  return Math.min(Math.ceil(columnSpan), columns);\n}\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 */\nfunction getAvailablePositions(positions, columnSpan, columns) {\n  // The item spans only one column.\n  if (columnSpan === 1) {\n    return positions;\n  }\n\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  var available = [];\n\n  // For how many possible positions for this item there are.\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/**\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 */\nfunction getShortColumn(positions, buffer) {\n  var minPosition = arrayMin(positions);\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/**\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 */\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\n  var span = getColumnSpan(itemSize.width, gridSize, total, threshold);\n  var setY = getAvailablePositions(positions, span, total);\n  var shortColumnIndex = getShortColumn(setY, buffer);\n\n  // Position the item\n  var point = new Point(gridSize * shortColumnIndex, setY[shortColumnIndex]);\n\n  // 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  var setHeight = setY[shortColumnIndex] + itemSize.height;\n  for (var i = 0; i < span; i++) {\n    positions[shortColumnIndex + i] = setHeight;\n  }\n\n  return point;\n}\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 */\nfunction getCenteredPositions(itemRects, containerWidth) {\n  var rowMap = {};\n\n  // Populate rows by their offset because items could jump between rows like:\n  // a   c\n  //  bbb\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  });\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  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\n    var finalRects = itemRects;\n    var canMove = false;\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);\n\n        // Check all current rects to make sure none overlap.\n        var noOverlap = !rects.some(function (r) {\n          return Rect.intersects(newRect, r);\n        });\n\n        newRects.push(newRect);\n        return noOverlap;\n      });\n\n      // If none of the rectangles overlapped, the whole group can be centered.\n      if (canMove) {\n        finalRects = newRects;\n      }\n    }\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    if (!canMove) {\n      var intersectingRect = void 0;\n      var hasOverlap = itemRects.some(function (itemRect) {\n        return rects.some(function (r) {\n          var intersects = Rect.intersects(itemRect, r);\n          if (intersects) {\n            intersectingRect = r;\n          }\n          return intersects;\n        });\n      });\n\n      // If there is any overlap, replace the overlapping row with the original.\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  });\n\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  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 \"-\" + m1.toLowerCase();\n  });\n}\n\nfunction arrayUnique(x) {\n  return Array.from(new Set(x));\n}\n\n// Used for unique instance variables\nvar id$1 = 0;\n\nvar Shuffle = function (_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 options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    classCallCheck(this, Shuffle);\n\n    var _this = possibleConstructorReturn(this, (Shuffle.__proto__ || Object.getPrototypeOf(Shuffle)).call(this));\n\n    _this.options = Object.assign({}, Shuffle.options, options);\n\n    // Allow misspelling of delimiter since that's how it used to be.\n    // Remove in v6.\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    _this.isInitialized = true;\n    return _this;\n  }\n\n  createClass(Shuffle, [{\n    key: '_init',\n    value: function _init() {\n      this.items = this._getItems();\n\n      this.options.sizer = this._getElementOption(this.options.sizer);\n\n      // Add class and invalidate styles\n      this.element.classList.add(Shuffle.Classes.BASE);\n\n      // Set initial css for each item\n      this._initItems(this.items);\n\n      // Bind resize events\n      this._onResize = this._getResizeFunction();\n      window.addEventListener('resize', this._onResize);\n\n      // 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      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      }\n\n      // Get container css all in one request. Causes reflow\n      var containerCss = window.getComputedStyle(this.element, null);\n      var containerWidth = Shuffle.getSize(this.element).width;\n\n      // Add styles to the container if it doesn't have them.\n      this._validateStyles(containerCss);\n\n      // 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      this._setColumns(containerWidth);\n\n      // Kick off!\n      this.filter(this.options.group, this.options.initialSort);\n\n      // 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      this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n      this.setItemTransitions(this.items);\n      this.element.style.transition = 'height ' + this.options.speed + 'ms ' + this.options.easing;\n    }\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      return this.options.throttle ? this.options.throttle(resizeFunction, this.options.throttleTime) : resizeFunction;\n    }\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\n        // Check for an element\n      } else if (option && option.nodeType && option.nodeType === 1) {\n        return option;\n\n        // Check for jQuery object\n      } else if (option && option.jquery) {\n        return option[0];\n      }\n\n      return null;\n    }\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      }\n\n      // Overflow has to be hidden.\n      if (styles.overflow !== 'hidden') {\n        this.element.style.overflow = 'hidden';\n      }\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$$1 = this._getFilteredSets(category, collection);\n\n      // Individually add/remove hidden/visible classes\n      this._toggleFilterClasses(set$$1);\n\n      // Save the last filter in case elements are appended.\n      this.lastFilter = category;\n\n      // This is saved mainly because providing a filter function (like searching)\n      // will overwrite the `lastFilter` property every time its called.\n      if (typeof category === 'string') {\n        this.group = category;\n      }\n\n      return set$$1;\n    }\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 = [];\n\n      // category === 'all', add visible class to everything\n      if (category === Shuffle.ALL_ITEMS) {\n        visible = items;\n\n        // 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    /**\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      }\n\n      // Check each element's data-groups attribute against the given category.\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        return category.every(testCategory);\n      }\n\n      return keys.includes(category);\n    }\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\n      visible.forEach(function (item) {\n        item.show();\n      });\n\n      hidden.forEach(function (item) {\n        item.hide();\n      });\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    /**\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    /**\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    /**\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 _options = this.options,\n          speed = _options.speed,\n          easing = _options.easing;\n\n      var positionProps = this.options.useTransforms ? ['transform'] : ['top', 'left'];\n\n      // Allow users to transtion other properties if they exist in the `before`\n      // css mapping of the shuffle item.\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\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    /**\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    /**\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 = void 0;\n\n      // If the columnWidth property is a function, then the grid is fluid\n      if (typeof this.options.columnWidth === 'function') {\n        size = this.options.columnWidth(containerWidth);\n\n        // 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;\n\n        // if not, how about the explicitly set option?\n      } else if (this.options.columnWidth) {\n        size = this.options.columnWidth;\n\n        // 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;\n\n        // if there's no items, use size of container\n      } else {\n        size = containerWidth;\n      }\n\n      // Don't let them set a column width of zero.\n      if (size === 0) {\n        size = containerWidth;\n      }\n\n      return size + gutterSize;\n    }\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 = void 0;\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    /**\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      var columnWidth = this._getColumnSize(containerWidth, gutter);\n      var calculatedColumns = (containerWidth + gutter) / columnWidth;\n\n      // Widths given from getStyles are not precise enough...\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), 1);\n      this.containerWidth = containerWidth;\n      this.colWidth = columnWidth;\n    }\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    /**\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    /**\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    /**\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    /**\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      while (i) {\n        i -= 1;\n        this.positions.push(0);\n      }\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        }\n\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        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;\n\n        // Clone the object so that the `before` object isn't modified when the\n        // transition delay is added.\n        var styles = _this4.getStylesForTransition(item, ShuffleItem.Css.VISIBLE.before);\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    /**\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          var point = _this5._getItemPosition(itemSize);\n          return new Rect(point.x, point.y, itemSize.width, itemSize.height, i);\n        });\n\n        return this.getTransformedPositions(itemsData, this.containerWidth);\n      }\n\n      // If no transforms are going to happen, simply return an array of the\n      // future points of each item.\n      return items.map(function (item) {\n        return _this5._getItemPosition(Shuffle.getSize(item.element, true));\n      });\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    /**\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    /**\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\n      var count = 0;\n      collection.forEach(function (item) {\n        function callback() {\n          item.applyCss(ShuffleItem.Css.HIDDEN.after);\n        }\n\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        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        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    /**\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    /**\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(' + x + 'px, ' + y + 'px) scale(' + 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    /**\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    /**\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        _this7._whenTransitionDone(opts.item.element, opts.callback, done);\n      };\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        this._dispatch(Shuffle.EventType.LAYOUT);\n\n        // 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      } else {\n        this._dispatch(Shuffle.EventType.LAYOUT);\n      }\n\n      // Remove everything in the style queue\n      this._queue.length = 0;\n    }\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;\n\n      // Create an array of functions to be called.\n      var callbacks = transitions.map(function (obj) {\n        return _this8._getTransitionFunction(obj);\n      });\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);\n\n      // Reset the array.\n      this._transitions.length = 0;\n\n      // Show it's no longer active.\n      this.isTransitioning = false;\n    }\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      this._dispatch(Shuffle.EventType.LAYOUT);\n    }\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 {Object} [sortObj] A sort object which can sort the visible set\n     */\n\n  }, {\n    key: 'filter',\n    value: function filter(category, sortObj) {\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);\n\n      // Shrink each hidden item\n      this._shrink();\n\n      // How many visible elements?\n      this._updateItemCount();\n\n      // Update transforms on visible elements so they will animate to their new positions.\n      this.sort(sortObj);\n    }\n\n    /**\n     * Gets the visible elements, sorts them, and passes them to layout.\n     * @param {Object} [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);\n\n      // `_layout` always happens after `_shrink`, so it's safe to process the style\n      // queue here with styles from the shrink method.\n      this._processQueue();\n\n      // Adjust the height of the container.\n      this._setContainerSize();\n\n      this.lastSort = sortOptions;\n    }\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        }\n\n        // Layout items\n        this.sort();\n      }\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    /**\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      });\n\n      // Add classes and set initial positions.\n      this._initItems(items);\n\n      // Determine which items will go with the current filter.\n      this._resetCols();\n\n      var allItems = this._mergeNewItems(items);\n      var sortedItems = sorter(allItems, this.lastSort);\n      var allSortedItemsSet = this._filter(this.lastFilter, sortedItems);\n\n      var isNewItem = function isNewItem(item) {\n        return items.includes(item);\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      };\n\n      // Layout all items again so that new items get positions.\n      // Synchonously apply positions.\n      var itemPositions = this._getNextPositions(allSortedItemsSet.visible);\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\n      allSortedItemsSet.hidden.forEach(function (item) {\n        if (isNewItem(item)) {\n          applyHiddenState(item);\n        }\n      });\n\n      // Cause layout so that the styles above are applied.\n      this.element.offsetWidth; // eslint-disable-line no-unused-expressions\n\n      // Add transition to each item.\n      this.setItemTransitions(items);\n\n      // Update the list of items.\n      this.items = this._mergeNewItems(items);\n\n      // Update layout/visibility of new and old items.\n      this.filter(this.lastFilter);\n    }\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    /**\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\n      this.isEnabled = true;\n      if (isUpdateLayout) {\n        this.update();\n      }\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\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);\n\n        // Remove the collection in the callback\n        collection.forEach(function (element) {\n          element.parentNode.removeChild(element);\n        });\n\n        _this10._dispatch(Shuffle.EventType.REMOVED, { collection: collection });\n      };\n\n      // Hide collection first.\n      this._toggleFilterClasses({\n        visible: [],\n        hidden: oldItems\n      });\n\n      this._shrink(oldItems);\n\n      this.sort();\n\n      // 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      this.items = this.items.filter(function (item) {\n        return !oldItems.includes(item);\n      });\n      this._updateItemCount();\n\n      this.once(Shuffle.EventType.LAYOUT, handleLayout);\n    }\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    /**\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      this.isInitialized = false;\n\n      // Find new items in the DOM.\n      this.items = this._getItems();\n\n      // Set initial styles on the new items.\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        _this11.isInitialized = true;\n      });\n\n      // Lay out all items.\n      this.filter(this.lastFilter);\n    }\n\n    /**\n     * Destroys shuffle, removes events, styles, and classes\n     */\n\n  }, {\n    key: 'destroy',\n    value: function destroy() {\n      this._cancelMovement();\n      window.removeEventListener('resize', this._onResize);\n\n      // Reset container styles\n      this.element.classList.remove('shuffle');\n      this.element.removeAttribute('style');\n\n      // Reset individual item styles\n      this._disposeItems(this.items);\n\n      this.items.length = 0;\n      this._transitions.length = 0;\n\n      // Null DOM references\n      this.options.sizer = null;\n      this.element = null;\n\n      // 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      this.isDestroyed = true;\n      this.isEnabled = false;\n    }\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\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    /**\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';\n\n      // Save current duration and delay.\n      var data = elements.map(function (element) {\n        var style = element.style;\n\n        var duration = style.transitionDuration;\n        var delay = style.transitionDelay;\n\n        // Set the duration to zero so it happens immediately\n        style.transitionDuration = zero;\n        style.transitionDelay = zero;\n\n        return {\n          duration: duration,\n          delay: delay\n        };\n      });\n\n      callback();\n\n      // Cause forced synchronous layout.\n      elements[0].offsetWidth; // eslint-disable-line no-unused-expressions\n\n      // Put the duration back\n      elements.forEach(function (element, i) {\n        element.style.transitionDuration = data[i].duration;\n        element.style.transitionDelay = data[i].delay;\n      });\n    }\n  }]);\n  return Shuffle;\n}(tinyEmitter);\n\nShuffle.ShuffleItem = ShuffleItem;\n\nShuffle.ALL_ITEMS = 'all';\nShuffle.FILTER_ATTRIBUTE_KEY = 'groups';\n\n/** @enum {string} */\nShuffle.EventType = {\n  LAYOUT: 'shuffle:layout',\n  REMOVED: 'shuffle:removed'\n};\n\n/** @enum {string} */\nShuffle.Classes = Classes;\n\n/** @enum {string} */\nShuffle.FilterMode = {\n  ANY: 'any',\n  ALL: 'all'\n};\n\n// Overrideable options\nShuffle.options = {\n  // Initial filter group.\n  group: Shuffle.ALL_ITEMS,\n\n  // Transition/animation speed (milliseconds).\n  speed: 250,\n\n  // CSS easing function to use.\n  easing: 'cubic-bezier(0.4, 0.0, 0.2, 1)',\n\n  // e.g. '.picture-item'.\n  itemSelector: '*',\n\n  // Element or selector string. Use an element to determine the size of columns\n  // and gutters.\n  sizer: null,\n\n  // A static number or function that tells the plugin how wide the gutters\n  // between columns are (in pixels).\n  gutterWidth: 0,\n\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\n  // If your group is not json, and is comma delimeted, you could set delimiter\n  // to ','.\n  delimiter: null,\n\n  // Useful for percentage based heights when they might not always be exactly\n  // the same (in pixels).\n  buffer: 0,\n\n  // Reading the width of elements isn't precise enough and can cause columns to\n  // jump between values.\n  columnThreshold: 0.01,\n\n  // Shuffle can be isInitialized with a sort object. It is the same object\n  // given to the sort method.\n  initialSort: null,\n\n  // By default, shuffle will throttle resize events. This can be changed or\n  // removed.\n  throttle: throttleit,\n\n  // How often shuffle can be called on resize (in milliseconds).\n  throttleTime: 300,\n\n  // Transition delay offset for each item in milliseconds.\n  staggerAmount: 15,\n\n  // Maximum stagger delay in milliseconds.\n  staggerAmountMax: 150,\n\n  // Whether to use transforms or absolute positioning.\n  useTransforms: true,\n\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\n  // Attempt to center grid items in each row.\n  isCentered: false,\n\n  // Whether to round pixel values used in translate(x, y). This usually avoids\n  // blurriness.\n  roundTransforms: true\n};\n\nShuffle.Point = Point;\nShuffle.Rect = Rect;\n\n// Expose for testing. Hack at your own risk.\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","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\n","'use strict';\n// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(6);\nvar KEY = 'findIndex';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n  findIndex: function findIndex(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\nrequire('./_add-to-unscopables')(KEY);\n","// 20.1.2.4 Number.isNaN(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare\n    return number != number;\n  }\n});\n"],"names":["_typeof","o","Symbol","iterator","constructor","prototype","require","token","singleMatcher","RegExp","multiMatcher","decodeComponents","components","split","decodeURIComponent","join","err","length","left","slice","right","Array","concat","call","decode","input","tokens","match","i","module","exports","encodedURI","TypeError","replace","replaceMap","exec","result","entries","Object","keys","key","customDecodeURIComponent","_toConsumableArray","r","isArray","_arrayLikeToArray","_arrayWithoutHoles","from","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","a","t","toString","name","test","e","n","strictUriEncode","decodeComponent","splitOnFirst","encode","value","options","strict","encodeURIComponent","keysSorter","sort","b","Number","map","removeHash","hashStart","indexOf","extract","queryStart","parseValue","parseNumbers","isNaN","trim","parseBooleans","toLowerCase","parse","formatter","arrayFormat","accumulator","undefined","newValue","parserForArrayFormat","assign","ret","create","_step","_iterator","_n","F","s","done","f","u","next","return","_createForOfIteratorHelper","param","_splitOnFirst2","_arrayWithHoles","l","push","_iterableToArrayLimit","_nonIterableRest","_i","_Object$keys","_i2","_Object$keys2","k","reduce","Boolean","stringify","object","index","encoderForArrayFormat","filter","x","parseUrl","url","query","E","on","callback","ctx","this","fn","once","self","listener","off","apply","arguments","_","emit","data","evtArr","len","evts","liveEvents","tinyEmitter","proto","Element","vendor","matches","matchesSelector","webkitMatchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector","noop","getNumber","parseFloat","classCallCheck","instance","Constructor","createClass","defineProperties","target","props","descriptor","enumerable","configurable","writable","defineProperty","protoProps","staticProps","Point","y","Rect","w","h","id","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","style","removeClasses","position","visibility","before","opacity","after","transitionDelay","document","body","documentElement","createElement","cssText","appendChild","window","getComputedStyle","getNumberStyle","styles","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","paddingLeft","paddingRight","borderLeftWidth","borderRightWidth","removeChild","defaults$1","reverse","by","compare","randomize","sorter","arr","opts","original","revert","array","Math","floor","random","temp","valA","valB","transitions","eventName","count","cancelTransitionEnd","removeEventListener","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","lastItem","end","offset","finalRects","canMove","newRects","every","newRect","noOverlap","some","intersects","intersectingRect","rowIndex","findIndex","items","includes","splice","arrayUnique","Set","id$1","Shuffle","_TinyEmitter","ReferenceError","possibleConstructorReturn","__proto__","getPrototypeOf","delimeter","delimiter","lastSort","group","ALL_ITEMS","lastFilter","isEnabled","isDestroyed","isInitialized","_transitions","isTransitioning","_queue","el","_getElementOption","_init","subClass","superClass","setPrototypeOf","inherits","_getItems","sizer","_initItems","_onResize","_getResizeFunction","addEventListener","readyState","layout","bind","onLoad","containerCss","getSize","_validateStyles","_setColumns","initialSort","offsetWidth","setItemTransitions","transition","speed","easing","resizeFunction","_handleResize","throttle","throttleTime","option","querySelector","nodeType","jquery","overflow","category","collection","set$$1","_getFilteredSets","_toggleFilterClasses","visible","hidden","item","_doesPassFilter","attr","getAttribute","FILTER_ATTRIBUTE_KEY","JSON","testCategory","filterMode","FilterMode","ANY","_ref","show","hide","init","dispose","visibleItems","_getFilteredItems","_options","positionProps","useTransforms","cssProps","str","m1","properties","transitionDuration","transitionTimingFunction","transitionProperty","children","selector","nodes","parentNode","querySelectorAll","itemSelector","gutterSize","size","gutterWidth","gutter","_getGutterSize","_getColumnSize","calculatedColumns","columnThreshold","cols","colWidth","_getContainerSize","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","evt","currentTarget","onTransitionEnd","_this7","_whenTransitionDone","_cancelMovement","hasSpeed","hasQueue","_startTransitions","_styleImmediately","_dispatch","EventType","LAYOUT","_this8","fns","context","pending","finished","results","maybeDone","arrayParallel","_getTransitionFunction","_movementFinished","objects","elements","_skipTransitions","sortObj","_filter","_shrink","_updateItemCount","sortOptions","_resetCols","_layout","_processQueue","_setContainerSize","isOnlyLayout","newItems","_this9","sortedItems","_mergeNewItems","allSortedItemsSet","isNewItem","applyHiddenState","isUpdateLayout","_this10","oldItems","getItemByElement","_disposeItems","REMOVED","find","_this11","includeMargins","duration","delay","ALL","func","wait","args","rtn","timeoutID","last","delta","Date","setTimeout","__sorter","__getColumnSpan","__getAvailablePositions","__getShortColumn","__getCenteredPositions","string","separator","separatorIndex","charCodeAt","toUpperCase","$export","$find","KEY","forced","P","callbackfn","S","number"],"sourceRoot":""}