https://www.carezimbabwe.org/wp-content/themes/careorg/assets/js/source.dev.js?ver=1.0.0

188}
189
190function listScrollParents(element,list){
191if(list===void 0){
192list=[];
193}
194
195var scrollParent=getScrollParent(element);
196var isBody=getNodeName(scrollParent)==='body';
197var win=getWindow(scrollParent);
198var target=isBody?[win].concat(win.visualViewport||[]):scrollParent;
199var updatedList=list.concat(target);
200return isBody?updatedList:// $FlowFixMe: isBody tells us target will be an HTMLElement here
201updatedList.concat(listScrollParents(getParentNode(target)));
202}
203
204function isTableElement(element){
205return['table','td','th'].indexOf(getNodeName(element))>=0;
206}
207
208function getTrueOffsetParent(element){
209if(!isHTMLElement(element)||// https://github.com/popperjs/popper-core/issues/837
210getComputedStyle(element).position==='fixed'){
211return null;
212}
213
214return element.offsetParent;
215}
216
217function getOffsetParent(element){
218var window=getWindow(element);
219var offsetParent=getTrueOffsetParent(element);// Find the nearest non-table offsetParent
220
221while(offsetParent&&isTableElement(offsetParent)){
222offsetParent=getTrueOffsetParent(offsetParent);
223}
224
225if(offsetParent&&getNodeName(offsetParent)==='body'&&getComputedStyle(offsetParent).position==='static'){
226return window;
227}
228
229return offsetParent||window;
230}
231
232var top='top';
233var bottom='bottom';
234var right='right';
235var left='left';
236var auto='auto';
237var basePlacements=[top,bottom,right,left];
238var start='start';
239var end='end';
240var clippingParents='clippingParents';
241var viewport='viewport';
242var popper='popper';
243var reference='reference';
244var variationPlacements=/*#__PURE__*/basePlacements.reduce(function(acc,placement){
245return acc.concat([placement+"-"+start,placement+"-"+end]);
246},[]);
247var placements=/*#__PURE__*/[].concat(basePlacements,[auto]).reduce(function(acc,placement){
248return acc.concat([placement,placement+"-"+start,placement+"-"+end]);
249},[]);// modifiers that need to read the DOM
250
251var beforeRead='beforeRead';
252var read='read';
253var afterRead='afterRead';// pure-logic modifiers
254
255var beforeMain='beforeMain';
256var main='main';
257var afterMain='afterMain';// modifier with the purpose to write to the DOM (or write into a framework state)
258
259var beforeWrite='beforeWrite';
260var write='write';
261var afterWrite='afterWrite';
262var modifierPhases=[beforeRead,read,afterRead,beforeMain,main,afterMain,beforeWrite,write,afterWrite];
263
264function order(modifiers){
265var map=new Map();
266var visited=new Set();
267var result=[];
268modifiers.forEach(function(modifier){
269map.set(modifier.name,modifier);
270});// On visiting object, check for its dependencies and visit them recursively
271
272function sort(modifier){
273visited.add(modifier.name);
274var requires=[].concat(modifier.requires||[],modifier.requiresIfExists||[]);
275requires.forEach(function(dep){
276if(!visited.has(dep)){
277var depModifier=map.get(dep);
278
279if(depModifier){
280sort(depModifier);
281}
282}
283});
284result.push(modifier);
285}
286
287modifiers.forEach(function(modifier){
288if(!visited.has(modifier.name)){
289// check for visited object
290sort(modifier);
291}
292});
293return result;
294}
295
296function orderModifiers(modifiers){
297// order based on dependencies
298var orderedModifiers=order(modifiers);// order based on phase
299
300return modifierPhases.reduce(function(acc,phase){
301return acc.concat(orderedModifiers.filter(function(modifier){
302return modifier.phase===phase;
303}));
304},[]);
305}
306
307function debounce(fn){
308var pending;
309return function(){
310if(!pending){
311pending=new Promise(function(resolve){
312Promise.resolve().then(function(){
313pending=undefined;
314resolve(fn());
315});
316});
317}
318
319return pending;
320};
321}
322
323function format(str){
324for(var _len=arguments.length,args=new Array(_len>1?_len-1:0),_key=1;_key<_len;_key++){
325args[_key-1]=arguments[_key];
326}
327
328return[].concat(args).reduce(function(p,c){
329return p.replace(/%s/,c);
330},str);
331}
332
333var INVALID_MODIFIER_ERROR='Popper: modifier "%s" provided an invalid %s property, expected %s but got %s';
334var MISSING_DEPENDENCY_ERROR='Popper: modifier "%s" requires "%s", but "%s" modifier is not available';
335var VALID_PROPERTIES=['name','enabled','phase','fn','effect','requires','options'];
336function validateModifiers(modifiers){

337modifiers.forEach(function(modifier){
338Object.keys(modifier).forEach(function(key){
339switch(key){
340case'name':
341if(typeof modifier.name!=='string'){
342console.error(format(INVALID_MODIFIER_ERROR,String(modifier.name),'"name"','"string"',"\""+String(modifier.name)+"\""));
343}
344
345break;
346
347case'enabled':
348if(typeof modifier.enabled!=='boolean'){
349console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"enabled"','"boolean"',"\""+String(modifier.enabled)+"\""));
350}
351
352case'phase':
353if(modifierPhases.indexOf(modifier.phase)<0){
354console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"phase"',"either "+modifierPhases.join(', '),"\""+String(modifier.phase)+"\""));
355}
356
357break;
358
359case'fn':
360if(typeof modifier.fn!=='function'){
361console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"fn"','"function"',"\""+String(modifier.fn)+"\""));
362}
363
364break;
365
366case'effect':
367if(typeof modifier.effect!=='function'){
368console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"effect"','"function"',"\""+String(modifier.fn)+"\""));
369}
370
371break;
372
373case'requires':
374if(!Array.isArray(modifier.requires)){
375console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"requires"','"array"',"\""+String(modifier.requires)+"\""));
376}
377
378break;
379
380case'requiresIfExists':
381if(!Array.isArray(modifier.requiresIfExists)){
382console.error(format(INVALID_MODIFIER_ERROR,modifier.name,'"requiresIfExists"','"array"',"\""+String(modifier.requiresIfExists)+"\""));
383}
384
385break;
386
387case'options':
388case'data':
389break;
390
391default:
392console.error("PopperJS: an invalid property has been provided to the \""+modifier.name+"\" modifier, valid properties are "+VALID_PROPERTIES.map(function(s){
393return"\""+s+"\"";
394}).join(', ')+"; but \""+key+"\" was provided.");}
395
396
397modifier.requires&&modifier.requires.forEach(function(requirement){
398if(modifiers.find(function(mod){
399return mod.name===requirement;
400})==null){
401console.error(format(MISSING_DEPENDENCY_ERROR,String(modifier.name),requirement,requirement));
402}
403});
404});
405});
406}
407
408function uniqueBy(arr,fn){
409var identifiers=new Set();
410return arr.filter(function(item){
411var identifier=fn(item);
412
413if(!identifiers.has(identifier)){
414identifiers.add(identifier);
415return true;
416}
417});
418}
419
420function getBasePlacement(placement){
421return placement.split('-')[0];
422}
423
424function mergeByName(modifiers){
425var merged=modifiers.reduce(function(merged,current){
426var existing=merged[current.name];
427merged[current.name]=existing?Object.assign({},existing,{},current,{
428options:Object.assign({},existing.options,{},current.options),
429data:Object.assign({},existing.data,{},current.data)}):
430current;
431return merged;
432},{});// IE11 does not support Object.values
433
434return Object.keys(merged).map(function(key){
435return merged[key];
436});
437}
438
439var INVALID_ELEMENT_ERROR='Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.';
440var INFINITE_LOOP_ERROR='Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.';
441var DEFAULT_OPTIONS={
442placement:'bottom',
443modifiers:[],
444strategy:'absolute'};
445
446
447function areValidElements(){
448for(var _len=arguments.length,args=new Array(_len),_key=0;_key<_len;_key++){
449args[_key]=arguments[_key];
450}
451
452return!args.some(function(element){
453return!(element&&typeof element.getBoundingClientRect==='function');
454});
455}
456
457function popperGenerator(generatorOptions){
458if(generatorOptions===void 0){
459generatorOptions={};
460}
461
462var _generatorOptions=generatorOptions,
463_generatorOptions$def=_generatorOptions.defaultModifiers,
464defaultModifiers=_generatorOptions$def===void 0?[]:_generatorOptions$def,
465_generatorOptions$def2=_generatorOptions.defaultOptions,
466defaultOptions=_generatorOptions$def2===void 0?DEFAULT_OPTIONS:_generatorOptions$def2;
467return function createPopper(reference,popper,options){
468if(options===void 0){
469options=defaultOptions;
470}
471
472var state={
473placement:'bottom',
474orderedModifiers:[],
475options:Object.assign({},DEFAULT_OPTIONS,{},defaultOptions),
476modifiersData:{},
477elements:{
478reference:reference,
479popper:popper},
480
481attributes:{},
482styles:{}};
483
484var effectCleanupFns=[];
485var isDestroyed=false;
486var instance={
487state:state,
488setOptions:function setOptions(options){
489cleanupModifierEffects();
490state.options=Object.assign({},defaultOptions,{},state.options,{},options);
491state.scrollParents={
492reference:isElement(reference)?listScrollParents(reference):reference.contextElement?listScrollParents(reference.contextElement):[],
493popper:listScrollParents(popper)};
494// Orders the modifiers based on their dependencies and `phase`
495// properties
496
497var orderedModifiers=orderModifiers(mergeByName([].concat(defaultModifiers,state.options.modifiers)));// Strip out disabled modifiers
498
499state.orderedModifiers=orderedModifiers.filter(function(m){
500return m.enabled;
501});// Validate the provided modifiers so that the consumer will get warned

502// if one of the modifiers is invalid for any reason
503
504if(process.env.NODE_ENV!=="production"){
505var modifiers=uniqueBy([].concat(orderedModifiers,state.options.modifiers),function(_ref){
506var name=_ref.name;
507return name;
508});
509validateModifiers(modifiers);
510
511if(getBasePlacement(state.options.placement)===auto){
512var flipModifier=state.orderedModifiers.find(function(_ref2){
513var name=_ref2.name;
514return name==='flip';
515});
516
517if(!flipModifier){
518console.error(['Popper: "auto" placements require the "flip" modifier be','present and enabled to work.'].join(' '));
519}
520}
521
522var _getComputedStyle=getComputedStyle(popper),
523marginTop=_getComputedStyle.marginTop,
524marginRight=_getComputedStyle.marginRight,
525marginBottom=_getComputedStyle.marginBottom,
526marginLeft=_getComputedStyle.marginLeft;// We no longer take into account `margins` on the popper, and it can
527// cause bugs with positioning, so we'll warn the consumer
528
529
530if([marginTop,marginRight,marginBottom,marginLeft].some(function(margin){
531return parseFloat(margin);
532})){
533console.warn(['Popper: CSS "margin" styles cannot be used to apply padding','between the popper and its reference element or boundary.','To replicate margin, use the `offset` modifier, as well as','the `padding` option in the `preventOverflow` and `flip`','modifiers.'].join(' '));
534}
535}
536
537runModifierEffects();
538return instance.update();
539},
540// Sync update – it will always be executed, even if not necessary. This
541// is useful for low frequency updates where sync behavior simplifies the
542// logic.
543// For high frequency updates (e.g. `resize` and `scroll` events), always
544// prefer the async Popper#update method
545forceUpdate:function forceUpdate(){
546if(isDestroyed){
547return;
548}
549
550var _state$elements=state.elements,
551reference=_state$elements.reference,
552popper=_state$elements.popper;// Don't proceed if `reference` or `popper` are not valid elements
553// anymore
554
555if(!areValidElements(reference,popper)){
556if(process.env.NODE_ENV!=="production"){
557console.error(INVALID_ELEMENT_ERROR);
558}
559
560return;
561}// Store the reference and popper rects to be read by modifiers
562
563
564state.rects={
565reference:getCompositeRect(reference,getOffsetParent(popper),state.options.strategy==='fixed'),
566popper:getLayoutRect(popper)};
567// Modifiers have the ability to reset the current update cycle. The
568// most common use case for this is the `flip` modifier changing the
569// placement, which then needs to re-run all the modifiers, because the
570// logic was previously ran for the previous placement and is therefore
571// stale/incorrect
572
573state.reset=false;
574state.placement=state.options.placement;// On each update cycle, the `modifiersData` property for each modifier
575// is filled with the initial data specified by the modifier. This means
576// it doesn't persist and is fresh on each update.
577// To ensure persistent data, use `${name}#persistent`
578
579state.orderedModifiers.forEach(function(modifier){
580return state.modifiersData[modifier.name]=Object.assign({},modifier.data);
581});
582var __debug_loops__=0;
583
584for(var index=0;index<state.orderedModifiers.length;index++){
585if(process.env.NODE_ENV!=="production"){
586__debug_loops__+=1;
587
588if(__debug_loops__>100){
589console.error(INFINITE_LOOP_ERROR);
590break;
591}
592}
593
594if(state.reset===true){
595state.reset=false;
596index=-1;
597continue;
598}
599
600var _state$orderedModifie=state.orderedModifiers[index],
601fn=_state$orderedModifie.fn,
602_state$orderedModifie2=_state$orderedModifie.options,
603_options=_state$orderedModifie2===void 0?{}:_state$orderedModifie2,
604name=_state$orderedModifie.name;
605
606if(typeof fn==='function'){
607state=fn({
608state:state,
609options:_options,
610name:name,
611instance:instance})||
612state;
613}
614}
615},
616// Async and optimistically optimized update – it will not be executed if
617// not necessary (debounced to run at most once-per-tick)
618update:debounce(function(){
619return new Promise(function(resolve){
620instance.forceUpdate();
621resolve(state);
622});
623}),
624destroy:function destroy(){
625cleanupModifierEffects();
626isDestroyed=true;
627}};
628
629
630if(!areValidElements(reference,popper)){
631if(process.env.NODE_ENV!=="production"){
632console.error(INVALID_ELEMENT_ERROR);
633}
634
635return instance;
636}
637
638instance.setOptions(options).then(function(state){
639if(!isDestroyed&&options.onFirstUpdate){
640options.onFirstUpdate(state);
641}
642});// Modifiers have the ability to execute arbitrary code before the first
643// update cycle runs. They will be executed in the same order as the update
644// cycle. This is useful when a modifier adds some persistent data that
645// other modifiers need to use, but the modifier is run after the dependent
646// one.
647
648function runModifierEffects(){

649state.orderedModifiers.forEach(function(_ref3){
650var name=_ref3.name,
651_ref3$options=_ref3.options,
652options=_ref3$options===void 0?{}:_ref3$options,
653effect=_ref3.effect;
654
655if(typeof effect==='function'){
656var cleanupFn=effect({
657state:state,
658name:name,
659instance:instance,
660options:options});
661
662
663var noopFn=function noopFn(){};
664
665effectCleanupFns.push(cleanupFn||noopFn);
666}
667});
668}
669
670function cleanupModifierEffects(){
671effectCleanupFns.forEach(function(fn){
672return fn();
673});
674effectCleanupFns=[];
675}
676
677return instance;
678};
679}
680
681var passive={
682passive:true};
683
684
685function effect(_ref){
686var state=_ref.state,
687instance=_ref.instance,
688options=_ref.options;
689var _options$scroll=options.scroll,
690scroll=_options$scroll===void 0?true:_options$scroll,
691_options$resize=options.resize,
692resize=_options$resize===void 0?true:_options$resize;
693var window=getWindow(state.elements.popper);
694var scrollParents=[].concat(state.scrollParents.reference,state.scrollParents.popper);
695
696if(scroll){
697scrollParents.forEach(function(scrollParent){
698scrollParent.addEventListener('scroll',instance.update,passive);
699});
700}
701
702if(resize){
703window.addEventListener('resize',instance.update,passive);
704}
705
706return function(){
707if(scroll){
708scrollParents.forEach(function(scrollParent){
709scrollParent.removeEventListener('scroll',instance.update,passive);
710});
711}
712
713if(resize){
714window.removeEventListener('resize',instance.update,passive);
715}
716};
717}// eslint-disable-next-line import/no-unused-modules
718
719
720var eventListeners={
721name:'eventListeners',
722enabled:true,
723phase:'write',
724fn:function fn(){},
725effect:effect,
726data:{}};
727
728
729function getVariation(placement){
730return placement.split('-')[1];
731}
732
733function getMainAxisFromPlacement(placement){
734return['top','bottom'].indexOf(placement)>=0?'x':'y';
735}
736
737function computeOffsets(_ref){
738var reference=_ref.reference,
739element=_ref.element,
740placement=_ref.placement;
741var basePlacement=placement?getBasePlacement(placement):null;
742var variation=placement?getVariation(placement):null;
743var commonX=reference.x+reference.width/2-element.width/2;
744var commonY=reference.y+reference.height/2-element.height/2;
745var offsets;
746
747switch(basePlacement){
748case top:
749offsets={
750x:commonX,
751y:reference.y-element.height};
752
753break;
754
755case bottom:
756offsets={
757x:commonX,
758y:reference.y+reference.height};
759
760break;
761
762case right:
763offsets={
764x:reference.x+reference.width,
765y:commonY};
766
767break;
768
769case left:
770offsets={
771x:reference.x-element.width,
772y:commonY};
773
774break;
775
776default:
777offsets={
778x:reference.x,
779y:reference.y};}
780
781
782
783var mainAxis=basePlacement?getMainAxisFromPlacement(basePlacement):null;
784
785if(mainAxis!=null){
786var len=mainAxis==='y'?'height':'width';
787
788switch(variation){
789case start:
790offsets[mainAxis]=Math.floor(offsets[mainAxis])-Math.floor(reference[len]/2-element[len]/2);
791break;
792
793case end:
794offsets[mainAxis]=Math.floor(offsets[mainAxis])+Math.ceil(reference[len]/2-element[len]/2);
795break;}
796
797}
798
799return offsets;
800}
801
802function popperOffsets(_ref){
803var state=_ref.state,
804name=_ref.name;
805// Offsets are the actual position the popper needs to have to be
806// properly positioned near its reference element
807// This is the most basic placement, and will be adjusted by
808// the modifiers in the next step
809state.modifiersData[name]=computeOffsets({
810reference:state.rects.reference,
811element:state.rects.popper,
812strategy:'absolute',
813placement:state.placement});
814
815}// eslint-disable-next-line import/no-unused-modules
816
817
818var popperOffsets$1={
819name:'popperOffsets',
820enabled:true,
821phase:'read',
822fn:popperOffsets,
823data:{}};
824
825
826var unsetSides={
827top:'auto',
828right:'auto',
829bottom:'auto',
830left:'auto'};
831// Round the offsets to the nearest suitable subpixel based on the DPR.
832// Zooming can change the DPR, but it seems to report a value that will
833// cleanly divide the values into the appropriate subpixels.
834
835function roundOffsets(_ref){
836var x=_ref.x,
837y=_ref.y;
838var win=window;
839var dpr=win.devicePixelRatio||1;
840return{
841x:Math.round(x*dpr)/dpr||0,
842y:Math.round(y*dpr)/dpr||0};
843
844}
845
846function mapToStyles(_ref2){
847var _Object$assign2;
848
849var popper=_ref2.popper,
850popperRect=_ref2.popperRect,
851placement=_ref2.placement,
852offsets=_ref2.offsets,
853position=_ref2.position,
854gpuAcceleration=_ref2.gpuAcceleration,
855adaptive=_ref2.adaptive;
856
857var _roundOffsets=roundOffsets(offsets),
858x=_roundOffsets.x,
859y=_roundOffsets.y;
860
861var hasX=offsets.hasOwnProperty('x');
862var hasY=offsets.hasOwnProperty('y');
863var sideX=left;
864var sideY=top;
865var win=window;
866

1297_options$boundary=_options.boundary,
1298boundary=_options$boundary===void 0?clippingParents:_options$boundary,
1299_options$rootBoundary=_options.rootBoundary,
1300rootBoundary=_options$rootBoundary===void 0?viewport:_options$rootBoundary,
1301_options$elementConte=_options.elementContext,
1302elementContext=_options$elementConte===void 0?popper:_options$elementConte,
1303_options$altBoundary=_options.altBoundary,
1304altBoundary=_options$altBoundary===void 0?false:_options$altBoundary,
1305_options$padding=_options.padding,
1306padding=_options$padding===void 0?0:_options$padding;
1307var paddingObject=mergePaddingObject(typeof padding!=='number'?padding:expandToHashMap(padding,basePlacements));
1308var altContext=elementContext===popper?reference:popper;
1309var referenceElement=state.elements.reference;
1310var popperRect=state.rects.popper;
1311var element=state.elements[altBoundary?altContext:elementContext];
1312var clippingClientRect=getClippingRect(isElement(element)?element:element.contextElement||getDocumentElement(state.elements.popper),boundary,rootBoundary);
1313var referenceClientRect=getBoundingClientRect(referenceElement);
1314var popperOffsets=computeOffsets({
1315reference:referenceClientRect,
1316element:popperRect,
1317strategy:'absolute',
1318placement:placement});
1319
1320var popperClientRect=rectToClientRect(Object.assign({},popperRect,{},popperOffsets));
1321var elementClientRect=elementContext===popper?popperClientRect:referenceClientRect;// positive = overflowing the clipping rect
1322// 0 or negative = within the clipping rect
1323
1324var overflowOffsets={
1325top:clippingClientRect.top-elementClientRect.top+paddingObject.top,
1326bottom:elementClientRect.bottom-clippingClientRect.bottom+paddingObject.bottom,
1327left:clippingClientRect.left-elementClientRect.left+paddingObject.left,
1328right:elementClientRect.right-clippingClientRect.right+paddingObject.right};
1329
1330var offsetData=state.modifiersData.offset;// Offsets can be applied only to the popper element
1331
1332if(elementContext===popper&&offsetData){
1333var offset=offsetData[placement];
1334Object.keys(overflowOffsets).forEach(function(key){
1335var multiply=[right,bottom].indexOf(key)>=0?1:-1;
1336var axis=[top,bottom].indexOf(key)>=0?'y':'x';
1337overflowOffsets[key]+=offset[axis]*multiply;
1338});
1339}
1340
1341return overflowOffsets;
1342}
1343
1344/*:: type OverflowsMap = { [ComputedPlacement]: number }; */
1345
1346/*;; type OverflowsMap = { [key in ComputedPlacement]: number }; */
1347function computeAutoPlacement(state,options){
1348if(options===void 0){
1349options={};
1350}
1351
1352var _options=options,
1353placement=_options.placement,
1354boundary=_options.boundary,
1355rootBoundary=_options.rootBoundary,
1356padding=_options.padding,
1357flipVariations=_options.flipVariations,
1358_options$allowedAutoP=_options.allowedAutoPlacements,
1359allowedAutoPlacements=_options$allowedAutoP===void 0?placements:_options$allowedAutoP;
1360var variation=getVariation(placement);
1361var placements$1=(variation?flipVariations?variationPlacements:variationPlacements.filter(function(placement){
1362return getVariation(placement)===variation;
1363}):basePlacements).filter(function(placement){
1364return allowedAutoPlacements.indexOf(placement)>=0;
1365});// $FlowFixMe: Flow seems to have problems with two array unions...
1366
1367var overflows=placements$1.reduce(function(acc,placement){
1368acc[placement]=detectOverflow(state,{
1369placement:placement,
1370boundary:boundary,
1371rootBoundary:rootBoundary,
1372padding:padding})[
1373getBasePlacement(placement)];
1374return acc;
1375},{});
1376return Object.keys(overflows).sort(function(a,b){
1377return overflows[a]-overflows[b];
1378});
1379}
1380
1381function getExpandedFallbackPlacements(placement){
1382if(getBasePlacement(placement)===auto){
1383return[];
1384}
1385
1386var oppositePlacement=getOppositePlacement(placement);
1387return[getOppositeVariationPlacement(placement),oppositePlacement,getOppositeVariationPlacement(oppositePlacement)];
1388}
1389
1390function flip(_ref){
1391var state=_ref.state,
1392options=_ref.options,
1393name=_ref.name;
1394
1395if(state.modifiersData[name]._skip){
1396return;
1397}
1398
1399var specifiedFallbackPlacements=options.fallbackPlacements,
1400padding=options.padding,
1401boundary=options.boundary,
1402rootBoundary=options.rootBoundary,
1403altBoundary=options.altBoundary,
1404_options$flipVariatio=options.flipVariations,
1405flipVariations=_options$flipVariatio===void 0?true:_options$flipVariatio,
1406allowedAutoPlacements=options.allowedAutoPlacements;
1407var preferredPlacement=state.options.placement;
1408var basePlacement=getBasePlacement(preferredPlacement);
1409var isBasePlacement=basePlacement===preferredPlacement;
1410var fallbackPlacements=specifiedFallbackPlacements||(isBasePlacement||!flipVariations?[getOppositePlacement(preferredPlacement)]:getExpandedFallbackPlacements(preferredPlacement));
1411var placements=[preferredPlacement].concat(fallbackPlacements).reduce(function(acc,placement){
1412return acc.concat(getBasePlacement(placement)===auto?computeAutoPlacement(state,{
1413placement:placement,
1414boundary:boundary,
1415rootBoundary:rootBoundary,
1416padding:padding,
1417flipVariations:flipVariations,
1418allowedAutoPlacements:allowedAutoPlacements}):
1419placement);
1420},[]);
1421var referenceRect=state.rects.reference;
1422var popperRect=state.rects.popper;
1423var checksMap=new Map();
1424var makeFallbackChecks=true;
1425var firstFittingPlacement=placements[0];
1426
1427for(var i=0;i<placements.length;i++){
1428var placement=placements[i];
1429
1430var _basePlacement=getBasePlacement(placement);
1431
1432var isStartVariation=getVariation(placement)===start;
1433var isVertical=[top,bottom].indexOf(_basePlacement)>=0;
1434var len=isVertical?'width':'height';
1435var overflow=detectOverflow(state,{
1436placement:placement,
1437boundary:boundary,
1438rootBoundary:rootBoundary,
1439altBoundary:altBoundary,
1440padding:padding});

1441
1442var mainVariationSide=isVertical?isStartVariation?right:left:isStartVariation?bottom:top;
1443
1444if(referenceRect[len]>popperRect[len]){
1445mainVariationSide=getOppositePlacement(mainVariationSide);
1446}
1447
1448var altVariationSide=getOppositePlacement(mainVariationSide);
1449var checks=[overflow[_basePlacement]<=0,overflow[mainVariationSide]<=0,overflow[altVariationSide]<=0];
1450
1451if(checks.every(function(check){
1452return check;
1453})){
1454firstFittingPlacement=placement;
1455makeFallbackChecks=false;
1456break;
1457}
1458
1459checksMap.set(placement,checks);
1460}
1461
1462if(makeFallbackChecks){
1463// `2` may be desired in some cases – research later
1464var numberOfChecks=flipVariations?3:1;
1465
1466var _loop=function _loop(_i){
1467var fittingPlacement=placements.find(function(placement){
1468var checks=checksMap.get(placement);
1469
1470if(checks){
1471return checks.slice(0,_i).every(function(check){
1472return check;
1473});
1474}
1475});
1476
1477if(fittingPlacement){
1478firstFittingPlacement=fittingPlacement;
1479return"break";
1480}
1481};
1482
1483for(var _i=numberOfChecks;_i>0;_i--){
1484var _ret=_loop(_i);
1485
1486if(_ret==="break")break;
1487}
1488}
1489
1490if(state.placement!==firstFittingPlacement){
1491state.modifiersData[name]._skip=true;
1492state.placement=firstFittingPlacement;
1493state.reset=true;
1494}
1495}// eslint-disable-next-line import/no-unused-modules
1496
1497
1498var flip$1={
1499name:'flip',
1500enabled:true,
1501phase:'main',
1502fn:flip,
1503requiresIfExists:['offset'],
1504data:{
1505_skip:false}};
1506
1507
1508
1509function getAltAxis(axis){
1510return axis==='x'?'y':'x';
1511}
1512
1513function within(min,value,max){
1514return Math.max(min,Math.min(value,max));
1515}
1516
1517function preventOverflow(_ref){
1518var state=_ref.state,
1519options=_ref.options,
1520name=_ref.name;
1521var _options$mainAxis=options.mainAxis,
1522checkMainAxis=_options$mainAxis===void 0?true:_options$mainAxis,
1523_options$altAxis=options.altAxis,
1524checkAltAxis=_options$altAxis===void 0?false:_options$altAxis,
1525boundary=options.boundary,
1526rootBoundary=options.rootBoundary,
1527altBoundary=options.altBoundary,
1528padding=options.padding,
1529_options$tether=options.tether,
1530tether=_options$tether===void 0?true:_options$tether,
1531_options$tetherOffset=options.tetherOffset,
1532tetherOffset=_options$tetherOffset===void 0?0:_options$tetherOffset;
1533var overflow=detectOverflow(state,{
1534boundary:boundary,
1535rootBoundary:rootBoundary,
1536padding:padding,
1537altBoundary:altBoundary});
1538
1539var basePlacement=getBasePlacement(state.placement);
1540var variation=getVariation(state.placement);
1541var isBasePlacement=!variation;
1542var mainAxis=getMainAxisFromPlacement(basePlacement);
1543var altAxis=getAltAxis(mainAxis);
1544var popperOffsets=state.modifiersData.popperOffsets;
1545var referenceRect=state.rects.reference;
1546var popperRect=state.rects.popper;
1547var tetherOffsetValue=typeof tetherOffset==='function'?tetherOffset(Object.assign({},state.rects,{
1548placement:state.placement})):
1549tetherOffset;
1550var data={
1551x:0,
1552y:0};
1553
1554
1555if(!popperOffsets){
1556return;
1557}
1558
1559if(checkMainAxis){
1560var mainSide=mainAxis==='y'?top:left;
1561var altSide=mainAxis==='y'?bottom:right;
1562var len=mainAxis==='y'?'height':'width';
1563var offset=popperOffsets[mainAxis];
1564var min=popperOffsets[mainAxis]+overflow[mainSide];
1565var max=popperOffsets[mainAxis]-overflow[altSide];
1566var additive=tether?-popperRect[len]/2:0;
1567var minLen=variation===start?referenceRect[len]:popperRect[len];
1568var maxLen=variation===start?-popperRect[len]:-referenceRect[len];// We need to include the arrow in the calculation so the arrow doesn't go
1569// outside the reference bounds
1570
1571var arrowElement=state.elements.arrow;
1572var arrowRect=tether&&arrowElement?getLayoutRect(arrowElement):{
1573width:0,
1574height:0};
1575
1576var arrowPaddingObject=state.modifiersData['arrow#persistent']?state.modifiersData['arrow#persistent'].padding:getFreshSideObject();
1577var arrowPaddingMin=arrowPaddingObject[mainSide];
1578var arrowPaddingMax=arrowPaddingObject[altSide];// If the reference length is smaller than the arrow length, we don't want
1579// to include its full size in the calculation. If the reference is small
1580// and near the edge of a boundary, the popper can overflow even if the
1581// reference is not overflowing as well (e.g. virtual elements with no
1582// width or height)
1583
1584var arrowLen=within(0,referenceRect[len],arrowRect[len]);
1585var minOffset=isBasePlacement?referenceRect[len]/2-additive-arrowLen-arrowPaddingMin-tetherOffsetValue:minLen-arrowLen-arrowPaddingMin-tetherOffsetValue;
1586var maxOffset=isBasePlacement?-referenceRect[len]/2+additive+arrowLen+arrowPaddingMax+tetherOffsetValue:maxLen+arrowLen+arrowPaddingMax+tetherOffsetValue;
1587var arrowOffsetParent=state.elements.arrow&&getOffsetParent(state.elements.arrow);
1588var clientOffset=arrowOffsetParent?mainAxis==='y'?arrowOffsetParent.clientTop||0:arrowOffsetParent.clientLeft||0:0;
1589var offsetModifierValue=state.modifiersData.offset?state.modifiersData.offset[state.placement][mainAxis]:0;
1590var tetherMin=popperOffsets[mainAxis]+minOffset-offsetModifierValue-clientOffset;
1591var tetherMax=popperOffsets[mainAxis]+maxOffset-offsetModifierValue;
1592var preventedOffset=within(tether?Math.min(min,tetherMin):min,offset,tether?Math.max(max,tetherMax):max);
1593popperOffsets[mainAxis]=preventedOffset;
1594data[mainAxis]=preventedOffset-offset;
1595}
1596
1597if(checkAltAxis){
1598var _mainSide=mainAxis==='x'?top:left;
1599
1600var _altSide=mainAxis==='x'?bottom:right;
1601
1602var _offset=popperOffsets[altAxis];
1603
1604var _min=_offset+overflow[_mainSide];
1605
1606var _max=_offset-overflow[_altSide];
1607
1608var _preventedOffset=within(_min,_offset,_max);
1609
1610popperOffsets[altAxis]=_preventedOffset;
1611data[altAxis]=_preventedOffset-_offset;
1612}
1613
1614state.modifiersData[name]=data;
1615}// eslint-disable-next-line import/no-unused-modules
1616
1617
1618var preventOverflow$1={
1619name:'preventOverflow',
1620enabled:true,
1621phase:'main',
1622fn:preventOverflow,
1623requiresIfExists:['offset']};
1624
1625
1626function arrow(_ref){
1627var _state$modifiersData$;
1628
1629var state=_ref.state,
1630name=_ref.name;
1631var arrowElement=state.elements.arrow;
1632var popperOffsets=state.modifiersData.popperOffsets;
1633var basePlacement=getBasePlacement(state.placement);
1634var axis=getMainAxisFromPlacement(basePlacement);
1635var isVertical=[left,right].indexOf(basePlacement)>=0;
1636var len=isVertical?'height':'width';
1637
1638if(!arrowElement||!popperOffsets){
1639return;
1640}
1641
1642var paddingObject=state.modifiersData[name+"#persistent"].padding;
1643var arrowRect=getLayoutRect(arrowElement);
1644var minProp=axis==='y'?top:left;
1645var maxProp=axis==='y'?bottom:right;
1646var endDiff=state.rects.reference[len]+state.rects.reference[axis]-popperOffsets[axis]-state.rects.popper[len];
1647var startDiff=popperOffsets[axis]-state.rects.reference[axis];
1648var arrowOffsetParent=state.elements.arrow&&getOffsetParent(state.elements.arrow);
1649var clientSize=arrowOffsetParent?axis==='y'?arrowOffsetParent.clientHeight||0:arrowOffsetParent.clientWidth||0:0;
1650var centerToReference=endDiff/2-startDiff/2;// Make sure the arrow doesn't overflow the popper if the center point is
1651// outside of the popper bounds
1652
1653var min=paddingObject[minProp];
1654var max=clientSize-arrowRect[len]-paddingObject[maxProp];
1655var center=clientSize/2-arrowRect[len]/2+centerToReference;
1656var offset=within(min,center,max);// Prevents breaking syntax highlighting...
1657
1658var axisProp=axis;
1659state.modifiersData[name]=(_state$modifiersData$={},_state$modifiersData$[axisProp]=offset,_state$modifiersData$.centerOffset=offset-center,_state$modifiersData$);
1660}
1661
1662function effect$2(_ref2){
1663var state=_ref2.state,
1664options=_ref2.options,
1665name=_ref2.name;
1666var _options$element=options.element,
1667arrowElement=_options$element===void 0?'[data-popper-arrow]':_options$element,
1668_options$padding=options.padding,
1669padding=_options$padding===void 0?0:_options$padding;// CSS selector
1670
1671if(typeof arrowElement==='string'){
1672arrowElement=state.elements.popper.querySelector(arrowElement);
1673
1674if(!arrowElement){
1675return;
1676}
1677}
1678
1679if(!contains(state.elements.popper,arrowElement)){
1680if(process.env.NODE_ENV!=="production"){
1681console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper','element.'].join(' '));

2084if(matchesSelector(elem,selector)){
2085ffElems.push(elem);
2086}
2087// find children
2088var childElems=elem.querySelectorAll(selector);
2089// concat childElems to filterFound array
2090for(var i=0;i<childElems.length;i++){
2091ffElems.push(childElems[i]);
2092}
2093});
2094
2095return ffElems;
2096};
2097
2098// ----- debounceMethod ----- //
2099
2100utils.debounceMethod=function(_class,methodName,threshold){
2101threshold=threshold||100;
2102// original method
2103var method=_class.prototype[methodName];
2104var timeoutName=methodName+'Timeout';
2105
2106_class.prototype[methodName]=function(){
2107var timeout=this[timeoutName];
2108clearTimeout(timeout);
2109
2110var args=arguments;
2111var _this=this;
2112this[timeoutName]=setTimeout(function(){
2113method.apply(_this,args);
2114delete _this[timeoutName];
2115},threshold);
2116};
2117};
2118
2119// ----- docReady ----- //
2120
2121utils.docReady=function(callback){
2122var readyState=document.readyState;
2123if(readyState=='complete'||readyState=='interactive'){
2124// do async to allow for other scripts to run. metafizzy/flickity#441
2125setTimeout(callback);
2126}else{
2127document.addEventListener('DOMContentLoaded',callback);
2128}
2129};
2130
2131// ----- htmlInit ----- //
2132
2133// http://jamesroberts.name/blog/2010/02/22/string-functions-for-javascript-trim-to-camel-case-to-dashed-and-to-underscore/
2134utils.toDashed=function(str){
2135return str.replace(/(.)([A-Z])/g,function(match,$1,$2){
2136return $1+'-'+$2;
2137}).toLowerCase();
2138};
2139
2140var console=window.console;
2141/**
2142 * allow user to initialize classes via [data-namespace] or .js-namespace class
2143 * htmlInit( Widget, 'widgetName' )
2144 * options are parsed from data-namespace-options
2145 */
2146utils.htmlInit=function(WidgetClass,namespace){
2147utils.docReady(function(){
2148var dashedNamespace=utils.toDashed(namespace);
2149var dataAttr='data-'+dashedNamespace;
2150var dataAttrElems=document.querySelectorAll('['+dataAttr+']');
2151var jsDashElems=document.querySelectorAll('.js-'+dashedNamespace);
2152var elems=utils.makeArray(dataAttrElems).
2153concat(utils.makeArray(jsDashElems));
2154var dataOptionsAttr=dataAttr+'-options';
2155var jQuery=window.jQuery;
2156
2157elems.forEach(function(elem){
2158var attr=elem.getAttribute(dataAttr)||
2159elem.getAttribute(dataOptionsAttr);
2160var options;
2161try{
2162options=attr&&JSON.parse(attr);
2163}catch(error){
2164// log error, do not initialize
2165if(console){
2166console.error('Error parsing '+dataAttr+' on '+elem.className+
2167': '+error);
2168}
2169return;
2170}
2171// initialize
2172var instance=new WidgetClass(elem,options);
2173// make available via $().data('namespace')
2174if(jQuery){
2175jQuery.data(elem,namespace,instance);
2176}
2177});
2178
2179});
2180};
2181
2182// -----  ----- //
2183
2184return utils;
2185
2186});
2187
2188},{"desandro-matches-selector":2}],5:[function(require,module,exports){
2189/*!
2190 * getSize v2.0.3
2191 * measure size of elements
2192 * MIT license
2193 */
2194
2195/* jshint browser: true, strict: true, undef: true, unused: true */
2196/* globals console: false */
2197
2198(function(window,factory){
2199/* jshint strict: false *//* globals define, module */
2200if(typeof define=='function'&&define.amd){
2201// AMD
2202define(factory);
2203}else if((typeof module==="undefined"?"undefined":_typeof2(module))=='object'&&module.exports){
2204// CommonJS
2205module.exports=factory();
2206}else{
2207// browser global
2208window.getSize=factory();
2209}
2210
2211})(window,function factory(){
2212'use strict';
2213
2214// -------------------------- helpers -------------------------- //
2215
2216// get a number from a string, not a percentage
2217function getStyleSize(value){
2218var num=parseFloat(value);
2219// not a percent like '100%', and a number
2220var isValid=value.indexOf('%')==-1&&!isNaN(num);
2221return isValid&&num;
2222}
2223
2224function noop(){}
2225
2226var logError=typeof console=='undefined'?noop:
2227function(message){
2228console.error(message);
2229};
2230
2231// -------------------------- measurements -------------------------- //
2232
2233var measurements=[
2234'paddingLeft',
2235'paddingRight',
2236'paddingTop',
2237'paddingBottom',
2238'marginLeft',
2239'marginRight',
2240'marginTop',
2241'marginBottom',
2242'borderLeftWidth',
2243'borderRightWidth',
2244'borderTopWidth',
2245'borderBottomWidth'];
2246
2247
2248var measurementsLength=measurements.length;
2249
2250function getZeroSize(){
2251var size={
2252width:0,
2253height:0,
2254innerWidth:0,
2255innerHeight:0,
2256outerWidth:0,
2257outerHeight:0};
2258
2259for(var i=0;i<measurementsLength;i++){
2260var measurement=measurements[i];
2261size[measurement]=0;
2262}
2263return size;
2264}
2265
2266// -------------------------- getStyle -------------------------- //
2267
2268/**
2269 * getStyle, get style of element, check for Firefox bug
2270 * https://bugzilla.mozilla.org/show_bug.cgi?id=548397
2271 */
2272function getStyle(elem){
2273var style=getComputedStyle(elem);
2274if(!style){
2275logError('Style returned '+style+
2276'. Are you running this code in a hidden iframe on Firefox? '+
2277'See https://bit.ly/getsizebug1');
2278}
2279return style;
2280}
2281
2282// -------------------------- setup -------------------------- //
2283
2284var isSetup=false;
2285
2286var isBoxSizeOuter;
2287
2288/**
2289 * setup
2290 * check isBoxSizerOuter
2291 * do on first getSize() rather than on page load for Firefox bug
2292 */
2293function setup(){
2294// setup once
2295if(isSetup){
2296return;
2297}
2298isSetup=true;
2299
2300// -------------------------- box sizing -------------------------- //
2301
2302/**
2303   * Chrome & Safari measure the outer-width on style.width on border-box elems
2304   * IE11 & Firefox<29 measures the inner-width
2305   */
2306var div=document.createElement('div');
2307div.style.width='200px';
2308div.style.padding='1px 2px 3px 4px';
2309div.style.borderStyle='solid';
2310div.style.borderWidth='1px 2px 3px 4px';
2311div.style.boxSizing='border-box';
2312
2313var body=document.body||document.documentElement;
2314body.appendChild(div);
2315var style=getStyle(div);
2316// round value for browser zoom. desandro/masonry#928
2317isBoxSizeOuter=Math.round(getStyleSize(style.width))==200;
2318getSize.isBoxSizeOuter=isBoxSizeOuter;
2319
2320body.removeChild(div);
2321}
2322
2323// -------------------------- getSize -------------------------- //
2324
2325function getSize(elem){
2326setup();
2327
2328// use querySeletor if elem is string
2329if(typeof elem=='string'){
2330elem=document.querySelector(elem);
2331}
2332
2333// do not proceed on non-objects
2334if(!elem||(typeof elem==="undefined"?"undefined":_typeof2(elem))!='object'||!elem.nodeType){
2335return;
2336}
2337
2338var style=getStyle(elem);
2339
2340// if hidden, everything is 0
2341if(style.display=='none'){
2342return getZeroSize();
2343}
2344
2345var size={};
2346size.width=elem.offsetWidth;
2347size.height=elem.offsetHeight;
2348
2349var isBorderBox=size.isBorderBox=style.boxSizing=='border-box';
2350
2351// get all measurements
2352for(var i=0;i<measurementsLength;i++){
2353var measurement=measurements[i];
2354var value=style[measurement];
2355var num=parseFloat(value);
2356// any 'auto', 'medium' value will be 0
2357size[measurement]=!isNaN(num)?num:0;
2358}
2359
2360var paddingWidth=size.paddingLeft+size.paddingRight;
2361var paddingHeight=size.paddingTop+size.paddingBottom;
2362var marginWidth=size.marginLeft+size.marginRight;
2363var marginHeight=size.marginTop+size.marginBottom;
2364var borderWidth=size.borderLeftWidth+size.borderRightWidth;
2365var borderHeight=size.borderTopWidth+size.borderBottomWidth;
2366
2367var isBorderBoxSizeOuter=isBorderBox&&isBoxSizeOuter;
2368
2369// overwrite width and height if we can get it from style
2370var styleWidth=getStyleSize(style.width);
2371if(styleWidth!==false){
2372size.width=styleWidth+(
2373// add padding and border unless it's already including it
2374isBorderBoxSizeOuter?0:paddingWidth+borderWidth);
2375}
2376
2377var styleHeight=getStyleSize(style.height);
2378if(styleHeight!==false){
2379size.height=styleHeight+(
2380// add padding and border unless it's already including it
2381isBorderBoxSizeOuter?0:paddingHeight+borderHeight);
2382}
2383
2384size.innerWidth=size.width-(paddingWidth+borderWidth);
2385size.innerHeight=size.height-(paddingHeight+borderHeight);
2386
2387size.outerWidth=size.width+marginWidth;
2388size.outerHeight=size.height+marginHeight;
2389
2390return size;
2391}
2392
2393return getSize;
2394
2395});
2396
2397},{}],6:[function(require,module,exports){
2398/*!
2399 * Masonry v4.2.2
2400 * Cascading grid layout library
2401 * https://masonry.desandro.com
2402 * MIT License
2403 * by David DeSandro
2404 */
2405
2406(function(window,factory){
2407// universal module definition
2408/* jshint strict: false *//*globals define, module, require */
2409if(typeof define=='function'&&define.amd){
2410// AMD
2411define([
2412'outlayer/outlayer',
2413'get-size/get-size'],
2414
2415factory);
2416}else if((typeof module==="undefined"?"undefined":_typeof2(module))=='object'&&module.exports){
2417// CommonJS
2418module.exports=factory(
2419require('outlayer'),
2420require('get-size'));
2421
2422}else{
2423// browser global
2424window.Masonry=factory(
2425window.Outlayer,
2426window.getSize);
2427
2428}
2429
2430})(window,function factory(Outlayer,getSize){
2431
2432'use strict';
2433
2434// -------------------------- masonryDefinition -------------------------- //
2435
2436// create an Outlayer layout class
2437var Masonry=Outlayer.create('masonry');
2438// isFitWidth -> fitWidth
2439Masonry.compatOptions.fitWidth='isFitWidth';
2440
2441var proto=Masonry.prototype;
2442
2443proto._resetLayout=function(){
2444this.getSize();
2445this._getMeasurement('columnWidth','outerWidth');
2446this._getMeasurement('gutter','outerWidth');
2447this.measureColumns();
2448
2449// reset column Y
2450this.colYs=[];
2451for(var i=0;i<this.cols;i++){
2452this.colYs.push(0);
2453}
2454
2455this.maxY=0;
2456this.horizontalColIndex=0;
2457};
2458
2459proto.measureColumns=function(){
2460this.getContainerWidth();
2461// if columnWidth is 0, default to outerWidth of first item
2462if(!this.columnWidth){
2463var firstItem=this.items[0];
2464var firstItemElem=firstItem&&firstItem.element;
2465// columnWidth fall back to item of first element
2466this.columnWidth=firstItemElem&&getSize(firstItemElem).outerWidth||
2467// if first elem has no width, default to size of container
2468this.containerWidth;
2469}
2470
2471var columnWidth=this.columnWidth+=this.gutter;
2472
2473// calculate columns
2474var containerWidth=this.containerWidth+this.gutter;
2475var cols=containerWidth/columnWidth;
2476// fix rounding errors, typically with gutters
2477var excess=columnWidth-containerWidth%columnWidth;
2478// if overshoot is less than a pixel, round up, otherwise floor it
2479var mathMethod=excess&&excess<1?'round':'floor';
2480cols=Math[mathMethod](cols);
2481this.cols=Math.max(cols,1);
2482};
2483
2484proto.getContainerWidth=function(){
2485// container is parent if fit width
2486var isFitWidth=this._getOption('fitWidth');
2487var container=isFitWidth?this.element.parentNode:this.element;
2488// check that this.size and size are there
2489// IE8 triggers resize on body size change, so they might not be
2490var size=getSize(container);
2491this.containerWidth=size&&size.innerWidth;
2492};

2493
2494proto._getItemLayoutPosition=function(item){
2495item.getSize();
2496// how many columns does this brick span
2497var remainder=item.size.outerWidth%this.columnWidth;
2498var mathMethod=remainder&&remainder<1?'round':'ceil';
2499// round if off by 1 pixel, otherwise use ceil
2500var colSpan=Math[mathMethod](item.size.outerWidth/this.columnWidth);
2501colSpan=Math.min(colSpan,this.cols);
2502// use horizontal or top column position
2503var colPosMethod=this.options.horizontalOrder?
2504'_getHorizontalColPosition':'_getTopColPosition';
2505var colPosition=this[colPosMethod](colSpan,item);
2506// position the brick
2507var position={
2508x:this.columnWidth*colPosition.col,
2509y:colPosition.y};
2510
2511// apply setHeight to necessary columns
2512var setHeight=colPosition.y+item.size.outerHeight;
2513var setMax=colSpan+colPosition.col;
2514for(var i=colPosition.col;i<setMax;i++){
2515this.colYs[i]=setHeight;
2516}
2517
2518return position;
2519};
2520
2521proto._getTopColPosition=function(colSpan){
2522var colGroup=this._getTopColGroup(colSpan);
2523// get the minimum Y value from the columns
2524var minimumY=Math.min.apply(Math,colGroup);
2525
2526return{
2527col:colGroup.indexOf(minimumY),
2528y:minimumY};
2529
2530};
2531
2532/**
2533   * @param {Number} colSpan - number of columns the element spans
2534   * @returns {Array} colGroup
2535   */
2536proto._getTopColGroup=function(colSpan){
2537if(colSpan<2){
2538// if brick spans only one column, use all the column Ys
2539return this.colYs;
2540}
2541
2542var colGroup=[];
2543// how many different places could this brick fit horizontally
2544var groupCount=this.cols+1-colSpan;
2545// for each group potential horizontal position
2546for(var i=0;i<groupCount;i++){
2547colGroup[i]=this._getColGroupY(i,colSpan);
2548}
2549return colGroup;
2550};
2551
2552proto._getColGroupY=function(col,colSpan){
2553if(colSpan<2){
2554return this.colYs[col];
2555}
2556// make an array of colY values for that one group
2557var groupColYs=this.colYs.slice(col,col+colSpan);
2558// and get the max value of the array
2559return Math.max.apply(Math,groupColYs);
2560};
2561
2562// get column position based on horizontal index. #873
2563proto._getHorizontalColPosition=function(colSpan,item){
2564var col=this.horizontalColIndex%this.cols;
2565var isOver=colSpan>1&&col+colSpan>this.cols;
2566// shift to next row if item can't fit on current row
2567col=isOver?0:col;
2568// don't let zero-size items take up space
2569var hasSize=item.size.outerWidth&&item.size.outerHeight;
2570this.horizontalColIndex=hasSize?col+colSpan:this.horizontalColIndex;
2571
2572return{
2573col:col,
2574y:this._getColGroupY(col,colSpan)};
2575
2576};
2577
2578proto._manageStamp=function(stamp){
2579var stampSize=getSize(stamp);
2580var offset=this._getElementOffset(stamp);
2581// get the columns that this stamp affects
2582var isOriginLeft=this._getOption('originLeft');
2583var firstX=isOriginLeft?offset.left:offset.right;
2584var lastX=firstX+stampSize.outerWidth;
2585var firstCol=Math.floor(firstX/this.columnWidth);
2586firstCol=Math.max(0,firstCol);
2587var lastCol=Math.floor(lastX/this.columnWidth);
2588// lastCol should not go over if multiple of columnWidth #425
2589lastCol-=lastX%this.columnWidth?0:1;
2590lastCol=Math.min(this.cols-1,lastCol);
2591// set colYs to bottom of the stamp
2592
2593var isOriginTop=this._getOption('originTop');
2594var stampMaxY=(isOriginTop?offset.top:offset.bottom)+
2595stampSize.outerHeight;
2596for(var i=firstCol;i<=lastCol;i++){
2597this.colYs[i]=Math.max(stampMaxY,this.colYs[i]);
2598}
2599};
2600
2601proto._getContainerSize=function(){
2602this.maxY=Math.max.apply(Math,this.colYs);
2603var size={
2604height:this.maxY};
2605
2606
2607if(this._getOption('fitWidth')){
2608size.width=this._getContainerFitWidth();
2609}
2610
2611return size;
2612};
2613
2614proto._getContainerFitWidth=function(){
2615var unusedCols=0;
2616// count unused columns
2617var i=this.cols;
2618while(--i){
2619if(this.colYs[i]!==0){
2620break;
2621}
2622unusedCols++;
2623}
2624// fit container to columns that have been used
2625return(this.cols-unusedCols)*this.columnWidth-this.gutter;
2626};
2627
2628proto.needsResizeLayout=function(){
2629var previousWidth=this.containerWidth;
2630this.getContainerWidth();
2631return previousWidth!=this.containerWidth;
2632};