{"version":3,"sources":["webpack:///./node_modules/lodash/_root.js","webpack:///./node_modules/lodash/isObject.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/splitting/dist/splitting.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/debounce.js","webpack:///./node_modules/lodash/now.js","webpack:///./node_modules/lodash/toNumber.js","webpack:///./node_modules/lodash/isSymbol.js","webpack:///./node_modules/lodash/isObjectLike.js","webpack:///./node_modules/get-size/get-size.js","webpack:///./node_modules/ev-emitter/ev-emitter.js","webpack:///./node_modules/masonry-layout/masonry.js","webpack:///./node_modules/outlayer/outlayer.js","webpack:///./node_modules/fizzy-ui-utils/utils.js","webpack:///./node_modules/desandro-matches-selector/matches-selector.js","webpack:///./node_modules/outlayer/item.js"],"names":["freeGlobal","freeSelf","self","Object","root","Function","module","exports","value","type","Symbol","document","createText","createTextNode","bind","setProperty","el","varName","style","appendChild","child","createElement","parent","key","text","whitespace","className","setAttribute","textContent","getData","getAttribute","$","e","length","nodeName","slice","call","querySelectorAll","Array2D","len","a","each","items","fn","some","selectFrom","obj","plugins","createPlugin","by","depends","split","resolve","resolvePlugins","deps","index","indexOf","unshift","p","indexOfParent","splice","map","add","opts","splitText","splitOn","includePrevious","preserveWhitespace","normalize","elements","F","createDocumentFragment","push","previousSibling","allElements","childNodes","next","tagName","hasChildNodes","apply","wholeText","contents","trim","i","splitEl","innerHTML","wordPlugin","charPlugin","options","ctx","results","word","Splitting","target","force","opts2","dest","src","k","copy","plugin","pluginBy","key2","element","prefix","cssVar","Array","isArray","item","classList","detectGrid","side","matching","children","c","w","val","Math","round","keys","Number","sort","byNumber","b","html","content","outerHTML","linePlugin","itemPlugin","rowPlugin","columnPlugin","gridPlugin","layoutPlugin","rows","columns","image","currentSrc","img","totalCells","container","cell","cellRowPlugin","rowCount","result","floor","cellColumnPlugin","columnCount","cellPlugin","opt","factory","getRawTag","objectToString","symToStringTag","toStringTag","undefined","global","objectProto","prototype","hasOwnProperty","nativeObjectToString","toString","isOwn","tag","unmasked","isObject","now","toNumber","nativeMax","max","nativeMin","min","func","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","TypeError","invokeFunc","time","args","thisArg","leadingEdge","setTimeout","timerExpired","shouldInvoke","timeSinceLastCall","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","cancel","clearTimeout","flush","Date","isSymbol","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","test","baseGetTag","isObjectLike","window","getStyleSize","num","parseFloat","isNaN","logError","console","message","error","measurements","measurementsLength","getStyle","elem","getComputedStyle","isBoxSizeOuter","isSetup","getSize","div","width","padding","borderStyle","borderWidth","boxSizing","body","documentElement","removeChild","setup","querySelector","nodeType","display","size","height","innerWidth","innerHeight","outerWidth","outerHeight","getZeroSize","offsetWidth","offsetHeight","isBorderBox","measurement","paddingWidth","paddingLeft","paddingRight","paddingHeight","paddingTop","paddingBottom","marginWidth","marginLeft","marginRight","marginHeight","marginTop","marginBottom","borderLeftWidth","borderRightWidth","borderHeight","borderTopWidth","borderBottomWidth","isBorderBoxSizeOuter","styleWidth","styleHeight","EvEmitter","proto","on","eventName","listener","events","_events","listeners","once","onceEvents","_onceEvents","off","emitEvent","onceListeners","allOff","Outlayer","Masonry","create","compatOptions","fitWidth","_resetLayout","_getMeasurement","measureColumns","colYs","cols","maxY","horizontalColIndex","getContainerWidth","columnWidth","firstItem","firstItemElem","containerWidth","gutter","excess","_getOption","parentNode","_getItemLayoutPosition","remainder","colSpan","colPosition","horizontalOrder","position","x","col","y","setHeight","setMax","_getTopColPosition","colGroup","_getTopColGroup","minimumY","groupCount","_getColGroupY","groupColYs","_getHorizontalColPosition","hasSize","_manageStamp","stamp","stampSize","offset","_getElementOffset","firstX","left","right","lastX","firstCol","lastCol","stampMaxY","top","bottom","_getContainerSize","_getContainerFitWidth","unusedCols","needsResizeLayout","previousWidth","utils","Item","jQuery","noop","GUID","instances","queryElement","getQueryElement","$element","extend","constructor","defaults","option","id","outlayerGUID","_create","layout","namespace","containerStyle","initLayout","originLeft","originTop","resize","resizeContainer","transitionDuration","hiddenStyle","opacity","transform","visibleStyle","subclass","Parent","SubClass","oldOption","horizontal","layoutInstant","reloadItems","stamps","bindResize","_itemize","elems","itemElems","_filterFindItemElements","filterFindElements","itemSelector","getItemElements","_manageStamps","isInstant","_isLayoutInited","layoutItems","_init","HTMLElement","_getItemsForLayout","_layoutItems","_postLayout","filter","isIgnored","_emitCompleteOnItems","queue","forEach","isLayoutInstant","_processLayoutQueue","updateStagger","_positionItem","stagger","matches","match","unit","msUnits","getMilliseconds","goTo","moveTo","_setContainerMeasure","measure","isWidth","elemSize","_this","onComplete","dispatchEvent","count","doneCount","tick","event","emitArgs","concat","$event","Event","trigger","ignore","getItem","unignore","_find","unstamp","removeFrom","makeArray","_getBoundingRect","boundingRect","getBoundingClientRect","_boundingRect","thisRect","handleEvent","addEventListener","isResizeBound","unbindResize","removeEventListener","onresize","debounceMethod","addItems","appended","reveal","prepended","previousItems","hide","revealItemElements","getItems","hideItemElements","remove","removeItems","destroy","removeData","data","Layout","htmlInit","bridget","ms","s","matchesSelector","prop","arraySlice","ary","getParent","selector","method","ffElems","childElems","_class","methodName","threshold","timeoutName","timeout","docReady","callback","readyState","toDashed","str","$1","$2","toLowerCase","WidgetClass","dashedNamespace","dataAttr","dataAttrElems","jsDashElems","dataOptionsAttr","attr","JSON","parse","instance","matchesMethod","ElemProto","Element","prefixes","docElemStyle","transitionProperty","transition","transformProperty","transitionEndEvent","WebkitTransition","vendorProperties","transitionDelay","_transn","ingProperties","clean","onEnd","css","elemStyle","getPosition","isOriginLeft","isOriginTop","xValue","yValue","layoutSize","layoutPosition","xPadding","xProperty","xResetProperty","getXValue","yPadding","yProperty","yResetProperty","getYValue","isHorizontal","percentPosition","_transitionTo","curX","curY","didNotMove","setPosition","isTransitioning","transX","transY","transitionStyle","getTranslate","to","onTransitionEnd","isCleaning","_nonTransition","_removeStyles","_transition","from","enableTransition","transitionProps","duration","staggerDelay","onwebkitTransitionEnd","ontransitionend","onotransitionend","dashedVendorProperties","propertyName","isEmptyObj","disableTransition","removeTransitionStyles","cleanStyle","cleanTransitionStyle","delay","removeElem","isHidden","getHideRevealTransitionEndProperty","onRevealTransitionEnd","styleProperty","optionStyle","onHideTransitionEnd"],"mappings":"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","file":"11.bdb009759136ada4d227.js","sourcesContent":["var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global.Splitting = factory());\n}(this, (function () { 'use strict';\n\nvar root = document;\nvar createText = root.createTextNode.bind(root);\n\n/**\n * # setProperty\n * Apply a CSS var\n * @param el{HTMLElement} \n * @param varName {string} \n * @param value {string|number}  \n */\nfunction setProperty(el, varName, value) {\n    el.style.setProperty(varName, value);\n} \n\n/**\n * \n * @param {Node} el \n * @param {Node} child \n */\nfunction appendChild(el, child) {\n  return el.appendChild(child);\n}\n\nfunction createElement(parent, key, text, whitespace) {\n  var el = root.createElement('span');\n  key && (el.className = key); \n  if (text) { \n      !whitespace && el.setAttribute(\"data-\" + key, text);\n      el.textContent = text; \n  }\n  return (parent && appendChild(parent, el)) || el;\n}\n\nfunction getData(el, key) {\n  return el.getAttribute(\"data-\" + key)\n}\n\n/**\n * \n * @param e {import('../types').Target} \n * @param parent {HTMLElement}\n * @returns {HTMLElement[]}\n */\nfunction $(e, parent) {\n    return !e || e.length == 0\n        ? // null or empty string returns empty array\n          []\n        : e.nodeName\n            ? // a single element is wrapped in an array\n              [e]\n            : // selector and NodeList are converted to Element[]\n              [].slice.call(e[0].nodeName ? e : (parent || root).querySelectorAll(e));\n}\n\n/**\n * Creates and fills an array with the value provided\n * @template {T}\n * @param {number} len\n * @param {() => T} valueProvider\n * @return {T}\n */\nfunction Array2D(len) {\n    var a = [];\n    for (; len--; ) {\n        a[len] = [];\n    }\n    return a;\n}\n\nfunction each(items, fn) {\n    items && items.some(fn);\n}\n\nfunction selectFrom(obj) {\n    return function (key) {\n        return obj[key];\n    }\n}\n\n/**\n * # Splitting.index\n * Index split elements and add them to a Splitting instance.\n *\n * @param element {HTMLElement}\n * @param key {string}\n * @param items {HTMLElement[] | HTMLElement[][]}\n */\nfunction index(element, key, items) {\n    var prefix = '--' + key;\n    var cssVar = prefix + \"-index\";\n\n    each(items, function (items, i) {\n        if (Array.isArray(items)) {\n            each(items, function(item) {\n                setProperty(item, cssVar, i);\n            });\n        } else {\n            setProperty(items, cssVar, i);\n        }\n    });\n\n    setProperty(element, prefix + \"-total\", items.length);\n}\n\n/**\n * @type {Record<string, import('./types').ISplittingPlugin>}\n */\nvar plugins = {};\n\n/**\n * @param by {string}\n * @param parent {string}\n * @param deps {string[]}\n * @return {string[]}\n */\nfunction resolvePlugins(by, parent, deps) {\n    // skip if already visited this dependency\n    var index = deps.indexOf(by);\n    if (index == -1) {\n        // if new to dependency array, add to the beginning\n        deps.unshift(by);\n\n        // recursively call this function for all dependencies\n        each(plugins[by].depends, function(p) {\n            resolvePlugins(p, by, deps);\n        });\n    } else {\n        // if this dependency was added already move to the left of\n        // the parent dependency so it gets loaded in order\n        var indexOfParent = deps.indexOf(parent);\n        deps.splice(index, 1);\n        deps.splice(indexOfParent, 0, by);\n    }\n    return deps;\n}\n\n/**\n * Internal utility for creating plugins... essentially to reduce\n * the size of the library\n * @param {string} by \n * @param {string} key \n * @param {string[]} depends \n * @param {Function} split \n * @returns {import('./types').ISplittingPlugin}\n */\nfunction createPlugin(by, depends, key, split) {\n    return {\n        by: by,\n        depends: depends,\n        key: key,\n        split: split\n    }\n}\n\n/**\n *\n * @param by {string}\n * @returns {import('./types').ISplittingPlugin[]}\n */\nfunction resolve(by) {\n    return resolvePlugins(by, 0, []).map(selectFrom(plugins));\n}\n\n/**\n * Adds a new plugin to splitting\n * @param opts {import('./types').ISplittingPlugin}\n */\nfunction add(opts) {\n    plugins[opts.by] = opts;\n}\n\n/**\n * # Splitting.split\n * Split an element's textContent into individual elements\n * @param el {Node} Element to split\n * @param key {string}\n * @param splitOn {string}\n * @param includeSpace {boolean}\n * @returns {HTMLElement[]}\n */\nfunction splitText(el, key, splitOn, includePrevious, preserveWhitespace) {\n    // Combine any strange text nodes or empty whitespace.\n    el.normalize();\n\n    // Use fragment to prevent unnecessary DOM thrashing.\n    var elements = [];\n    var F = document.createDocumentFragment();\n\n    if (includePrevious) {\n        elements.push(el.previousSibling);\n    }\n\n    var allElements = [];\n    $(el.childNodes).some(function(next) {\n        if (next.tagName && !next.hasChildNodes()) {\n            // keep elements without child nodes (no text and no children)\n            allElements.push(next);\n            return;\n        }\n        // Recursively run through child nodes\n        if (next.childNodes && next.childNodes.length) {\n            allElements.push(next);\n            elements.push.apply(elements, splitText(next, key, splitOn, includePrevious, preserveWhitespace));\n            return;\n        }\n\n        // Get the text to split, trimming out the whitespace\n        /** @type {string} */\n        var wholeText = next.wholeText || '';\n        var contents = wholeText.trim();\n\n        // If there's no text left after trimming whitespace, continue the loop\n        if (contents.length) {\n            // insert leading space if there was one\n            if (wholeText[0] === ' ') {\n                allElements.push(createText(' '));\n            }\n            // Concatenate the split text children back into the full array\n            each(contents.split(splitOn), function(splitText, i) {\n                if (i && preserveWhitespace) {\n                    allElements.push(createElement(F, \"whitespace\", \" \", preserveWhitespace));\n                }\n                var splitEl = createElement(F, key, splitText);\n                elements.push(splitEl);\n                allElements.push(splitEl);\n            }); \n            // insert trailing space if there was one\n            if (wholeText[wholeText.length - 1] === ' ') {\n                allElements.push(createText(' '));\n            }\n        }\n    });\n\n    each(allElements, function(el) {\n        appendChild(F, el);\n    });\n\n    // Clear out the existing element\n    el.innerHTML = \"\";\n    appendChild(el, F);\n    return elements;\n}\n\n/** an empty value */\nvar _ = 0;\n\nfunction copy(dest, src) {\n    for (var k in src) {\n        dest[k] = src[k];\n    }\n    return dest;\n}\n\nvar WORDS = 'words';\n\nvar wordPlugin = createPlugin(\n    /*by: */ WORDS,\n    /*depends: */ _,\n    /*key: */ 'word', \n    /*split: */ function(el) {\n        return splitText(el, 'word', /\\s+/, 0, 1)\n    }\n);\n\nvar CHARS = \"chars\";\n\nvar charPlugin = createPlugin(\n    /*by: */ CHARS,\n    /*depends: */ [WORDS],\n    /*key: */ \"char\", \n    /*split: */ function(el, options, ctx) {\n        var results = [];\n\n        each(ctx[WORDS], function(word, i) {\n            results.push.apply(results, splitText(word, \"char\", \"\", options.whitespace && i));\n        });\n\n        return results;\n    }\n);\n\n/**\n * # Splitting\n * \n * @param opts {import('./types').ISplittingOptions} \n */\nfunction Splitting (opts) {\n  opts = opts || {};\n  var key = opts.key;\n\n  return $(opts.target || '[data-splitting]').map(function(el) {\n    var ctx = el['🍌'];  \n    if (!opts.force && ctx) {\n      return ctx;\n    }\n\n    ctx = el['🍌'] = { el: el };\n    var items = resolve(opts.by || getData(el, 'splitting') || CHARS);\n    var opts2 = copy({}, opts);\n    each(items, function(plugin) {\n      if (plugin.split) {\n        var pluginBy = plugin.by;\n        var key2 = (key ? '-' + key : '') + plugin.key;\n        var results = plugin.split(el, opts2, ctx);\n        key2 && index(el, key2, results);\n        ctx[pluginBy] = results;\n        el.classList.add(pluginBy);\n      } \n    });\n\n    el.classList.add('splitting');\n    return ctx;\n  })\n}\n\n/**\n * # Splitting.html\n * \n * @param opts {import('./types').ISplittingOptions}\n */\nfunction html(opts) {\n  opts = opts || {};\n  var parent = opts.target =  createElement();\n  parent.innerHTML = opts.content;\n  Splitting(opts);\n  return parent.outerHTML\n}\n\nSplitting.html = html;\nSplitting.add = add;\n\nfunction detectGrid(el, options, side) {\n    var items = $(options.matching || el.children, el);\n    var c = {};\n\n    each(items, function(w) {\n        var val = Math.round(w[side]);\n        (c[val] || (c[val] = [])).push(w);\n    });\n\n    return Object.keys(c).map(Number).sort(byNumber).map(selectFrom(c));\n}\n\nfunction byNumber(a, b) {\n    return a - b;\n}\n\nvar linePlugin = createPlugin(\n    /*by: */ 'lines',\n    /*depends: */ [WORDS],\n    /*key: */ 'line',\n    /*split: */ function(el, options, ctx) {\n      return detectGrid(el, { matching: ctx[WORDS] }, 'offsetTop')\n    }\n);\n\nvar itemPlugin = createPlugin(\n    /*by: */ 'items',\n    /*depends: */ _,\n    /*key: */ 'item', \n    /*split: */ function(el, options) {\n        return $(options.matching || el.children, el)\n    }\n);\n\nvar rowPlugin = createPlugin(\n    /*by: */ 'rows',\n    /*depends: */ _,\n    /*key: */ 'row', \n    /*split: */ function(el, options) {\n        return detectGrid(el, options, \"offsetTop\");\n    }\n);\n\nvar columnPlugin = createPlugin(\n    /*by: */ 'cols',\n    /*depends: */ _,\n    /*key: */ \"col\", \n    /*split: */ function(el, options) {\n        return detectGrid(el, options, \"offsetLeft\");\n    }\n);\n\nvar gridPlugin = createPlugin(\n    /*by: */ 'grid',\n    /*depends: */ ['rows', 'cols']\n);\n\nvar LAYOUT = \"layout\";\n\nvar layoutPlugin = createPlugin(\n    /*by: */ LAYOUT,\n    /*depends: */ _,\n    /*key: */ _,\n    /*split: */ function(el, opts) {\n        // detect and set options\n        var rows =  opts.rows = +(opts.rows || getData(el, 'rows') || 1);\n        var columns = opts.columns = +(opts.columns || getData(el, 'columns') || 1);\n\n        // Seek out the first <img> if the value is true \n        opts.image = opts.image || getData(el, 'image') || el.currentSrc || el.src;\n        if (opts.image) {\n            var img = $(\"img\", el)[0];\n            opts.image = img && (img.currentSrc || img.src);\n        }\n\n        // add optional image to background\n        if (opts.image) {\n            setProperty(el, \"background-image\", \"url(\" + opts.image + \")\");\n        }\n\n        var totalCells = rows * columns;\n        var elements = [];\n\n        var container = createElement(_, \"cell-grid\");\n        while (totalCells--) {\n            // Create a span\n            var cell = createElement(container, \"cell\");\n            createElement(cell, \"cell-inner\");\n            elements.push(cell);\n        }\n\n        // Append elements back into the parent\n        appendChild(el, container);\n\n        return elements;\n    }\n);\n\nvar cellRowPlugin = createPlugin(\n    /*by: */ \"cellRows\",\n    /*depends: */ [LAYOUT],\n    /*key: */ \"row\",\n    /*split: */ function(el, opts, ctx) {\n        var rowCount = opts.rows;\n        var result = Array2D(rowCount);\n\n        each(ctx[LAYOUT], function(cell, i, src) {\n            result[Math.floor(i / (src.length / rowCount))].push(cell);\n        });\n\n        return result;\n    }\n);\n\nvar cellColumnPlugin = createPlugin(\n    /*by: */ \"cellColumns\",\n    /*depends: */ [LAYOUT],\n    /*key: */ \"col\",\n    /*split: */ function(el, opts, ctx) {\n        var columnCount = opts.columns;\n        var result = Array2D(columnCount);\n\n        each(ctx[LAYOUT], function(cell, i) {\n            result[i % columnCount].push(cell);\n        });\n\n        return result;\n    }\n);\n\nvar cellPlugin = createPlugin(\n    /*by: */ \"cells\",\n    /*depends: */ ['cellRows', 'cellColumns'],\n    /*key: */ \"cell\", \n    /*split: */ function(el, opt, ctx) { \n        // re-index the layout as the cells\n        return ctx[LAYOUT];\n    }\n);\n\n// install plugins\n// word/char plugins\nadd(wordPlugin);\nadd(charPlugin);\nadd(linePlugin);\n// grid plugins\nadd(itemPlugin);\nadd(rowPlugin);\nadd(columnPlugin);\nadd(gridPlugin);\n// cell-layout plugins\nadd(layoutPlugin);\nadd(cellRowPlugin);\nadd(cellColumnPlugin);\nadd(cellPlugin);\n\nreturn Splitting;\n\n})));\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","/*!\n * getSize v2.0.3\n * measure size of elements\n * MIT license\n */\n\n/* jshint browser: true, strict: true, undef: true, unused: true */\n/* globals console: false */\n\n( function( window, factory ) {\n  /* jshint strict: false */ /* globals define, module */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD\n    define( factory );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS\n    module.exports = factory();\n  } else {\n    // browser global\n    window.getSize = factory();\n  }\n\n})( window, function factory() {\n'use strict';\n\n// -------------------------- helpers -------------------------- //\n\n// get a number from a string, not a percentage\nfunction getStyleSize( value ) {\n  var num = parseFloat( value );\n  // not a percent like '100%', and a number\n  var isValid = value.indexOf('%') == -1 && !isNaN( num );\n  return isValid && num;\n}\n\nfunction noop() {}\n\nvar logError = typeof console == 'undefined' ? noop :\n  function( message ) {\n    console.error( message );\n  };\n\n// -------------------------- measurements -------------------------- //\n\nvar measurements = [\n  'paddingLeft',\n  'paddingRight',\n  'paddingTop',\n  'paddingBottom',\n  'marginLeft',\n  'marginRight',\n  'marginTop',\n  'marginBottom',\n  'borderLeftWidth',\n  'borderRightWidth',\n  'borderTopWidth',\n  'borderBottomWidth'\n];\n\nvar measurementsLength = measurements.length;\n\nfunction getZeroSize() {\n  var size = {\n    width: 0,\n    height: 0,\n    innerWidth: 0,\n    innerHeight: 0,\n    outerWidth: 0,\n    outerHeight: 0\n  };\n  for ( var i=0; i < measurementsLength; i++ ) {\n    var measurement = measurements[i];\n    size[ measurement ] = 0;\n  }\n  return size;\n}\n\n// -------------------------- getStyle -------------------------- //\n\n/**\n * getStyle, get style of element, check for Firefox bug\n * https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n */\nfunction getStyle( elem ) {\n  var style = getComputedStyle( elem );\n  if ( !style ) {\n    logError( 'Style returned ' + style +\n      '. Are you running this code in a hidden iframe on Firefox? ' +\n      'See https://bit.ly/getsizebug1' );\n  }\n  return style;\n}\n\n// -------------------------- setup -------------------------- //\n\nvar isSetup = false;\n\nvar isBoxSizeOuter;\n\n/**\n * setup\n * check isBoxSizerOuter\n * do on first getSize() rather than on page load for Firefox bug\n */\nfunction setup() {\n  // setup once\n  if ( isSetup ) {\n    return;\n  }\n  isSetup = true;\n\n  // -------------------------- box sizing -------------------------- //\n\n  /**\n   * Chrome & Safari measure the outer-width on style.width on border-box elems\n   * IE11 & Firefox<29 measures the inner-width\n   */\n  var div = document.createElement('div');\n  div.style.width = '200px';\n  div.style.padding = '1px 2px 3px 4px';\n  div.style.borderStyle = 'solid';\n  div.style.borderWidth = '1px 2px 3px 4px';\n  div.style.boxSizing = 'border-box';\n\n  var body = document.body || document.documentElement;\n  body.appendChild( div );\n  var style = getStyle( div );\n  // round value for browser zoom. desandro/masonry#928\n  isBoxSizeOuter = Math.round( getStyleSize( style.width ) ) == 200;\n  getSize.isBoxSizeOuter = isBoxSizeOuter;\n\n  body.removeChild( div );\n}\n\n// -------------------------- getSize -------------------------- //\n\nfunction getSize( elem ) {\n  setup();\n\n  // use querySeletor if elem is string\n  if ( typeof elem == 'string' ) {\n    elem = document.querySelector( elem );\n  }\n\n  // do not proceed on non-objects\n  if ( !elem || typeof elem != 'object' || !elem.nodeType ) {\n    return;\n  }\n\n  var style = getStyle( elem );\n\n  // if hidden, everything is 0\n  if ( style.display == 'none' ) {\n    return getZeroSize();\n  }\n\n  var size = {};\n  size.width = elem.offsetWidth;\n  size.height = elem.offsetHeight;\n\n  var isBorderBox = size.isBorderBox = style.boxSizing == 'border-box';\n\n  // get all measurements\n  for ( var i=0; i < measurementsLength; i++ ) {\n    var measurement = measurements[i];\n    var value = style[ measurement ];\n    var num = parseFloat( value );\n    // any 'auto', 'medium' value will be 0\n    size[ measurement ] = !isNaN( num ) ? num : 0;\n  }\n\n  var paddingWidth = size.paddingLeft + size.paddingRight;\n  var paddingHeight = size.paddingTop + size.paddingBottom;\n  var marginWidth = size.marginLeft + size.marginRight;\n  var marginHeight = size.marginTop + size.marginBottom;\n  var borderWidth = size.borderLeftWidth + size.borderRightWidth;\n  var borderHeight = size.borderTopWidth + size.borderBottomWidth;\n\n  var isBorderBoxSizeOuter = isBorderBox && isBoxSizeOuter;\n\n  // overwrite width and height if we can get it from style\n  var styleWidth = getStyleSize( style.width );\n  if ( styleWidth !== false ) {\n    size.width = styleWidth +\n      // add padding and border unless it's already including it\n      ( isBorderBoxSizeOuter ? 0 : paddingWidth + borderWidth );\n  }\n\n  var styleHeight = getStyleSize( style.height );\n  if ( styleHeight !== false ) {\n    size.height = styleHeight +\n      // add padding and border unless it's already including it\n      ( isBorderBoxSizeOuter ? 0 : paddingHeight + borderHeight );\n  }\n\n  size.innerWidth = size.width - ( paddingWidth + borderWidth );\n  size.innerHeight = size.height - ( paddingHeight + borderHeight );\n\n  size.outerWidth = size.width + marginWidth;\n  size.outerHeight = size.height + marginHeight;\n\n  return size;\n}\n\nreturn getSize;\n\n});\n","/**\n * EvEmitter v1.1.0\n * Lil' event emitter\n * MIT License\n */\n\n/* jshint unused: true, undef: true, strict: true */\n\n( function( global, factory ) {\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, window */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD - RequireJS\n    define( factory );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory();\n  } else {\n    // Browser globals\n    global.EvEmitter = factory();\n  }\n\n}( typeof window != 'undefined' ? window : this, function() {\n\n\"use strict\";\n\nfunction EvEmitter() {}\n\nvar proto = EvEmitter.prototype;\n\nproto.on = function( eventName, listener ) {\n  if ( !eventName || !listener ) {\n    return;\n  }\n  // set events hash\n  var events = this._events = this._events || {};\n  // set listeners array\n  var listeners = events[ eventName ] = events[ eventName ] || [];\n  // only add once\n  if ( listeners.indexOf( listener ) == -1 ) {\n    listeners.push( listener );\n  }\n\n  return this;\n};\n\nproto.once = function( eventName, listener ) {\n  if ( !eventName || !listener ) {\n    return;\n  }\n  // add event\n  this.on( eventName, listener );\n  // set once flag\n  // set onceEvents hash\n  var onceEvents = this._onceEvents = this._onceEvents || {};\n  // set onceListeners object\n  var onceListeners = onceEvents[ eventName ] = onceEvents[ eventName ] || {};\n  // set flag\n  onceListeners[ listener ] = true;\n\n  return this;\n};\n\nproto.off = function( eventName, listener ) {\n  var listeners = this._events && this._events[ eventName ];\n  if ( !listeners || !listeners.length ) {\n    return;\n  }\n  var index = listeners.indexOf( listener );\n  if ( index != -1 ) {\n    listeners.splice( index, 1 );\n  }\n\n  return this;\n};\n\nproto.emitEvent = function( eventName, args ) {\n  var listeners = this._events && this._events[ eventName ];\n  if ( !listeners || !listeners.length ) {\n    return;\n  }\n  // copy over to avoid interference if .off() in listener\n  listeners = listeners.slice(0);\n  args = args || [];\n  // once stuff\n  var onceListeners = this._onceEvents && this._onceEvents[ eventName ];\n\n  for ( var i=0; i < listeners.length; i++ ) {\n    var listener = listeners[i]\n    var isOnce = onceListeners && onceListeners[ listener ];\n    if ( isOnce ) {\n      // remove listener\n      // remove before trigger to prevent recursion\n      this.off( eventName, listener );\n      // unset once flag\n      delete onceListeners[ listener ];\n    }\n    // trigger listener\n    listener.apply( this, args );\n  }\n\n  return this;\n};\n\nproto.allOff = function() {\n  delete this._events;\n  delete this._onceEvents;\n};\n\nreturn EvEmitter;\n\n}));\n","/*!\n * Masonry v4.2.2\n * Cascading grid layout library\n * https://masonry.desandro.com\n * MIT License\n * by David DeSandro\n */\n\n( function( window, factory ) {\n  // universal module definition\n  /* jshint strict: false */ /*globals define, module, require */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD\n    define( [\n        'outlayer/outlayer',\n        'get-size/get-size'\n      ],\n      factory );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS\n    module.exports = factory(\n      require('outlayer'),\n      require('get-size')\n    );\n  } else {\n    // browser global\n    window.Masonry = factory(\n      window.Outlayer,\n      window.getSize\n    );\n  }\n\n}( window, function factory( Outlayer, getSize ) {\n\n'use strict';\n\n// -------------------------- masonryDefinition -------------------------- //\n\n  // create an Outlayer layout class\n  var Masonry = Outlayer.create('masonry');\n  // isFitWidth -> fitWidth\n  Masonry.compatOptions.fitWidth = 'isFitWidth';\n\n  var proto = Masonry.prototype;\n\n  proto._resetLayout = function() {\n    this.getSize();\n    this._getMeasurement( 'columnWidth', 'outerWidth' );\n    this._getMeasurement( 'gutter', 'outerWidth' );\n    this.measureColumns();\n\n    // reset column Y\n    this.colYs = [];\n    for ( var i=0; i < this.cols; i++ ) {\n      this.colYs.push( 0 );\n    }\n\n    this.maxY = 0;\n    this.horizontalColIndex = 0;\n  };\n\n  proto.measureColumns = function() {\n    this.getContainerWidth();\n    // if columnWidth is 0, default to outerWidth of first item\n    if ( !this.columnWidth ) {\n      var firstItem = this.items[0];\n      var firstItemElem = firstItem && firstItem.element;\n      // columnWidth fall back to item of first element\n      this.columnWidth = firstItemElem && getSize( firstItemElem ).outerWidth ||\n        // if first elem has no width, default to size of container\n        this.containerWidth;\n    }\n\n    var columnWidth = this.columnWidth += this.gutter;\n\n    // calculate columns\n    var containerWidth = this.containerWidth + this.gutter;\n    var cols = containerWidth / columnWidth;\n    // fix rounding errors, typically with gutters\n    var excess = columnWidth - containerWidth % columnWidth;\n    // if overshoot is less than a pixel, round up, otherwise floor it\n    var mathMethod = excess && excess < 1 ? 'round' : 'floor';\n    cols = Math[ mathMethod ]( cols );\n    this.cols = Math.max( cols, 1 );\n  };\n\n  proto.getContainerWidth = function() {\n    // container is parent if fit width\n    var isFitWidth = this._getOption('fitWidth');\n    var container = isFitWidth ? this.element.parentNode : this.element;\n    // check that this.size and size are there\n    // IE8 triggers resize on body size change, so they might not be\n    var size = getSize( container );\n    this.containerWidth = size && size.innerWidth;\n  };\n\n  proto._getItemLayoutPosition = function( item ) {\n    item.getSize();\n    // how many columns does this brick span\n    var remainder = item.size.outerWidth % this.columnWidth;\n    var mathMethod = remainder && remainder < 1 ? 'round' : 'ceil';\n    // round if off by 1 pixel, otherwise use ceil\n    var colSpan = Math[ mathMethod ]( item.size.outerWidth / this.columnWidth );\n    colSpan = Math.min( colSpan, this.cols );\n    // use horizontal or top column position\n    var colPosMethod = this.options.horizontalOrder ?\n      '_getHorizontalColPosition' : '_getTopColPosition';\n    var colPosition = this[ colPosMethod ]( colSpan, item );\n    // position the brick\n    var position = {\n      x: this.columnWidth * colPosition.col,\n      y: colPosition.y\n    };\n    // apply setHeight to necessary columns\n    var setHeight = colPosition.y + item.size.outerHeight;\n    var setMax = colSpan + colPosition.col;\n    for ( var i = colPosition.col; i < setMax; i++ ) {\n      this.colYs[i] = setHeight;\n    }\n\n    return position;\n  };\n\n  proto._getTopColPosition = function( colSpan ) {\n    var colGroup = this._getTopColGroup( colSpan );\n    // get the minimum Y value from the columns\n    var minimumY = Math.min.apply( Math, colGroup );\n\n    return {\n      col: colGroup.indexOf( minimumY ),\n      y: minimumY,\n    };\n  };\n\n  /**\n   * @param {Number} colSpan - number of columns the element spans\n   * @returns {Array} colGroup\n   */\n  proto._getTopColGroup = function( colSpan ) {\n    if ( colSpan < 2 ) {\n      // if brick spans only one column, use all the column Ys\n      return this.colYs;\n    }\n\n    var colGroup = [];\n    // how many different places could this brick fit horizontally\n    var groupCount = this.cols + 1 - colSpan;\n    // for each group potential horizontal position\n    for ( var i = 0; i < groupCount; i++ ) {\n      colGroup[i] = this._getColGroupY( i, colSpan );\n    }\n    return colGroup;\n  };\n\n  proto._getColGroupY = function( col, colSpan ) {\n    if ( colSpan < 2 ) {\n      return this.colYs[ col ];\n    }\n    // make an array of colY values for that one group\n    var groupColYs = this.colYs.slice( col, col + colSpan );\n    // and get the max value of the array\n    return Math.max.apply( Math, groupColYs );\n  };\n\n  // get column position based on horizontal index. #873\n  proto._getHorizontalColPosition = function( colSpan, item ) {\n    var col = this.horizontalColIndex % this.cols;\n    var isOver = colSpan > 1 && col + colSpan > this.cols;\n    // shift to next row if item can't fit on current row\n    col = isOver ? 0 : col;\n    // don't let zero-size items take up space\n    var hasSize = item.size.outerWidth && item.size.outerHeight;\n    this.horizontalColIndex = hasSize ? col + colSpan : this.horizontalColIndex;\n\n    return {\n      col: col,\n      y: this._getColGroupY( col, colSpan ),\n    };\n  };\n\n  proto._manageStamp = function( stamp ) {\n    var stampSize = getSize( stamp );\n    var offset = this._getElementOffset( stamp );\n    // get the columns that this stamp affects\n    var isOriginLeft = this._getOption('originLeft');\n    var firstX = isOriginLeft ? offset.left : offset.right;\n    var lastX = firstX + stampSize.outerWidth;\n    var firstCol = Math.floor( firstX / this.columnWidth );\n    firstCol = Math.max( 0, firstCol );\n    var lastCol = Math.floor( lastX / this.columnWidth );\n    // lastCol should not go over if multiple of columnWidth #425\n    lastCol -= lastX % this.columnWidth ? 0 : 1;\n    lastCol = Math.min( this.cols - 1, lastCol );\n    // set colYs to bottom of the stamp\n\n    var isOriginTop = this._getOption('originTop');\n    var stampMaxY = ( isOriginTop ? offset.top : offset.bottom ) +\n      stampSize.outerHeight;\n    for ( var i = firstCol; i <= lastCol; i++ ) {\n      this.colYs[i] = Math.max( stampMaxY, this.colYs[i] );\n    }\n  };\n\n  proto._getContainerSize = function() {\n    this.maxY = Math.max.apply( Math, this.colYs );\n    var size = {\n      height: this.maxY\n    };\n\n    if ( this._getOption('fitWidth') ) {\n      size.width = this._getContainerFitWidth();\n    }\n\n    return size;\n  };\n\n  proto._getContainerFitWidth = function() {\n    var unusedCols = 0;\n    // count unused columns\n    var i = this.cols;\n    while ( --i ) {\n      if ( this.colYs[i] !== 0 ) {\n        break;\n      }\n      unusedCols++;\n    }\n    // fit container to columns that have been used\n    return ( this.cols - unusedCols ) * this.columnWidth - this.gutter;\n  };\n\n  proto.needsResizeLayout = function() {\n    var previousWidth = this.containerWidth;\n    this.getContainerWidth();\n    return previousWidth != this.containerWidth;\n  };\n\n  return Masonry;\n\n}));\n","/*!\n * Outlayer v2.1.1\n * the brains and guts of a layout library\n * MIT license\n */\n\n( function( window, factory ) {\n  'use strict';\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, require */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD - RequireJS\n    define( [\n        'ev-emitter/ev-emitter',\n        'get-size/get-size',\n        'fizzy-ui-utils/utils',\n        './item'\n      ],\n      function( EvEmitter, getSize, utils, Item ) {\n        return factory( window, EvEmitter, getSize, utils, Item);\n      }\n    );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory(\n      window,\n      require('ev-emitter'),\n      require('get-size'),\n      require('fizzy-ui-utils'),\n      require('./item')\n    );\n  } else {\n    // browser global\n    window.Outlayer = factory(\n      window,\n      window.EvEmitter,\n      window.getSize,\n      window.fizzyUIUtils,\n      window.Outlayer.Item\n    );\n  }\n\n}( window, function factory( window, EvEmitter, getSize, utils, Item ) {\n'use strict';\n\n// ----- vars ----- //\n\nvar console = window.console;\nvar jQuery = window.jQuery;\nvar noop = function() {};\n\n// -------------------------- Outlayer -------------------------- //\n\n// globally unique identifiers\nvar GUID = 0;\n// internal store of all Outlayer intances\nvar instances = {};\n\n\n/**\n * @param {Element, String} element\n * @param {Object} options\n * @constructor\n */\nfunction Outlayer( element, options ) {\n  var queryElement = utils.getQueryElement( element );\n  if ( !queryElement ) {\n    if ( console ) {\n      console.error( 'Bad element for ' + this.constructor.namespace +\n        ': ' + ( queryElement || element ) );\n    }\n    return;\n  }\n  this.element = queryElement;\n  // add jQuery\n  if ( jQuery ) {\n    this.$element = jQuery( this.element );\n  }\n\n  // options\n  this.options = utils.extend( {}, this.constructor.defaults );\n  this.option( options );\n\n  // add id for Outlayer.getFromElement\n  var id = ++GUID;\n  this.element.outlayerGUID = id; // expando\n  instances[ id ] = this; // associate via id\n\n  // kick it off\n  this._create();\n\n  var isInitLayout = this._getOption('initLayout');\n  if ( isInitLayout ) {\n    this.layout();\n  }\n}\n\n// settings are for internal use only\nOutlayer.namespace = 'outlayer';\nOutlayer.Item = Item;\n\n// default options\nOutlayer.defaults = {\n  containerStyle: {\n    position: 'relative'\n  },\n  initLayout: true,\n  originLeft: true,\n  originTop: true,\n  resize: true,\n  resizeContainer: true,\n  // item options\n  transitionDuration: '0.4s',\n  hiddenStyle: {\n    opacity: 0,\n    transform: 'scale(0.001)'\n  },\n  visibleStyle: {\n    opacity: 1,\n    transform: 'scale(1)'\n  }\n};\n\nvar proto = Outlayer.prototype;\n// inherit EvEmitter\nutils.extend( proto, EvEmitter.prototype );\n\n/**\n * set options\n * @param {Object} opts\n */\nproto.option = function( opts ) {\n  utils.extend( this.options, opts );\n};\n\n/**\n * get backwards compatible option value, check old name\n */\nproto._getOption = function( option ) {\n  var oldOption = this.constructor.compatOptions[ option ];\n  return oldOption && this.options[ oldOption ] !== undefined ?\n    this.options[ oldOption ] : this.options[ option ];\n};\n\nOutlayer.compatOptions = {\n  // currentName: oldName\n  initLayout: 'isInitLayout',\n  horizontal: 'isHorizontal',\n  layoutInstant: 'isLayoutInstant',\n  originLeft: 'isOriginLeft',\n  originTop: 'isOriginTop',\n  resize: 'isResizeBound',\n  resizeContainer: 'isResizingContainer'\n};\n\nproto._create = function() {\n  // get items from children\n  this.reloadItems();\n  // elements that affect layout, but are not laid out\n  this.stamps = [];\n  this.stamp( this.options.stamp );\n  // set container style\n  utils.extend( this.element.style, this.options.containerStyle );\n\n  // bind resize method\n  var canBindResize = this._getOption('resize');\n  if ( canBindResize ) {\n    this.bindResize();\n  }\n};\n\n// goes through all children again and gets bricks in proper order\nproto.reloadItems = function() {\n  // collection of item elements\n  this.items = this._itemize( this.element.children );\n};\n\n\n/**\n * turn elements into Outlayer.Items to be used in layout\n * @param {Array or NodeList or HTMLElement} elems\n * @returns {Array} items - collection of new Outlayer Items\n */\nproto._itemize = function( elems ) {\n\n  var itemElems = this._filterFindItemElements( elems );\n  var Item = this.constructor.Item;\n\n  // create new Outlayer Items for collection\n  var items = [];\n  for ( var i=0; i < itemElems.length; i++ ) {\n    var elem = itemElems[i];\n    var item = new Item( elem, this );\n    items.push( item );\n  }\n\n  return items;\n};\n\n/**\n * get item elements to be used in layout\n * @param {Array or NodeList or HTMLElement} elems\n * @returns {Array} items - item elements\n */\nproto._filterFindItemElements = function( elems ) {\n  return utils.filterFindElements( elems, this.options.itemSelector );\n};\n\n/**\n * getter method for getting item elements\n * @returns {Array} elems - collection of item elements\n */\nproto.getItemElements = function() {\n  return this.items.map( function( item ) {\n    return item.element;\n  });\n};\n\n// ----- init & layout ----- //\n\n/**\n * lays out all items\n */\nproto.layout = function() {\n  this._resetLayout();\n  this._manageStamps();\n\n  // don't animate first layout\n  var layoutInstant = this._getOption('layoutInstant');\n  var isInstant = layoutInstant !== undefined ?\n    layoutInstant : !this._isLayoutInited;\n  this.layoutItems( this.items, isInstant );\n\n  // flag for initalized\n  this._isLayoutInited = true;\n};\n\n// _init is alias for layout\nproto._init = proto.layout;\n\n/**\n * logic before any new layout\n */\nproto._resetLayout = function() {\n  this.getSize();\n};\n\n\nproto.getSize = function() {\n  this.size = getSize( this.element );\n};\n\n/**\n * get measurement from option, for columnWidth, rowHeight, gutter\n * if option is String -> get element from selector string, & get size of element\n * if option is Element -> get size of element\n * else use option as a number\n *\n * @param {String} measurement\n * @param {String} size - width or height\n * @private\n */\nproto._getMeasurement = function( measurement, size ) {\n  var option = this.options[ measurement ];\n  var elem;\n  if ( !option ) {\n    // default to 0\n    this[ measurement ] = 0;\n  } else {\n    // use option as an element\n    if ( typeof option == 'string' ) {\n      elem = this.element.querySelector( option );\n    } else if ( option instanceof HTMLElement ) {\n      elem = option;\n    }\n    // use size of element, if element\n    this[ measurement ] = elem ? getSize( elem )[ size ] : option;\n  }\n};\n\n/**\n * layout a collection of item elements\n * @api public\n */\nproto.layoutItems = function( items, isInstant ) {\n  items = this._getItemsForLayout( items );\n\n  this._layoutItems( items, isInstant );\n\n  this._postLayout();\n};\n\n/**\n * get the items to be laid out\n * you may want to skip over some items\n * @param {Array} items\n * @returns {Array} items\n */\nproto._getItemsForLayout = function( items ) {\n  return items.filter( function( item ) {\n    return !item.isIgnored;\n  });\n};\n\n/**\n * layout items\n * @param {Array} items\n * @param {Boolean} isInstant\n */\nproto._layoutItems = function( items, isInstant ) {\n  this._emitCompleteOnItems( 'layout', items );\n\n  if ( !items || !items.length ) {\n    // no items, emit event with empty array\n    return;\n  }\n\n  var queue = [];\n\n  items.forEach( function( item ) {\n    // get x/y object from method\n    var position = this._getItemLayoutPosition( item );\n    // enqueue\n    position.item = item;\n    position.isInstant = isInstant || item.isLayoutInstant;\n    queue.push( position );\n  }, this );\n\n  this._processLayoutQueue( queue );\n};\n\n/**\n * get item layout position\n * @param {Outlayer.Item} item\n * @returns {Object} x and y position\n */\nproto._getItemLayoutPosition = function( /* item */ ) {\n  return {\n    x: 0,\n    y: 0\n  };\n};\n\n/**\n * iterate over array and position each item\n * Reason being - separating this logic prevents 'layout invalidation'\n * thx @paul_irish\n * @param {Array} queue\n */\nproto._processLayoutQueue = function( queue ) {\n  this.updateStagger();\n  queue.forEach( function( obj, i ) {\n    this._positionItem( obj.item, obj.x, obj.y, obj.isInstant, i );\n  }, this );\n};\n\n// set stagger from option in milliseconds number\nproto.updateStagger = function() {\n  var stagger = this.options.stagger;\n  if ( stagger === null || stagger === undefined ) {\n    this.stagger = 0;\n    return;\n  }\n  this.stagger = getMilliseconds( stagger );\n  return this.stagger;\n};\n\n/**\n * Sets position of item in DOM\n * @param {Outlayer.Item} item\n * @param {Number} x - horizontal position\n * @param {Number} y - vertical position\n * @param {Boolean} isInstant - disables transitions\n */\nproto._positionItem = function( item, x, y, isInstant, i ) {\n  if ( isInstant ) {\n    // if not transition, just set CSS\n    item.goTo( x, y );\n  } else {\n    item.stagger( i * this.stagger );\n    item.moveTo( x, y );\n  }\n};\n\n/**\n * Any logic you want to do after each layout,\n * i.e. size the container\n */\nproto._postLayout = function() {\n  this.resizeContainer();\n};\n\nproto.resizeContainer = function() {\n  var isResizingContainer = this._getOption('resizeContainer');\n  if ( !isResizingContainer ) {\n    return;\n  }\n  var size = this._getContainerSize();\n  if ( size ) {\n    this._setContainerMeasure( size.width, true );\n    this._setContainerMeasure( size.height, false );\n  }\n};\n\n/**\n * Sets width or height of container if returned\n * @returns {Object} size\n *   @param {Number} width\n *   @param {Number} height\n */\nproto._getContainerSize = noop;\n\n/**\n * @param {Number} measure - size of width or height\n * @param {Boolean} isWidth\n */\nproto._setContainerMeasure = function( measure, isWidth ) {\n  if ( measure === undefined ) {\n    return;\n  }\n\n  var elemSize = this.size;\n  // add padding and border width if border box\n  if ( elemSize.isBorderBox ) {\n    measure += isWidth ? elemSize.paddingLeft + elemSize.paddingRight +\n      elemSize.borderLeftWidth + elemSize.borderRightWidth :\n      elemSize.paddingBottom + elemSize.paddingTop +\n      elemSize.borderTopWidth + elemSize.borderBottomWidth;\n  }\n\n  measure = Math.max( measure, 0 );\n  this.element.style[ isWidth ? 'width' : 'height' ] = measure + 'px';\n};\n\n/**\n * emit eventComplete on a collection of items events\n * @param {String} eventName\n * @param {Array} items - Outlayer.Items\n */\nproto._emitCompleteOnItems = function( eventName, items ) {\n  var _this = this;\n  function onComplete() {\n    _this.dispatchEvent( eventName + 'Complete', null, [ items ] );\n  }\n\n  var count = items.length;\n  if ( !items || !count ) {\n    onComplete();\n    return;\n  }\n\n  var doneCount = 0;\n  function tick() {\n    doneCount++;\n    if ( doneCount == count ) {\n      onComplete();\n    }\n  }\n\n  // bind callback\n  items.forEach( function( item ) {\n    item.once( eventName, tick );\n  });\n};\n\n/**\n * emits events via EvEmitter and jQuery events\n * @param {String} type - name of event\n * @param {Event} event - original event\n * @param {Array} args - extra arguments\n */\nproto.dispatchEvent = function( type, event, args ) {\n  // add original event to arguments\n  var emitArgs = event ? [ event ].concat( args ) : args;\n  this.emitEvent( type, emitArgs );\n\n  if ( jQuery ) {\n    // set this.$element\n    this.$element = this.$element || jQuery( this.element );\n    if ( event ) {\n      // create jQuery event\n      var $event = jQuery.Event( event );\n      $event.type = type;\n      this.$element.trigger( $event, args );\n    } else {\n      // just trigger with type if no event available\n      this.$element.trigger( type, args );\n    }\n  }\n};\n\n// -------------------------- ignore & stamps -------------------------- //\n\n\n/**\n * keep item in collection, but do not lay it out\n * ignored items do not get skipped in layout\n * @param {Element} elem\n */\nproto.ignore = function( elem ) {\n  var item = this.getItem( elem );\n  if ( item ) {\n    item.isIgnored = true;\n  }\n};\n\n/**\n * return item to layout collection\n * @param {Element} elem\n */\nproto.unignore = function( elem ) {\n  var item = this.getItem( elem );\n  if ( item ) {\n    delete item.isIgnored;\n  }\n};\n\n/**\n * adds elements to stamps\n * @param {NodeList, Array, Element, or String} elems\n */\nproto.stamp = function( elems ) {\n  elems = this._find( elems );\n  if ( !elems ) {\n    return;\n  }\n\n  this.stamps = this.stamps.concat( elems );\n  // ignore\n  elems.forEach( this.ignore, this );\n};\n\n/**\n * removes elements to stamps\n * @param {NodeList, Array, or Element} elems\n */\nproto.unstamp = function( elems ) {\n  elems = this._find( elems );\n  if ( !elems ){\n    return;\n  }\n\n  elems.forEach( function( elem ) {\n    // filter out removed stamp elements\n    utils.removeFrom( this.stamps, elem );\n    this.unignore( elem );\n  }, this );\n};\n\n/**\n * finds child elements\n * @param {NodeList, Array, Element, or String} elems\n * @returns {Array} elems\n */\nproto._find = function( elems ) {\n  if ( !elems ) {\n    return;\n  }\n  // if string, use argument as selector string\n  if ( typeof elems == 'string' ) {\n    elems = this.element.querySelectorAll( elems );\n  }\n  elems = utils.makeArray( elems );\n  return elems;\n};\n\nproto._manageStamps = function() {\n  if ( !this.stamps || !this.stamps.length ) {\n    return;\n  }\n\n  this._getBoundingRect();\n\n  this.stamps.forEach( this._manageStamp, this );\n};\n\n// update boundingLeft / Top\nproto._getBoundingRect = function() {\n  // get bounding rect for container element\n  var boundingRect = this.element.getBoundingClientRect();\n  var size = this.size;\n  this._boundingRect = {\n    left: boundingRect.left + size.paddingLeft + size.borderLeftWidth,\n    top: boundingRect.top + size.paddingTop + size.borderTopWidth,\n    right: boundingRect.right - ( size.paddingRight + size.borderRightWidth ),\n    bottom: boundingRect.bottom - ( size.paddingBottom + size.borderBottomWidth )\n  };\n};\n\n/**\n * @param {Element} stamp\n**/\nproto._manageStamp = noop;\n\n/**\n * get x/y position of element relative to container element\n * @param {Element} elem\n * @returns {Object} offset - has left, top, right, bottom\n */\nproto._getElementOffset = function( elem ) {\n  var boundingRect = elem.getBoundingClientRect();\n  var thisRect = this._boundingRect;\n  var size = getSize( elem );\n  var offset = {\n    left: boundingRect.left - thisRect.left - size.marginLeft,\n    top: boundingRect.top - thisRect.top - size.marginTop,\n    right: thisRect.right - boundingRect.right - size.marginRight,\n    bottom: thisRect.bottom - boundingRect.bottom - size.marginBottom\n  };\n  return offset;\n};\n\n// -------------------------- resize -------------------------- //\n\n// enable event handlers for listeners\n// i.e. resize -> onresize\nproto.handleEvent = utils.handleEvent;\n\n/**\n * Bind layout to window resizing\n */\nproto.bindResize = function() {\n  window.addEventListener( 'resize', this );\n  this.isResizeBound = true;\n};\n\n/**\n * Unbind layout to window resizing\n */\nproto.unbindResize = function() {\n  window.removeEventListener( 'resize', this );\n  this.isResizeBound = false;\n};\n\nproto.onresize = function() {\n  this.resize();\n};\n\nutils.debounceMethod( Outlayer, 'onresize', 100 );\n\nproto.resize = function() {\n  // don't trigger if size did not change\n  // or if resize was unbound. See #9\n  if ( !this.isResizeBound || !this.needsResizeLayout() ) {\n    return;\n  }\n\n  this.layout();\n};\n\n/**\n * check if layout is needed post layout\n * @returns Boolean\n */\nproto.needsResizeLayout = function() {\n  var size = getSize( this.element );\n  // check that this.size and size are there\n  // IE8 triggers resize on body size change, so they might not be\n  var hasSizes = this.size && size;\n  return hasSizes && size.innerWidth !== this.size.innerWidth;\n};\n\n// -------------------------- methods -------------------------- //\n\n/**\n * add items to Outlayer instance\n * @param {Array or NodeList or Element} elems\n * @returns {Array} items - Outlayer.Items\n**/\nproto.addItems = function( elems ) {\n  var items = this._itemize( elems );\n  // add items to collection\n  if ( items.length ) {\n    this.items = this.items.concat( items );\n  }\n  return items;\n};\n\n/**\n * Layout newly-appended item elements\n * @param {Array or NodeList or Element} elems\n */\nproto.appended = function( elems ) {\n  var items = this.addItems( elems );\n  if ( !items.length ) {\n    return;\n  }\n  // layout and reveal just the new items\n  this.layoutItems( items, true );\n  this.reveal( items );\n};\n\n/**\n * Layout prepended elements\n * @param {Array or NodeList or Element} elems\n */\nproto.prepended = function( elems ) {\n  var items = this._itemize( elems );\n  if ( !items.length ) {\n    return;\n  }\n  // add items to beginning of collection\n  var previousItems = this.items.slice(0);\n  this.items = items.concat( previousItems );\n  // start new layout\n  this._resetLayout();\n  this._manageStamps();\n  // layout new stuff without transition\n  this.layoutItems( items, true );\n  this.reveal( items );\n  // layout previous items\n  this.layoutItems( previousItems );\n};\n\n/**\n * reveal a collection of items\n * @param {Array of Outlayer.Items} items\n */\nproto.reveal = function( items ) {\n  this._emitCompleteOnItems( 'reveal', items );\n  if ( !items || !items.length ) {\n    return;\n  }\n  var stagger = this.updateStagger();\n  items.forEach( function( item, i ) {\n    item.stagger( i * stagger );\n    item.reveal();\n  });\n};\n\n/**\n * hide a collection of items\n * @param {Array of Outlayer.Items} items\n */\nproto.hide = function( items ) {\n  this._emitCompleteOnItems( 'hide', items );\n  if ( !items || !items.length ) {\n    return;\n  }\n  var stagger = this.updateStagger();\n  items.forEach( function( item, i ) {\n    item.stagger( i * stagger );\n    item.hide();\n  });\n};\n\n/**\n * reveal item elements\n * @param {Array}, {Element}, {NodeList} items\n */\nproto.revealItemElements = function( elems ) {\n  var items = this.getItems( elems );\n  this.reveal( items );\n};\n\n/**\n * hide item elements\n * @param {Array}, {Element}, {NodeList} items\n */\nproto.hideItemElements = function( elems ) {\n  var items = this.getItems( elems );\n  this.hide( items );\n};\n\n/**\n * get Outlayer.Item, given an Element\n * @param {Element} elem\n * @param {Function} callback\n * @returns {Outlayer.Item} item\n */\nproto.getItem = function( elem ) {\n  // loop through items to get the one that matches\n  for ( var i=0; i < this.items.length; i++ ) {\n    var item = this.items[i];\n    if ( item.element == elem ) {\n      // return item\n      return item;\n    }\n  }\n};\n\n/**\n * get collection of Outlayer.Items, given Elements\n * @param {Array} elems\n * @returns {Array} items - Outlayer.Items\n */\nproto.getItems = function( elems ) {\n  elems = utils.makeArray( elems );\n  var items = [];\n  elems.forEach( function( elem ) {\n    var item = this.getItem( elem );\n    if ( item ) {\n      items.push( item );\n    }\n  }, this );\n\n  return items;\n};\n\n/**\n * remove element(s) from instance and DOM\n * @param {Array or NodeList or Element} elems\n */\nproto.remove = function( elems ) {\n  var removeItems = this.getItems( elems );\n\n  this._emitCompleteOnItems( 'remove', removeItems );\n\n  // bail if no items to remove\n  if ( !removeItems || !removeItems.length ) {\n    return;\n  }\n\n  removeItems.forEach( function( item ) {\n    item.remove();\n    // remove item from collection\n    utils.removeFrom( this.items, item );\n  }, this );\n};\n\n// ----- destroy ----- //\n\n// remove and disable Outlayer instance\nproto.destroy = function() {\n  // clean up dynamic styles\n  var style = this.element.style;\n  style.height = '';\n  style.position = '';\n  style.width = '';\n  // destroy items\n  this.items.forEach( function( item ) {\n    item.destroy();\n  });\n\n  this.unbindResize();\n\n  var id = this.element.outlayerGUID;\n  delete instances[ id ]; // remove reference to instance by id\n  delete this.element.outlayerGUID;\n  // remove data for jQuery\n  if ( jQuery ) {\n    jQuery.removeData( this.element, this.constructor.namespace );\n  }\n\n};\n\n// -------------------------- data -------------------------- //\n\n/**\n * get Outlayer instance from element\n * @param {Element} elem\n * @returns {Outlayer}\n */\nOutlayer.data = function( elem ) {\n  elem = utils.getQueryElement( elem );\n  var id = elem && elem.outlayerGUID;\n  return id && instances[ id ];\n};\n\n\n// -------------------------- create Outlayer class -------------------------- //\n\n/**\n * create a layout class\n * @param {String} namespace\n */\nOutlayer.create = function( namespace, options ) {\n  // sub-class Outlayer\n  var Layout = subclass( Outlayer );\n  // apply new options and compatOptions\n  Layout.defaults = utils.extend( {}, Outlayer.defaults );\n  utils.extend( Layout.defaults, options );\n  Layout.compatOptions = utils.extend( {}, Outlayer.compatOptions  );\n\n  Layout.namespace = namespace;\n\n  Layout.data = Outlayer.data;\n\n  // sub-class Item\n  Layout.Item = subclass( Item );\n\n  // -------------------------- declarative -------------------------- //\n\n  utils.htmlInit( Layout, namespace );\n\n  // -------------------------- jQuery bridge -------------------------- //\n\n  // make into jQuery plugin\n  if ( jQuery && jQuery.bridget ) {\n    jQuery.bridget( namespace, Layout );\n  }\n\n  return Layout;\n};\n\nfunction subclass( Parent ) {\n  function SubClass() {\n    Parent.apply( this, arguments );\n  }\n\n  SubClass.prototype = Object.create( Parent.prototype );\n  SubClass.prototype.constructor = SubClass;\n\n  return SubClass;\n}\n\n// ----- helpers ----- //\n\n// how many milliseconds are in each unit\nvar msUnits = {\n  ms: 1,\n  s: 1000\n};\n\n// munge time-like parameter into millisecond number\n// '0.4s' -> 40\nfunction getMilliseconds( time ) {\n  if ( typeof time == 'number' ) {\n    return time;\n  }\n  var matches = time.match( /(^\\d*\\.?\\d*)(\\w*)/ );\n  var num = matches && matches[1];\n  var unit = matches && matches[2];\n  if ( !num.length ) {\n    return 0;\n  }\n  num = parseFloat( num );\n  var mult = msUnits[ unit ] || 1;\n  return num * mult;\n}\n\n// ----- fin ----- //\n\n// back in global\nOutlayer.Item = Item;\n\nreturn Outlayer;\n\n}));\n","/**\n * Fizzy UI utils v2.0.7\n * MIT license\n */\n\n/*jshint browser: true, undef: true, unused: true, strict: true */\n\n( function( window, factory ) {\n  // universal module definition\n  /*jshint strict: false */ /*globals define, module, require */\n\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD\n    define( [\n      'desandro-matches-selector/matches-selector'\n    ], function( matchesSelector ) {\n      return factory( window, matchesSelector );\n    });\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS\n    module.exports = factory(\n      window,\n      require('desandro-matches-selector')\n    );\n  } else {\n    // browser global\n    window.fizzyUIUtils = factory(\n      window,\n      window.matchesSelector\n    );\n  }\n\n}( window, function factory( window, matchesSelector ) {\n\n'use strict';\n\nvar utils = {};\n\n// ----- extend ----- //\n\n// extends objects\nutils.extend = function( a, b ) {\n  for ( var prop in b ) {\n    a[ prop ] = b[ prop ];\n  }\n  return a;\n};\n\n// ----- modulo ----- //\n\nutils.modulo = function( num, div ) {\n  return ( ( num % div ) + div ) % div;\n};\n\n// ----- makeArray ----- //\n\nvar arraySlice = Array.prototype.slice;\n\n// turn element or nodeList into an array\nutils.makeArray = function( obj ) {\n  if ( Array.isArray( obj ) ) {\n    // use object if already an array\n    return obj;\n  }\n  // return empty array if undefined or null. #6\n  if ( obj === null || obj === undefined ) {\n    return [];\n  }\n\n  var isArrayLike = typeof obj == 'object' && typeof obj.length == 'number';\n  if ( isArrayLike ) {\n    // convert nodeList to array\n    return arraySlice.call( obj );\n  }\n\n  // array of single index\n  return [ obj ];\n};\n\n// ----- removeFrom ----- //\n\nutils.removeFrom = function( ary, obj ) {\n  var index = ary.indexOf( obj );\n  if ( index != -1 ) {\n    ary.splice( index, 1 );\n  }\n};\n\n// ----- getParent ----- //\n\nutils.getParent = function( elem, selector ) {\n  while ( elem.parentNode && elem != document.body ) {\n    elem = elem.parentNode;\n    if ( matchesSelector( elem, selector ) ) {\n      return elem;\n    }\n  }\n};\n\n// ----- getQueryElement ----- //\n\n// use element as selector string\nutils.getQueryElement = function( elem ) {\n  if ( typeof elem == 'string' ) {\n    return document.querySelector( elem );\n  }\n  return elem;\n};\n\n// ----- handleEvent ----- //\n\n// enable .ontype to trigger from .addEventListener( elem, 'type' )\nutils.handleEvent = function( event ) {\n  var method = 'on' + event.type;\n  if ( this[ method ] ) {\n    this[ method ]( event );\n  }\n};\n\n// ----- filterFindElements ----- //\n\nutils.filterFindElements = function( elems, selector ) {\n  // make array of elems\n  elems = utils.makeArray( elems );\n  var ffElems = [];\n\n  elems.forEach( function( elem ) {\n    // check that elem is an actual element\n    if ( !( elem instanceof HTMLElement ) ) {\n      return;\n    }\n    // add elem if no selector\n    if ( !selector ) {\n      ffElems.push( elem );\n      return;\n    }\n    // filter & find items if we have a selector\n    // filter\n    if ( matchesSelector( elem, selector ) ) {\n      ffElems.push( elem );\n    }\n    // find children\n    var childElems = elem.querySelectorAll( selector );\n    // concat childElems to filterFound array\n    for ( var i=0; i < childElems.length; i++ ) {\n      ffElems.push( childElems[i] );\n    }\n  });\n\n  return ffElems;\n};\n\n// ----- debounceMethod ----- //\n\nutils.debounceMethod = function( _class, methodName, threshold ) {\n  threshold = threshold || 100;\n  // original method\n  var method = _class.prototype[ methodName ];\n  var timeoutName = methodName + 'Timeout';\n\n  _class.prototype[ methodName ] = function() {\n    var timeout = this[ timeoutName ];\n    clearTimeout( timeout );\n\n    var args = arguments;\n    var _this = this;\n    this[ timeoutName ] = setTimeout( function() {\n      method.apply( _this, args );\n      delete _this[ timeoutName ];\n    }, threshold );\n  };\n};\n\n// ----- docReady ----- //\n\nutils.docReady = function( callback ) {\n  var readyState = document.readyState;\n  if ( readyState == 'complete' || readyState == 'interactive' ) {\n    // do async to allow for other scripts to run. metafizzy/flickity#441\n    setTimeout( callback );\n  } else {\n    document.addEventListener( 'DOMContentLoaded', callback );\n  }\n};\n\n// ----- htmlInit ----- //\n\n// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/\nutils.toDashed = function( str ) {\n  return str.replace( /(.)([A-Z])/g, function( match, $1, $2 ) {\n    return $1 + '-' + $2;\n  }).toLowerCase();\n};\n\nvar console = window.console;\n/**\n * allow user to initialize classes via [data-namespace] or .js-namespace class\n * htmlInit( Widget, 'widgetName' )\n * options are parsed from data-namespace-options\n */\nutils.htmlInit = function( WidgetClass, namespace ) {\n  utils.docReady( function() {\n    var dashedNamespace = utils.toDashed( namespace );\n    var dataAttr = 'data-' + dashedNamespace;\n    var dataAttrElems = document.querySelectorAll( '[' + dataAttr + ']' );\n    var jsDashElems = document.querySelectorAll( '.js-' + dashedNamespace );\n    var elems = utils.makeArray( dataAttrElems )\n      .concat( utils.makeArray( jsDashElems ) );\n    var dataOptionsAttr = dataAttr + '-options';\n    var jQuery = window.jQuery;\n\n    elems.forEach( function( elem ) {\n      var attr = elem.getAttribute( dataAttr ) ||\n        elem.getAttribute( dataOptionsAttr );\n      var options;\n      try {\n        options = attr && JSON.parse( attr );\n      } catch ( error ) {\n        // log error, do not initialize\n        if ( console ) {\n          console.error( 'Error parsing ' + dataAttr + ' on ' + elem.className +\n          ': ' + error );\n        }\n        return;\n      }\n      // initialize\n      var instance = new WidgetClass( elem, options );\n      // make available via $().data('namespace')\n      if ( jQuery ) {\n        jQuery.data( elem, namespace, instance );\n      }\n    });\n\n  });\n};\n\n// -----  ----- //\n\nreturn utils;\n\n}));\n","/**\n * matchesSelector v2.0.2\n * matchesSelector( element, '.selector' )\n * MIT license\n */\n\n/*jshint browser: true, strict: true, undef: true, unused: true */\n\n( function( window, factory ) {\n  /*global define: false, module: false */\n  'use strict';\n  // universal module definition\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD\n    define( factory );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS\n    module.exports = factory();\n  } else {\n    // browser global\n    window.matchesSelector = factory();\n  }\n\n}( window, function factory() {\n  'use strict';\n\n  var matchesMethod = ( function() {\n    var ElemProto = window.Element.prototype;\n    // check for the standard method name first\n    if ( ElemProto.matches ) {\n      return 'matches';\n    }\n    // check un-prefixed\n    if ( ElemProto.matchesSelector ) {\n      return 'matchesSelector';\n    }\n    // check vendor prefixes\n    var prefixes = [ 'webkit', 'moz', 'ms', 'o' ];\n\n    for ( var i=0; i < prefixes.length; i++ ) {\n      var prefix = prefixes[i];\n      var method = prefix + 'MatchesSelector';\n      if ( ElemProto[ method ] ) {\n        return method;\n      }\n    }\n  })();\n\n  return function matchesSelector( elem, selector ) {\n    return elem[ matchesMethod ]( selector );\n  };\n\n}));\n","/**\n * Outlayer Item\n */\n\n( function( window, factory ) {\n  // universal module definition\n  /* jshint strict: false */ /* globals define, module, require */\n  if ( typeof define == 'function' && define.amd ) {\n    // AMD - RequireJS\n    define( [\n        'ev-emitter/ev-emitter',\n        'get-size/get-size'\n      ],\n      factory\n    );\n  } else if ( typeof module == 'object' && module.exports ) {\n    // CommonJS - Browserify, Webpack\n    module.exports = factory(\n      require('ev-emitter'),\n      require('get-size')\n    );\n  } else {\n    // browser global\n    window.Outlayer = {};\n    window.Outlayer.Item = factory(\n      window.EvEmitter,\n      window.getSize\n    );\n  }\n\n}( window, function factory( EvEmitter, getSize ) {\n'use strict';\n\n// ----- helpers ----- //\n\nfunction isEmptyObj( obj ) {\n  for ( var prop in obj ) {\n    return false;\n  }\n  prop = null;\n  return true;\n}\n\n// -------------------------- CSS3 support -------------------------- //\n\n\nvar docElemStyle = document.documentElement.style;\n\nvar transitionProperty = typeof docElemStyle.transition == 'string' ?\n  'transition' : 'WebkitTransition';\nvar transformProperty = typeof docElemStyle.transform == 'string' ?\n  'transform' : 'WebkitTransform';\n\nvar transitionEndEvent = {\n  WebkitTransition: 'webkitTransitionEnd',\n  transition: 'transitionend'\n}[ transitionProperty ];\n\n// cache all vendor properties that could have vendor prefix\nvar vendorProperties = {\n  transform: transformProperty,\n  transition: transitionProperty,\n  transitionDuration: transitionProperty + 'Duration',\n  transitionProperty: transitionProperty + 'Property',\n  transitionDelay: transitionProperty + 'Delay'\n};\n\n// -------------------------- Item -------------------------- //\n\nfunction Item( element, layout ) {\n  if ( !element ) {\n    return;\n  }\n\n  this.element = element;\n  // parent layout class, i.e. Masonry, Isotope, or Packery\n  this.layout = layout;\n  this.position = {\n    x: 0,\n    y: 0\n  };\n\n  this._create();\n}\n\n// inherit EvEmitter\nvar proto = Item.prototype = Object.create( EvEmitter.prototype );\nproto.constructor = Item;\n\nproto._create = function() {\n  // transition objects\n  this._transn = {\n    ingProperties: {},\n    clean: {},\n    onEnd: {}\n  };\n\n  this.css({\n    position: 'absolute'\n  });\n};\n\n// trigger specified handler for event type\nproto.handleEvent = function( event ) {\n  var method = 'on' + event.type;\n  if ( this[ method ] ) {\n    this[ method ]( event );\n  }\n};\n\nproto.getSize = function() {\n  this.size = getSize( this.element );\n};\n\n/**\n * apply CSS styles to element\n * @param {Object} style\n */\nproto.css = function( style ) {\n  var elemStyle = this.element.style;\n\n  for ( var prop in style ) {\n    // use vendor property if available\n    var supportedProp = vendorProperties[ prop ] || prop;\n    elemStyle[ supportedProp ] = style[ prop ];\n  }\n};\n\n // measure position, and sets it\nproto.getPosition = function() {\n  var style = getComputedStyle( this.element );\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n  var xValue = style[ isOriginLeft ? 'left' : 'right' ];\n  var yValue = style[ isOriginTop ? 'top' : 'bottom' ];\n  var x = parseFloat( xValue );\n  var y = parseFloat( yValue );\n  // convert percent to pixels\n  var layoutSize = this.layout.size;\n  if ( xValue.indexOf('%') != -1 ) {\n    x = ( x / 100 ) * layoutSize.width;\n  }\n  if ( yValue.indexOf('%') != -1 ) {\n    y = ( y / 100 ) * layoutSize.height;\n  }\n  // clean up 'auto' or other non-integer values\n  x = isNaN( x ) ? 0 : x;\n  y = isNaN( y ) ? 0 : y;\n  // remove padding from measurement\n  x -= isOriginLeft ? layoutSize.paddingLeft : layoutSize.paddingRight;\n  y -= isOriginTop ? layoutSize.paddingTop : layoutSize.paddingBottom;\n\n  this.position.x = x;\n  this.position.y = y;\n};\n\n// set settled position, apply padding\nproto.layoutPosition = function() {\n  var layoutSize = this.layout.size;\n  var style = {};\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n\n  // x\n  var xPadding = isOriginLeft ? 'paddingLeft' : 'paddingRight';\n  var xProperty = isOriginLeft ? 'left' : 'right';\n  var xResetProperty = isOriginLeft ? 'right' : 'left';\n\n  var x = this.position.x + layoutSize[ xPadding ];\n  // set in percentage or pixels\n  style[ xProperty ] = this.getXValue( x );\n  // reset other property\n  style[ xResetProperty ] = '';\n\n  // y\n  var yPadding = isOriginTop ? 'paddingTop' : 'paddingBottom';\n  var yProperty = isOriginTop ? 'top' : 'bottom';\n  var yResetProperty = isOriginTop ? 'bottom' : 'top';\n\n  var y = this.position.y + layoutSize[ yPadding ];\n  // set in percentage or pixels\n  style[ yProperty ] = this.getYValue( y );\n  // reset other property\n  style[ yResetProperty ] = '';\n\n  this.css( style );\n  this.emitEvent( 'layout', [ this ] );\n};\n\nproto.getXValue = function( x ) {\n  var isHorizontal = this.layout._getOption('horizontal');\n  return this.layout.options.percentPosition && !isHorizontal ?\n    ( ( x / this.layout.size.width ) * 100 ) + '%' : x + 'px';\n};\n\nproto.getYValue = function( y ) {\n  var isHorizontal = this.layout._getOption('horizontal');\n  return this.layout.options.percentPosition && isHorizontal ?\n    ( ( y / this.layout.size.height ) * 100 ) + '%' : y + 'px';\n};\n\nproto._transitionTo = function( x, y ) {\n  this.getPosition();\n  // get current x & y from top/left\n  var curX = this.position.x;\n  var curY = this.position.y;\n\n  var didNotMove = x == this.position.x && y == this.position.y;\n\n  // save end position\n  this.setPosition( x, y );\n\n  // if did not move and not transitioning, just go to layout\n  if ( didNotMove && !this.isTransitioning ) {\n    this.layoutPosition();\n    return;\n  }\n\n  var transX = x - curX;\n  var transY = y - curY;\n  var transitionStyle = {};\n  transitionStyle.transform = this.getTranslate( transX, transY );\n\n  this.transition({\n    to: transitionStyle,\n    onTransitionEnd: {\n      transform: this.layoutPosition\n    },\n    isCleaning: true\n  });\n};\n\nproto.getTranslate = function( x, y ) {\n  // flip cooridinates if origin on right or bottom\n  var isOriginLeft = this.layout._getOption('originLeft');\n  var isOriginTop = this.layout._getOption('originTop');\n  x = isOriginLeft ? x : -x;\n  y = isOriginTop ? y : -y;\n  return 'translate3d(' + x + 'px, ' + y + 'px, 0)';\n};\n\n// non transition + transform support\nproto.goTo = function( x, y ) {\n  this.setPosition( x, y );\n  this.layoutPosition();\n};\n\nproto.moveTo = proto._transitionTo;\n\nproto.setPosition = function( x, y ) {\n  this.position.x = parseFloat( x );\n  this.position.y = parseFloat( y );\n};\n\n// ----- transition ----- //\n\n/**\n * @param {Object} style - CSS\n * @param {Function} onTransitionEnd\n */\n\n// non transition, just trigger callback\nproto._nonTransition = function( args ) {\n  this.css( args.to );\n  if ( args.isCleaning ) {\n    this._removeStyles( args.to );\n  }\n  for ( var prop in args.onTransitionEnd ) {\n    args.onTransitionEnd[ prop ].call( this );\n  }\n};\n\n/**\n * proper transition\n * @param {Object} args - arguments\n *   @param {Object} to - style to transition to\n *   @param {Object} from - style to start transition from\n *   @param {Boolean} isCleaning - removes transition styles after transition\n *   @param {Function} onTransitionEnd - callback\n */\nproto.transition = function( args ) {\n  // redirect to nonTransition if no transition duration\n  if ( !parseFloat( this.layout.options.transitionDuration ) ) {\n    this._nonTransition( args );\n    return;\n  }\n\n  var _transition = this._transn;\n  // keep track of onTransitionEnd callback by css property\n  for ( var prop in args.onTransitionEnd ) {\n    _transition.onEnd[ prop ] = args.onTransitionEnd[ prop ];\n  }\n  // keep track of properties that are transitioning\n  for ( prop in args.to ) {\n    _transition.ingProperties[ prop ] = true;\n    // keep track of properties to clean up when transition is done\n    if ( args.isCleaning ) {\n      _transition.clean[ prop ] = true;\n    }\n  }\n\n  // set from styles\n  if ( args.from ) {\n    this.css( args.from );\n    // force redraw. http://blog.alexmaccaw.com/css-transitions\n    var h = this.element.offsetHeight;\n    // hack for JSHint to hush about unused var\n    h = null;\n  }\n  // enable transition\n  this.enableTransition( args.to );\n  // set styles that are transitioning\n  this.css( args.to );\n\n  this.isTransitioning = true;\n\n};\n\n// dash before all cap letters, including first for\n// WebkitTransform => -webkit-transform\nfunction toDashedAll( str ) {\n  return str.replace( /([A-Z])/g, function( $1 ) {\n    return '-' + $1.toLowerCase();\n  });\n}\n\nvar transitionProps = 'opacity,' + toDashedAll( transformProperty );\n\nproto.enableTransition = function(/* style */) {\n  // HACK changing transitionProperty during a transition\n  // will cause transition to jump\n  if ( this.isTransitioning ) {\n    return;\n  }\n\n  // make `transition: foo, bar, baz` from style object\n  // HACK un-comment this when enableTransition can work\n  // while a transition is happening\n  // var transitionValues = [];\n  // for ( var prop in style ) {\n  //   // dash-ify camelCased properties like WebkitTransition\n  //   prop = vendorProperties[ prop ] || prop;\n  //   transitionValues.push( toDashedAll( prop ) );\n  // }\n  // munge number to millisecond, to match stagger\n  var duration = this.layout.options.transitionDuration;\n  duration = typeof duration == 'number' ? duration + 'ms' : duration;\n  // enable transition styles\n  this.css({\n    transitionProperty: transitionProps,\n    transitionDuration: duration,\n    transitionDelay: this.staggerDelay || 0\n  });\n  // listen for transition end event\n  this.element.addEventListener( transitionEndEvent, this, false );\n};\n\n// ----- events ----- //\n\nproto.onwebkitTransitionEnd = function( event ) {\n  this.ontransitionend( event );\n};\n\nproto.onotransitionend = function( event ) {\n  this.ontransitionend( event );\n};\n\n// properties that I munge to make my life easier\nvar dashedVendorProperties = {\n  '-webkit-transform': 'transform'\n};\n\nproto.ontransitionend = function( event ) {\n  // disregard bubbled events from children\n  if ( event.target !== this.element ) {\n    return;\n  }\n  var _transition = this._transn;\n  // get property name of transitioned property, convert to prefix-free\n  var propertyName = dashedVendorProperties[ event.propertyName ] || event.propertyName;\n\n  // remove property that has completed transitioning\n  delete _transition.ingProperties[ propertyName ];\n  // check if any properties are still transitioning\n  if ( isEmptyObj( _transition.ingProperties ) ) {\n    // all properties have completed transitioning\n    this.disableTransition();\n  }\n  // clean style\n  if ( propertyName in _transition.clean ) {\n    // clean up style\n    this.element.style[ event.propertyName ] = '';\n    delete _transition.clean[ propertyName ];\n  }\n  // trigger onTransitionEnd callback\n  if ( propertyName in _transition.onEnd ) {\n    var onTransitionEnd = _transition.onEnd[ propertyName ];\n    onTransitionEnd.call( this );\n    delete _transition.onEnd[ propertyName ];\n  }\n\n  this.emitEvent( 'transitionEnd', [ this ] );\n};\n\nproto.disableTransition = function() {\n  this.removeTransitionStyles();\n  this.element.removeEventListener( transitionEndEvent, this, false );\n  this.isTransitioning = false;\n};\n\n/**\n * removes style property from element\n * @param {Object} style\n**/\nproto._removeStyles = function( style ) {\n  // clean up transition styles\n  var cleanStyle = {};\n  for ( var prop in style ) {\n    cleanStyle[ prop ] = '';\n  }\n  this.css( cleanStyle );\n};\n\nvar cleanTransitionStyle = {\n  transitionProperty: '',\n  transitionDuration: '',\n  transitionDelay: ''\n};\n\nproto.removeTransitionStyles = function() {\n  // remove transition\n  this.css( cleanTransitionStyle );\n};\n\n// ----- stagger ----- //\n\nproto.stagger = function( delay ) {\n  delay = isNaN( delay ) ? 0 : delay;\n  this.staggerDelay = delay + 'ms';\n};\n\n// ----- show/hide/remove ----- //\n\n// remove element from DOM\nproto.removeElem = function() {\n  this.element.parentNode.removeChild( this.element );\n  // remove display: none\n  this.css({ display: '' });\n  this.emitEvent( 'remove', [ this ] );\n};\n\nproto.remove = function() {\n  // just remove element if no transition support or no transition\n  if ( !transitionProperty || !parseFloat( this.layout.options.transitionDuration ) ) {\n    this.removeElem();\n    return;\n  }\n\n  // start transition\n  this.once( 'transitionEnd', function() {\n    this.removeElem();\n  });\n  this.hide();\n};\n\nproto.reveal = function() {\n  delete this.isHidden;\n  // remove display: none\n  this.css({ display: '' });\n\n  var options = this.layout.options;\n\n  var onTransitionEnd = {};\n  var transitionEndProperty = this.getHideRevealTransitionEndProperty('visibleStyle');\n  onTransitionEnd[ transitionEndProperty ] = this.onRevealTransitionEnd;\n\n  this.transition({\n    from: options.hiddenStyle,\n    to: options.visibleStyle,\n    isCleaning: true,\n    onTransitionEnd: onTransitionEnd\n  });\n};\n\nproto.onRevealTransitionEnd = function() {\n  // check if still visible\n  // during transition, item may have been hidden\n  if ( !this.isHidden ) {\n    this.emitEvent('reveal');\n  }\n};\n\n/**\n * get style property use for hide/reveal transition end\n * @param {String} styleProperty - hiddenStyle/visibleStyle\n * @returns {String}\n */\nproto.getHideRevealTransitionEndProperty = function( styleProperty ) {\n  var optionStyle = this.layout.options[ styleProperty ];\n  // use opacity\n  if ( optionStyle.opacity ) {\n    return 'opacity';\n  }\n  // get first property\n  for ( var prop in optionStyle ) {\n    return prop;\n  }\n};\n\nproto.hide = function() {\n  // set flag\n  this.isHidden = true;\n  // remove display: none\n  this.css({ display: '' });\n\n  var options = this.layout.options;\n\n  var onTransitionEnd = {};\n  var transitionEndProperty = this.getHideRevealTransitionEndProperty('hiddenStyle');\n  onTransitionEnd[ transitionEndProperty ] = this.onHideTransitionEnd;\n\n  this.transition({\n    from: options.visibleStyle,\n    to: options.hiddenStyle,\n    // keep hidden stuff hidden\n    isCleaning: true,\n    onTransitionEnd: onTransitionEnd\n  });\n};\n\nproto.onHideTransitionEnd = function() {\n  // check if still hidden\n  // during transition, item may have been un-hidden\n  if ( this.isHidden ) {\n    this.css({ display: 'none' });\n    this.emitEvent('hide');\n  }\n};\n\nproto.destroy = function() {\n  this.css({\n    position: '',\n    left: '',\n    right: '',\n    top: '',\n    bottom: '',\n    transition: '',\n    transform: ''\n  });\n};\n\nreturn Item;\n\n}));\n"],"sourceRoot":""}