scripts.min.js?ver=20190605

js geblod.nu collected 2026-10-02 08:35:43 UTC 45,219 bytes, 1,751 lines download raw bytes

1(function(window, factory) {
2	var lazySizes = factory(window, window.document);
3	window.lazySizes = lazySizes;
4	if(typeof module == 'object' && module.exports){
5		module.exports = lazySizes;
6	}
7}(typeof window != 'undefined' ?
8      window : {}, function l(window, document) {
9	'use strict';
10	/*jshint eqnull:true */
11
12	var lazysizes, lazySizesCfg;
13
14	(function(){
15		var prop;
16
17		var lazySizesDefaults = {
18			lazyClass: 'lazyload',
19			loadedClass: 'lazyloaded',
20			loadingClass: 'lazyloading',
21			preloadClass: 'lazypreload',
22			errorClass: 'lazyerror',
23			//strictClass: 'lazystrict',
24			autosizesClass: 'lazyautosizes',
25			srcAttr: 'data-src',
26			srcsetAttr: 'data-srcset',
27			sizesAttr: 'data-sizes',
28			//preloadAfterLoad: false,
29			minSize: 40,
30			customMedia: {},
31			init: true,
32			expFactor: 1.5,
33			hFac: 0.8,
34			loadMode: 2,
35			loadHidden: true,
36			ricTimeout: 0,
37			throttleDelay: 125,
38		};
39
40		lazySizesCfg = window.lazySizesConfig || window.lazysizesConfig || {};
41
42		for(prop in lazySizesDefaults){
43			if(!(prop in lazySizesCfg)){
44				lazySizesCfg[prop] = lazySizesDefaults[prop];
45			}
46		}
47	})();
48
49	if (!document || !document.getElementsByClassName) {
50		return {
51			init: function () {},
52			cfg: lazySizesCfg,
53			noSupport: true,
54		};
55	}
56
57	var docElem = document.documentElement;
58
59	var Date = window.Date;
60
61	var supportPicture = window.HTMLPictureElement;
62
63	var _addEventListener = 'addEventListener';
64
65	var _getAttribute = 'getAttribute';
66
67	var addEventListener = window[_addEventListener];
68
69	var setTimeout = window.setTimeout;
70
71	var requestAnimationFrame = window.requestAnimationFrame || setTimeout;
72
73	var requestIdleCallback = window.requestIdleCallback;
74
75	var regPicture = /^picture$/i;
76
77	var loadEvents = ['load', 'error', 'lazyincluded', '_lazyloaded'];
78
79	var regClassCache = {};
80

vendor: 15,532 bytes, lines 81-687

81	var forEach = Array.prototype.forEach;
82
83	var hasClass = function(ele, cls) {
84		if(!regClassCache[cls]){
85			regClassCache[cls] = new RegExp('(\\s|^)'+cls+'(\\s|$)');
86		}
87		return regClassCache[cls].test(ele[_getAttribute]('class') || '') && regClassCache[cls];
88	};
89
90	var addClass = function(ele, cls) {
91		if (!hasClass(ele, cls)){
92			ele.setAttribute('class', (ele[_getAttribute]('class') || '').trim() + ' ' + cls);
93		}
94	};
95
96	var removeClass = function(ele, cls) {
97		var reg;
98		if ((reg = hasClass(ele,cls))) {
99			ele.setAttribute('class', (ele[_getAttribute]('class') || '').replace(reg, ' '));
100		}
101	};
102
103	var addRemoveLoadEvents = function(dom, fn, add){
104		var action = add ? _addEventListener : 'removeEventListener';
105		if(add){
106			addRemoveLoadEvents(dom, fn);
107		}
108		loadEvents.forEach(function(evt){
109			dom[action](evt, fn);
110		});
111	};
112
113	var triggerEvent = function(elem, name, detail, noBubbles, noCancelable){
114		var event = document.createEvent('Event');
115
116		if(!detail){
117			detail = {};
118		}
119
120		detail.instance = lazysizes;
121
122		event.initEvent(name, !noBubbles, !noCancelable);
123
124		event.detail = detail;
125
126		elem.dispatchEvent(event);
127		return event;
128	};
129
130	var updatePolyfill = function (el, full){
131		var polyfill;
132		if( !supportPicture && ( polyfill = (window.picturefill || lazySizesCfg.pf) ) ){
133			if(full && full.src && !el[_getAttribute]('srcset')){
134				el.setAttribute('srcset', full.src);
135			}
136			polyfill({reevaluate: true, elements: [el]});
137		} else if(full && full.src){
138			el.src = full.src;
139		}
140	};
141
142	var getCSS = function (elem, style){
143		return (getComputedStyle(elem, null) || {})[style];
144	};
145
146	var getWidth = function(elem, parent, width){
147		width = width || elem.offsetWidth;
148
149		while(width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth){
150			width =  parent.offsetWidth;
151			parent = parent.parentNode;
152		}
153
154		return width;
155	};
156
157	var rAF = (function(){
158		var running, waiting;
159		var firstFns = [];
160		var secondFns = [];
161		var fns = firstFns;
162
163		var run = function(){
164			var runFns = fns;
165
166			fns = firstFns.length ? secondFns : firstFns;
167
168			running = true;
169			waiting = false;
170
171			while(runFns.length){
172				runFns.shift()();
173			}
174
175			running = false;
176		};
177
178		var rafBatch = function(fn, queue){
179			if(running && !queue){
180				fn.apply(this, arguments);
181			} else {
182				fns.push(fn);
183
184				if(!waiting){
185					waiting = true;
186					(document.hidden ? setTimeout : requestAnimationFrame)(run);
187				}
188			}
189		};
190
191		rafBatch._lsFlush = run;
192
193		return rafBatch;
194	})();
195
196	var rAFIt = function(fn, simple){
197		return simple ?
198			function() {
199				rAF(fn);
200			} :
201			function(){
202				var that = this;
203				var args = arguments;
204				rAF(function(){
205					fn.apply(that, args);
206				});
207			}
208		;
209	};
210
211	var throttle = function(fn){
212		var running;
213		var lastTime = 0;
214		var gDelay = lazySizesCfg.throttleDelay;
215		var rICTimeout = lazySizesCfg.ricTimeout;
216		var run = function(){
217			running = false;
218			lastTime = Date.now();
219			fn();
220		};
221		var idleCallback = requestIdleCallback && rICTimeout > 49 ?
222			function(){
223				requestIdleCallback(run, {timeout: rICTimeout});
224
225				if(rICTimeout !== lazySizesCfg.ricTimeout){
226					rICTimeout = lazySizesCfg.ricTimeout;
227				}
228			} :
229			rAFIt(function(){
230				setTimeout(run);
231			}, true)
232		;
233
234		return function(isPriority){
235			var delay;
236
237			if((isPriority = isPriority === true)){
238				rICTimeout = 33;
239			}
240
241			if(running){
242				return;
243			}
244
245			running =  true;
246
247			delay = gDelay - (Date.now() - lastTime);
248
249			if(delay < 0){
250				delay = 0;
251			}
252
253			if(isPriority || delay < 9){
254				idleCallback();
255			} else {
256				setTimeout(idleCallback, delay);
257			}
258		};
259	};
260
261	//based on http://modernjavascript.blogspot.de/2013/08/building-better-debounce.html
262	var debounce = function(func) {
263		var timeout, timestamp;
264		var wait = 99;
265		var run = function(){
266			timeout = null;
267			func();
268		};
269		var later = function() {
270			var last = Date.now() - timestamp;
271
272			if (last < wait) {
273				setTimeout(later, wait - last);
274			} else {
275				(requestIdleCallback || run)(run);
276			}
277		};
278
279		return function() {
280			timestamp = Date.now();
281
282			if (!timeout) {
283				timeout = setTimeout(later, wait);
284			}
285		};
286	};
287
288	var loader = (function(){
289		var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
290
291		var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden;
292
293		var regImg = /^img$/i;
294		var regIframe = /^iframe$/i;
295
296		var supportScroll = ('onscroll' in window) && !(/(gle|ing)bot/.test(navigator.userAgent));
297
298		var shrinkExpand = 0;
299		var currentExpand = 0;
300
301		var isLoading = 0;
302		var lowRuns = -1;
303
304		var resetPreloading = function(e){
305			isLoading--;
306			if(!e || isLoading < 0 || !e.target){
307				isLoading = 0;
308			}
309		};
310
311		var isVisible = function (elem) {
312			if (isBodyHidden == null) {
313				isBodyHidden = getCSS(document.body, 'visibility') == 'hidden';
314			}
315
316			return isBodyHidden || (getCSS(elem.parentNode, 'visibility') != 'hidden' && getCSS(elem, 'visibility') != 'hidden');
317		};
318
319		var isNestedVisible = function(elem, elemExpand){
320			var outerRect;
321			var parent = elem;
322			var visible = isVisible(elem);
323
324			eLtop -= elemExpand;
325			eLbottom += elemExpand;
326			eLleft -= elemExpand;
327			eLright += elemExpand;
328
329			while(visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem){
330				visible = ((getCSS(parent, 'opacity') || 1) > 0);
331
332				if(visible && getCSS(parent, 'overflow') != 'visible'){
333					outerRect = parent.getBoundingClientRect();
334					visible = eLright > outerRect.left &&
335						eLleft < outerRect.right &&
336						eLbottom > outerRect.top - 1 &&
337						eLtop < outerRect.bottom + 1
338					;
339				}
340			}
341
342			return visible;
343		};
344
345		var checkElements = function() {
346			var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal,
347				beforeExpandVal, defaultExpand, preloadExpand, hFac;
348			var lazyloadElems = lazysizes.elements;
349
350			if((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)){
351
352				i = 0;
353
354				lowRuns++;
355
356				for(; i < eLlen; i++){
357
358					if(!lazyloadElems[i] || lazyloadElems[i]._lazyRace){continue;}
359
360					if(!supportScroll || (lazysizes.prematureUnveil && lazysizes.prematureUnveil(lazyloadElems[i]))){unveilElement(lazyloadElems[i]);continue;}
361
362					if(!(elemExpandVal = lazyloadElems[i][_getAttribute]('data-expand')) || !(elemExpand = elemExpandVal * 1)){
363						elemExpand = currentExpand;
364					}
365
366					if (!defaultExpand) {
367						defaultExpand = (!lazySizesCfg.expand || lazySizesCfg.expand < 1) ?
368							docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 :
369							lazySizesCfg.expand;
370
371						lazysizes._defEx = defaultExpand;
372
373						preloadExpand = defaultExpand * lazySizesCfg.expFactor;
374						hFac = lazySizesCfg.hFac;
375						isBodyHidden = null;
376
377						if(currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document.hidden){
378							currentExpand = preloadExpand;
379							lowRuns = 0;
380						} else if(loadMode > 1 && lowRuns > 1 && isLoading < 6){
381							currentExpand = defaultExpand;
382						} else {
383							currentExpand = shrinkExpand;
384						}
385					}
386
387					if(beforeExpandVal !== elemExpand){
388						eLvW = innerWidth + (elemExpand * hFac);
389						elvH = innerHeight + elemExpand;
390						elemNegativeExpand = elemExpand * -1;
391						beforeExpandVal = elemExpand;
392					}
393
394					rect = lazyloadElems[i].getBoundingClientRect();
395
396					if ((eLbottom = rect.bottom) >= elemNegativeExpand &&
397						(eLtop = rect.top) <= elvH &&
398						(eLright = rect.right) >= elemNegativeExpand * hFac &&
399						(eLleft = rect.left) <= eLvW &&
400						(eLbottom || eLright || eLleft || eLtop) &&
401						(lazySizesCfg.loadHidden || isVisible(lazyloadElems[i])) &&
402						((isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4)) || isNestedVisible(lazyloadElems[i], elemExpand))){
403						unveilElement(lazyloadElems[i]);
404						loadedSomething = true;
405						if(isLoading > 9){break;}
406					} else if(!loadedSomething && isCompleted && !autoLoadElem &&
407						isLoading < 4 && lowRuns < 4 && loadMode > 2 &&
408						(preloadElems[0] || lazySizesCfg.preloadAfterLoad) &&
409						(preloadElems[0] || (!elemExpandVal && ((eLbottom || eLright || eLleft || eLtop) || lazyloadElems[i][_getAttribute](lazySizesCfg.sizesAttr) != 'auto')))){
410						autoLoadElem = preloadElems[0] || lazyloadElems[i];
411					}
412				}
413
414				if(autoLoadElem && !loadedSomething){
415					unveilElement(autoLoadElem);
416				}
417			}
418		};
419
420		var throttledCheckElements = throttle(checkElements);
421
422		var switchLoadingClass = function(e){
423			var elem = e.target;
424
425			if (elem._lazyCache) {
426				delete elem._lazyCache;
427				return;
428			}
429
430			resetPreloading(e);
431			addClass(elem, lazySizesCfg.loadedClass);
432			removeClass(elem, lazySizesCfg.loadingClass);
433			addRemoveLoadEvents(elem, rafSwitchLoadingClass);
434			triggerEvent(elem, 'lazyloaded');
435		};
436		var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
437		var rafSwitchLoadingClass = function(e){
438			rafedSwitchLoadingClass({target: e.target});
439		};
440
441		var changeIframeSrc = function(elem, src){
442			try {
443				elem.contentWindow.location.replace(src);
444			} catch(e){
445				elem.src = src;
446			}
447		};
448
449		var handleSources = function(source){
450			var customMedia;
451
452			var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr);
453
454			if( (customMedia = lazySizesCfg.customMedia[source[_getAttribute]('data-media') || source[_getAttribute]('media')]) ){
455				source.setAttribute('media', customMedia);
456			}
457
458			if(sourceSrcset){
459				source.setAttribute('srcset', sourceSrcset);
460			}
461		};
462
463		var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg){
464			var src, srcset, parent, isPicture, event, firesLoad;
465
466			if(!(event = triggerEvent(elem, 'lazybeforeunveil', detail)).defaultPrevented){
467
468				if(sizes){
469					if(isAuto){
470						addClass(elem, lazySizesCfg.autosizesClass);
471					} else {
472						elem.setAttribute('sizes', sizes);
473					}
474				}
475
476				srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr);
477				src = elem[_getAttribute](lazySizesCfg.srcAttr);
478
479				if(isImg) {
480					parent = elem.parentNode;
481					isPicture = parent && regPicture.test(parent.nodeName || '');
482				}
483
484				firesLoad = detail.firesLoad || (('src' in elem) && (srcset || src || isPicture));
485
486				event = {target: elem};
487
488				addClass(elem, lazySizesCfg.loadingClass);
489
490				if(firesLoad){
491					clearTimeout(resetPreloadingTimer);
492					resetPreloadingTimer = setTimeout(resetPreloading, 2500);
493					addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
494				}
495
496				if(isPicture){
497					forEach.call(parent.getElementsByTagName('source'), handleSources);
498				}
499
500				if(srcset){
501					elem.setAttribute('srcset', srcset);
502				} else if(src && !isPicture){
503					if(regIframe.test(elem.nodeName)){
504						changeIframeSrc(elem, src);
505					} else {
506						elem.src = src;
507					}
508				}
509
510				if(isImg && (srcset || isPicture)){
511					updatePolyfill(elem, {src: src});
512				}
513			}
514
515			if(elem._lazyRace){
516				delete elem._lazyRace;
517			}
518			removeClass(elem, lazySizesCfg.lazyClass);
519
520			rAF(function(){
521				// Part of this can be removed as soon as this fix is older: https://bugs.chromium.org/p/chromium/issues/detail?id=7731 (2015)
522				var isLoaded = elem.complete && elem.naturalWidth > 1;
523
524				if( !firesLoad || isLoaded){
525					if (isLoaded) {
526						addClass(elem, 'ls-is-cached');
527					}
528					switchLoadingClass(event);
529					elem._lazyCache = true;
530					setTimeout(function(){
531						if ('_lazyCache' in elem) {
532							delete elem._lazyCache;
533						}
534					}, 9);
535				}
536				if (elem.loading == 'lazy') {
537					isLoading--;
538				}
539			}, true);
540		});
541
542		var unveilElement = function (elem){
543			if (elem._lazyRace) {return;}
544			var detail;
545
546			var isImg = regImg.test(elem.nodeName);
547
548			//allow using sizes="auto", but don't use. it's invalid. Use data-sizes="auto" or a valid value for sizes instead (i.e.: sizes="80vw")
549			var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]('sizes'));
550			var isAuto = sizes == 'auto';
551
552			if( (isAuto || !isCompleted) && isImg && (elem[_getAttribute]('src') || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)){return;}
553
554			detail = triggerEvent(elem, 'lazyunveilread').detail;
555
556			if(isAuto){
557				 autoSizer.updateElem(elem, true, elem.offsetWidth);
558			}
559
560			elem._lazyRace = true;
561			isLoading++;
562
563			lazyUnveil(elem, detail, isAuto, sizes, isImg);
564		};
565
566		var afterScroll = debounce(function(){
567			lazySizesCfg.loadMode = 3;
568			throttledCheckElements();
569		});
570
571		var altLoadmodeScrollListner = function(){
572			if(lazySizesCfg.loadMode == 3){
573				lazySizesCfg.loadMode = 2;
574			}
575			afterScroll();
576		};
577
578		var onload = function(){
579			if(isCompleted){return;}
580			if(Date.now() - started < 999){
581				setTimeout(onload, 999);
582				return;
583			}
584
585
586			isCompleted = true;
587
588			lazySizesCfg.loadMode = 3;
589
590			throttledCheckElements();
591
592			addEventListener('scroll', altLoadmodeScrollListner, true);
593		};
594
595		return {
596			_: function(){
597				started = Date.now();
598
599				lazysizes.elements = document.getElementsByClassName(lazySizesCfg.lazyClass);
600				preloadElems = document.getElementsByClassName(lazySizesCfg.lazyClass + ' ' + lazySizesCfg.preloadClass);
601
602				addEventListener('scroll', throttledCheckElements, true);
603
604				addEventListener('resize', throttledCheckElements, true);
605
606				if(window.MutationObserver){
607					new MutationObserver( throttledCheckElements ).observe( docElem, {childList: true, subtree: true, attributes: true} );
608				} else {
609					docElem[_addEventListener]('DOMNodeInserted', throttledCheckElements, true);
610					docElem[_addEventListener]('DOMAttrModified', throttledCheckElements, true);
611					setInterval(throttledCheckElements, 999);
612				}
613
614				addEventListener('hashchange', throttledCheckElements, true);
615
616				//, 'fullscreenchange'
617				['focus', 'mouseover', 'click', 'load', 'transitionend', 'animationend'].forEach(function(name){
618					document[_addEventListener](name, throttledCheckElements, true);
619				});
620
621				if((/d$|^c/.test(document.readyState))){
622					onload();
623				} else {
624					addEventListener('load', onload);
625					document[_addEventListener]('DOMContentLoaded', throttledCheckElements);
626					setTimeout(onload, 20000);
627				}
628
629				if(lazysizes.elements.length){
630					checkElements();
631					rAF._lsFlush();
632				} else {
633					throttledCheckElements();
634				}
635			},
636			checkElems: throttledCheckElements,
637			unveil: unveilElement,
638			_aLSL: altLoadmodeScrollListner,
639		};
640	})();
641
642
643	var autoSizer = (function(){
644		var autosizesElems;
645
646		var sizeElement = rAFIt(function(elem, parent, event, width){
647			var sources, i, len;
648			elem._lazysizesWidth = width;
649			width += 'px';
650
651			elem.setAttribute('sizes', width);
652
653			if(regPicture.test(parent.nodeName || '')){
654				sources = parent.getElementsByTagName('source');
655				for(i = 0, len = sources.length; i < len; i++){
656					sources[i].setAttribute('sizes', width);
657				}
658			}
659
660			if(!event.detail.dataAttr){
661				updatePolyfill(elem, event.detail);
662			}
663		});
664		var getSizeElement = function (elem, dataAttr, width){
665			var event;
666			var parent = elem.parentNode;
667
668			if(parent){
669				width = getWidth(elem, parent, width);
670				event = triggerEvent(elem, 'lazybeforesizes', {width: width, dataAttr: !!dataAttr});
671
672				if(!event.defaultPrevented){
673					width = event.detail.width;
674
675					if(width && width !== elem._lazysizesWidth){
676						sizeElement(elem, parent, event, width);
677					}
678				}
679			}
680		};
681
682		var updateElementsSizes = function(){
683			var i;
684			var len = autosizesElems.length;
685			if(len){
686				i = 0;
687

688				for(; i < len; i++){
689					getSizeElement(autosizesElems[i]);
690				}
691			}
692		};
693
694		var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
695
696		return {
697			_: function(){
698				autosizesElems = document.getElementsByClassName(lazySizesCfg.autosizesClass);
699				addEventListener('resize', debouncedUpdateElementsSizes);
700			},
701			checkElems: debouncedUpdateElementsSizes,
702			updateElem: getSizeElement
703		};
704	})();
705
706	var init = function(){
707		if(!init.i && document.getElementsByClassName){
708			init.i = true;
709			autoSizer._();
710			loader._();
711		}
712	};
713
714	setTimeout(function(){
715		if(lazySizesCfg.init){
716			init();
717		}
718	});
719
720	lazysizes = {
721		cfg: lazySizesCfg,
722		autoSizer: autoSizer,
723		loader: loader,
724		init: init,
725		uP: updatePolyfill,
726		aC: addClass,
727		rC: removeClass,
728		hC: hasClass,
729		fire: triggerEvent,
730		gW: getWidth,
731		rAF: rAF,
732	};
733
734	return lazysizes;
735}
736));
737;(function(window, factory) {
738	var globalInstall = function(){
739		factory(window.lazySizes);
740		window.removeEventListener('lazyunveilread', globalInstall, true);
741	};
742
743	factory = factory.bind(null, window, window.document);
744
745	if(typeof module == 'object' && module.exports){
746		factory(require('lazysizes'));
747	} else if(window.lazySizes) {
748		globalInstall();
749	} else {
750		window.addEventListener('lazyunveilread', globalInstall, true);
751	}
752}(window, function(window, document, lazySizes) {
753	'use strict';
754	if(!window.addEventListener){return;}
755
756	var lazySizesCfg = lazySizes.cfg;
757	var regWhite = /\s+/g;
758	var regSplitSet = /\s*\|\s+|\s+\|\s*/g;
759	var regSource = /^(.+?)(?:\s+\[\s*(.+?)\s*\])(?:\s+\[\s*(.+?)\s*\])?$/;
760	var regType = /^\s*\(*\s*type\s*:\s*(.+?)\s*\)*\s*$/;
761	var regBgUrlEscape = /\(|\)|'/;
762	var allowedBackgroundSize = {contain: 1, cover: 1};
763	var proxyWidth = function(elem){
764		var width = lazySizes.gW(elem, elem.parentNode);
765
766		if(!elem._lazysizesWidth || width > elem._lazysizesWidth){
767			elem._lazysizesWidth = width;
768		}
769		return elem._lazysizesWidth;
770	};
771	var getBgSize = function(elem){
772		var bgSize;
773
774		bgSize = (getComputedStyle(elem) || {getPropertyValue: function(){}}).getPropertyValue('background-size');
775
776		if(!allowedBackgroundSize[bgSize] && allowedBackgroundSize[elem.style.backgroundSize]){
777			bgSize = elem.style.backgroundSize;
778		}
779
780		return bgSize;
781	};
782	var setTypeOrMedia = function(source, match){
783		if(match){
784			var typeMatch = match.match(regType);
785			if(typeMatch && typeMatch[1]){
786				source.setAttribute('type', typeMatch[1]);
787			} else {
788				source.setAttribute('media', lazySizesCfg.customMedia[match] || match);
789			}
790		}
791	};
792	var createPicture = function(sets, elem, img){
793		var picture = document.createElement('picture');
794		var sizes = elem.getAttribute(lazySizesCfg.sizesAttr);
795		var ratio = elem.getAttribute('data-ratio');
796		var optimumx = elem.getAttribute('data-optimumx');
797
798		if(elem._lazybgset && elem._lazybgset.parentNode == elem){
799			elem.removeChild(elem._lazybgset);
800		}
801
802		Object.defineProperty(img, '_lazybgset', {
803			value: elem,
804			writable: true
805		});
806		Object.defineProperty(elem, '_lazybgset', {
807			value: picture,
808			writable: true
809		});
810
811		sets = sets.replace(regWhite, ' ').split(regSplitSet);
812
813		picture.style.display = 'none';
814		img.className = lazySizesCfg.lazyClass;
815
816		if(sets.length == 1 && !sizes){
817			sizes = 'auto';
818		}
819
820		sets.forEach(function(set){
821			var match;
822			var source = document.createElement('source');
823
824			if(sizes && sizes != 'auto'){
825				source.setAttribute('sizes', sizes);
826			}
827
828			if((match = set.match(regSource))){
829				source.setAttribute(lazySizesCfg.srcsetAttr, match[1]);
830
831				setTypeOrMedia(source, match[2]);
832				setTypeOrMedia(source, match[3]);
833			} else {
834				source.setAttribute(lazySizesCfg.srcsetAttr, set);
835			}
836
837			picture.appendChild(source);
838		});
839
840		if(sizes){
841			img.setAttribute(lazySizesCfg.sizesAttr, sizes);
842			elem.removeAttribute(lazySizesCfg.sizesAttr);
843			elem.removeAttribute('sizes');
844		}
845		if(optimumx){
846			img.setAttribute('data-optimumx', optimumx);
847		}
848		if(ratio) {
849			img.setAttribute('data-ratio', ratio);
850		}
851
852		picture.appendChild(img);
853
854		elem.appendChild(picture);
855	};
856
857	var proxyLoad = function(e){
858		if(!e.target._lazybgset){return;}
859
860		var image = e.target;
861		var elem = image._lazybgset;
862		var bg = image.currentSrc || image.src;
863
864
865		if(bg){
866			var event = lazySizes.fire(elem, 'bgsetproxy', {
867				src: bg,
868				useSrc: regBgUrlEscape.test(bg) ? JSON.stringify(bg) : bg,
869			});
870
871			if(!event.defaultPrevented){
872				elem.style.backgroundImage = 'url(' + event.detail.useSrc + ')';
873			}
874		}
875
876		if(image._lazybgsetLoading){
877			lazySizes.fire(elem, '_lazyloaded', {}, false, true);
878			delete image._lazybgsetLoading;
879		}
880	};
881
882	addEventListener('lazybeforeunveil', function(e){
883		var set, image, elem;
884
885		if(e.defaultPrevented || !(set = e.target.getAttribute('data-bgset'))){return;}
886
887		elem = e.target;
888		image = document.createElement('img');
889
890		image.alt = '';
891
892		image._lazybgsetLoading = true;
893		e.detail.firesLoad = true;
894
895		createPicture(set, elem, image);
896
897		setTimeout(function(){
898			lazySizes.loader.unveil(image);
899
900			lazySizes.rAF(function(){
901				lazySizes.fire(image, '_lazyloaded', {}, true, true);
902				if(image.complete) {
903					proxyLoad({target: image});
904				}
905			});
906		});
907
908	});
909
910	document.addEventListener('load', proxyLoad, true);
911
912	window.addEventListener('lazybeforesizes', function(e){
913		if(e.detail.instance != lazySizes){return;}
914		if(e.target._lazybgset && e.detail.dataAttr){
915			var elem = e.target._lazybgset;
916			var bgSize = getBgSize(elem);
917

918			if(allowedBackgroundSize[bgSize]){
919				e.target._lazysizesParentFit = bgSize;
920
921				lazySizes.rAF(function(){
922					e.target.setAttribute('data-parent-fit', bgSize);
923					if(e.target._lazysizesParentFit){
924						delete e.target._lazysizesParentFit;
925					}
926				});
927			}
928		}
929	}, true);
930
931	document.documentElement.addEventListener('lazybeforesizes', function(e){
932		if(e.defaultPrevented || !e.target._lazybgset || e.detail.instance != lazySizes){return;}
933		e.detail.width = proxyWidth(e.target._lazybgset);
934	});
935}));
936;(function(window, factory) {
937	if(!window) {return;}
938	var globalInstall = function(){
939		factory(window.lazySizes);
940		window.removeEventListener('lazyunveilread', globalInstall, true);
941	};
942
943	factory = factory.bind(null, window, window.document);
944
945	if(typeof module == 'object' && module.exports){
946		factory(require('lazysizes'));
947	} else if(window.lazySizes) {
948		globalInstall();
949	} else {
950		window.addEventListener('lazyunveilread', globalInstall, true);
951	}
952}(typeof window != 'undefined' ?
953	window : 0, function(window, document, lazySizes) {
954	/*jshint eqnull:true */
955	'use strict';
956	var polyfill;
957	var lazySizesCfg = lazySizes.cfg;
958	var img = document.createElement('img');
959	var supportSrcset = ('sizes' in img) && ('srcset' in img);
960	var regHDesc = /\s+\d+h/g;
961	var fixEdgeHDescriptor = (function(){
962		var regDescriptors = /\s+(\d+)(w|h)\s+(\d+)(w|h)/;
963		var forEach = Array.prototype.forEach;
964
965		return function(){
966			var img = document.createElement('img');
967			var removeHDescriptors = function(source){
968				var ratio, match;
969				var srcset = source.getAttribute(lazySizesCfg.srcsetAttr);
970				if(srcset){
971					if((match = srcset.match(regDescriptors))){
972						if(match[2] == 'w'){
973							ratio = match[1] / match[3];
974						} else {
975							ratio = match[3] / match[1];
976						}
977
978						if(ratio){
979							source.setAttribute('data-aspectratio', ratio);
980						}
981						source.setAttribute(lazySizesCfg.srcsetAttr, srcset.replace(regHDesc, ''));
982					}
983				}
984			};
985			var handler = function(e){
986				if(e.detail.instance != lazySizes){return;}
987				var picture = e.target.parentNode;
988
989				if(picture && picture.nodeName == 'PICTURE'){
990					forEach.call(picture.getElementsByTagName('source'), removeHDescriptors);
991				}
992				removeHDescriptors(e.target);
993			};
994
995			var test = function(){
996				if(!!img.currentSrc){
997					document.removeEventListener('lazybeforeunveil', handler);
998				}
999			};
1000
1001			document.addEventListener('lazybeforeunveil', handler);
1002
1003			img.onload = test;
1004			img.onerror = test;
1005
1006			img.srcset = 'data:,a 1w 1h';
1007
1008			if(img.complete){
1009				test();
1010			}
1011		};
1012	})();
1013
1014	if(!lazySizesCfg.supportsType){
1015		lazySizesCfg.supportsType = function(type/*, elem*/){
1016			return !type;
1017		};
1018	}
1019
1020	if (window.HTMLPictureElement && supportSrcset) {
1021		if(!lazySizes.hasHDescriptorFix && document.msElementsFromPoint){
1022			lazySizes.hasHDescriptorFix = true;
1023			fixEdgeHDescriptor();
1024		}
1025		return;
1026	}
1027
1028	if(window.picturefill || lazySizesCfg.pf){return;}
1029
1030	lazySizesCfg.pf = function(options){
1031		var i, len;
1032		if(window.picturefill){return;}
1033		for(i = 0, len = options.elements.length; i < len; i++){
1034			polyfill(options.elements[i]);
1035		}
1036	};
1037
1038	// partial polyfill
1039	polyfill = (function(){
1040		var ascendingSort = function( a, b ) {
1041			return a.w - b.w;
1042		};
1043		var regPxLength = /^\s*\d+\.*\d*px\s*$/;
1044		var reduceCandidate = function (srces) {
1045			var lowerCandidate, bonusFactor;
1046			var len = srces.length;
1047			var candidate = srces[len -1];
1048			var i = 0;
1049
1050			for(i; i < len;i++){
1051				candidate = srces[i];
1052				candidate.d = candidate.w / srces.w;
1053
1054				if(candidate.d >= srces.d){
1055					if(!candidate.cached && (lowerCandidate = srces[i - 1]) &&
1056						lowerCandidate.d > srces.d - (0.13 * Math.pow(srces.d, 2.2))){
1057
1058						bonusFactor = Math.pow(lowerCandidate.d - 0.6, 1.6);
1059
1060						if(lowerCandidate.cached) {
1061							lowerCandidate.d += 0.15 * bonusFactor;
1062						}
1063
1064						if(lowerCandidate.d + ((candidate.d - srces.d) * bonusFactor) > srces.d){
1065							candidate = lowerCandidate;
1066						}
1067					}
1068					break;
1069				}
1070			}
1071			return candidate;
1072		};
1073
1074		var parseWsrcset = (function(){
1075			var candidates;
1076			var regWCandidates = /(([^,\s].[^\s]+)\s+(\d+)w)/g;
1077			var regMultiple = /\s/;
1078			var addCandidate = function(match, candidate, url, wDescriptor){
1079				candidates.push({
1080					c: candidate,
1081					u: url,
1082					w: wDescriptor * 1
1083				});
1084			};
1085
1086			return function(input){
1087				candidates = [];
1088				input = input.trim();
1089				input
1090					.replace(regHDesc, '')
1091					.replace(regWCandidates, addCandidate)
1092				;
1093
1094				if(!candidates.length && input && !regMultiple.test(input)){
1095					candidates.push({
1096						c: input,
1097						u: input,
1098						w: 99
1099					});
1100				}
1101
1102				return candidates;
1103			};
1104		})();
1105
1106		var runMatchMedia = function(){
1107			if(runMatchMedia.init){return;}
1108
1109			runMatchMedia.init = true;
1110			addEventListener('resize', (function(){
1111				var timer;
1112				var matchMediaElems = document.getElementsByClassName('lazymatchmedia');
1113				var run = function(){
1114					var i, len;
1115					for(i = 0, len = matchMediaElems.length; i < len; i++){
1116						polyfill(matchMediaElems[i]);
1117					}
1118				};
1119
1120				return function(){
1121					clearTimeout(timer);
1122					timer = setTimeout(run, 66);
1123				};
1124			})());
1125		};
1126
1127		var createSrcset = function(elem, isImage){
1128			var parsedSet;
1129			var srcSet = elem.getAttribute('srcset') || elem.getAttribute(lazySizesCfg.srcsetAttr);
1130
1131			if(!srcSet && isImage){
1132				srcSet = !elem._lazypolyfill ?
1133					(elem.getAttribute(lazySizesCfg.srcAttr) || elem.getAttribute('src')) :
1134					elem._lazypolyfill._set
1135				;
1136			}
1137
1138			if(!elem._lazypolyfill || elem._lazypolyfill._set != srcSet){
1139
1140				parsedSet = parseWsrcset( srcSet || '' );
1141				if(isImage && elem.parentNode){
1142					parsedSet.isPicture = elem.parentNode.nodeName.toUpperCase() == 'PICTURE';
1143
1144					if(parsedSet.isPicture){
1145						if(window.matchMedia){
1146							lazySizes.aC(elem, 'lazymatchmedia');
1147							runMatchMedia();
1148						}
1149					}
1150				}
1151
1152				parsedSet._set = srcSet;
1153				Object.defineProperty(elem, '_lazypolyfill', {
1154					value: parsedSet,
1155					writable: true
1156				});
1157			}
1158		};
1159
1160		var getX = function(elem){
1161			var dpr = window.devicePixelRatio || 1;
1162			var optimum = lazySizes.getX && lazySizes.getX(elem);
1163			return Math.min(optimum || dpr, 2.5, dpr);
1164		};
1165
1166		var matchesMedia = function(media){
1167			if(window.matchMedia){
1168				matchesMedia = function(media){
1169					return !media || (matchMedia(media) || {}).matches;
1170				};
1171			} else {
1172				return !media;
1173			}
1174
1175			return matchesMedia(media);
1176		};
1177
1178		var getCandidate = function(elem){
1179			var sources, i, len, media, source, srces, src, width;
1180
1181			source = elem;
1182			createSrcset(source, true);
1183			srces = source._lazypolyfill;
1184
1185			if(srces.isPicture){
1186				for(i = 0, sources = elem.parentNode.getElementsByTagName('source'), len = sources.length; i < len; i++){
1187					if( lazySizesCfg.supportsType(sources[i].getAttribute('type'), elem) && matchesMedia( sources[i].getAttribute('media')) ){
1188						source = sources[i];
1189						createSrcset(source);
1190						srces = source._lazypolyfill;
1191						break;
1192					}
1193				}
1194			}
1195
1196			if(srces.length > 1){
1197				width = source.getAttribute('sizes') || '';
1198				width = regPxLength.test(width) && parseInt(width, 10) || lazySizes.gW(elem, elem.parentNode);
1199				srces.d = getX(elem);
1200				if(!srces.src || !srces.w || srces.w < width){
1201					srces.w = width;
1202					src = reduceCandidate(srces.sort(ascendingSort));
1203					srces.src = src;
1204				} else {
1205					src = srces.src;
1206				}
1207			} else {
1208				src = srces[0];
1209			}
1210
1211			return src;
1212		};
1213
1214		var p = function(elem){
1215			if(supportSrcset && elem.parentNode && elem.parentNode.nodeName.toUpperCase() != 'PICTURE'){return;}
1216			var candidate = getCandidate(elem);
1217
1218			if(candidate && candidate.u && elem._lazypolyfill.cur != candidate.u){
1219				elem._lazypolyfill.cur = candidate.u;
1220				candidate.cached = true;
1221				elem.setAttribute(lazySizesCfg.srcAttr, candidate.u);
1222				elem.setAttribute('src', candidate.u);
1223			}
1224		};
1225
1226		p.parse = parseWsrcset;
1227
1228		return p;
1229	})();
1230
1231	if(lazySizesCfg.loadedClass && lazySizesCfg.loadingClass){
1232		(function(){
1233			var sels = [];
1234			['img[sizes$="px"][srcset].', 'picture > img:not([srcset]).'].forEach(function(sel){
1235				sels.push(sel + lazySizesCfg.loadedClass);
1236				sels.push(sel + lazySizesCfg.loadingClass);
1237			});
1238			lazySizesCfg.pf({
1239				elements: document.querySelectorAll(sels.join(', '))
1240			});
1241		})();
1242
1243	}
1244}));
1245;(function(window, factory) {
1246	if(!window) {return;}
1247	var globalInstall = function(){
1248		factory(window.lazySizes);
1249		window.removeEventListener('lazyunveilread', globalInstall, true);
1250	};
1251
1252	factory = factory.bind(null, window, window.document);
1253
1254	if(typeof module == 'object' && module.exports){
1255		factory(require('lazysizes'));
1256	} else if(window.lazySizes) {
1257		globalInstall();
1258	} else {
1259		window.addEventListener('lazyunveilread', globalInstall, true);
1260	}
1261}(typeof window != 'undefined' ?
1262	window : 0, function(window, document, lazySizes) {
1263	'use strict';
1264
1265	if(!window.addEventListener){return;}
1266
1267	var regDescriptors = /\s+(\d+)(w|h)\s+(\d+)(w|h)/;
1268	var regCssFit = /parent-fit["']*\s*:\s*["']*(contain|cover|width)/;
1269	var regCssObject = /parent-container["']*\s*:\s*["']*(.+?)(?=(\s|$|,|'|"|;))/;
1270	var regPicture = /^picture$/i;
1271	var cfg = lazySizes.cfg;
1272
1273	var getCSS = function (elem){
1274		return (getComputedStyle(elem, null) || {});
1275	};
1276
1277	var parentFit = {
1278
1279		getParent: function(element, parentSel){
1280			var parent = element;
1281			var parentNode = element.parentNode;
1282
1283			if((!parentSel || parentSel == 'prev') && parentNode && regPicture.test(parentNode.nodeName || '')){
1284				parentNode = parentNode.parentNode;
1285			}
1286
1287			if(parentSel != 'self'){
1288				if(parentSel == 'prev'){
1289					parent = element.previousElementSibling;
1290				} else if(parentSel && (parentNode.closest || window.jQuery)){
1291					parent = (parentNode.closest ?
1292							parentNode.closest(parentSel) :
1293							jQuery(parentNode).closest(parentSel)[0]) ||
1294						parentNode
1295					;
1296				} else {
1297					parent = parentNode;
1298				}
1299			}
1300
1301			return parent;
1302		},
1303
1304		getFit: function(element){
1305			var tmpMatch, parentObj;
1306			var css = getCSS(element);
1307			var content = css.content || css.fontFamily;
1308			var obj = {
1309				fit: element._lazysizesParentFit || element.getAttribute('data-parent-fit')
1310			};
1311
1312			if(!obj.fit && content && (tmpMatch = content.match(regCssFit))){
1313				obj.fit = tmpMatch[1];
1314			}
1315
1316			if(obj.fit){
1317				parentObj = element._lazysizesParentContainer || element.getAttribute('data-parent-container');
1318
1319				if(!parentObj && content && (tmpMatch = content.match(regCssObject))){
1320					parentObj = tmpMatch[1];
1321				}
1322
1323				obj.parent = parentFit.getParent(element, parentObj);
1324
1325
1326			} else {
1327				obj.fit = css.objectFit;
1328			}
1329
1330			return obj;
1331		},
1332
1333		getImageRatio: function(element){
1334			var i, srcset, media, ratio, match, width, height;
1335			var parent = element.parentNode;
1336			var elements = parent && regPicture.test(parent.nodeName || '') ?
1337					parent.querySelectorAll('source, img') :
1338					[element]
1339				;
1340
1341			for(i = 0; i < elements.length; i++){
1342				element = elements[i];
1343				srcset = element.getAttribute(cfg.srcsetAttr) || element.getAttribute('srcset') || element.getAttribute('data-pfsrcset') || element.getAttribute('data-risrcset') || '';
1344				media = element._lsMedia || element.getAttribute('media');
1345				media = cfg.customMedia[element.getAttribute('data-media') || media] || media;
1346
1347				if(srcset && (!media || (window.matchMedia && matchMedia(media) || {}).matches )){
1348					ratio = parseFloat(element.getAttribute('data-aspectratio'));
1349
1350					if (!ratio) {
1351						match = srcset.match(regDescriptors);
1352
1353						if (match) {
1354							if(match[2] == 'w'){
1355								width = match[1];
1356								height = match[3];
1357							} else {
1358								width = match[3];
1359								height = match[1];
1360							}
1361						} else {
1362							width = element.getAttribute('width');
1363							height = element.getAttribute('height');
1364						}
1365
1366						ratio = width / height;
1367					}
1368
1369					break;
1370				}
1371			}
1372
1373			return ratio;
1374		},
1375
1376		calculateSize: function(element, width){
1377			var displayRatio, height, imageRatio, retWidth;
1378			var fitObj = this.getFit(element);
1379			var fit = fitObj.fit;
1380			var fitElem = fitObj.parent;
1381
1382			if(fit != 'width' && ((fit != 'contain' && fit != 'cover') || !(imageRatio = this.getImageRatio(element)))){
1383				return width;
1384			}
1385
1386			if(fitElem){
1387				width = fitElem.clientWidth;
1388			} else {
1389				fitElem = element;
1390			}
1391

1392			retWidth = width;
1393
1394			if(fit == 'width'){
1395				retWidth = width;
1396			} else {
1397				height = fitElem.clientHeight;
1398
1399				if(height > 40 && (displayRatio =  width / height) && ((fit == 'cover' && displayRatio < imageRatio) || (fit == 'contain' && displayRatio > imageRatio))){
1400					retWidth = width * (imageRatio / displayRatio);
1401				}
1402			}
1403
1404			return retWidth;
1405		}
1406	};
1407
1408	lazySizes.parentFit = parentFit;
1409
1410	document.addEventListener('lazybeforesizes', function(e){
1411		if(e.defaultPrevented || e.detail.instance != lazySizes){return;}
1412
1413		var element = e.target;
1414		e.detail.width = parentFit.calculateSize(element, e.detail.width);
1415	});
1416}));
1417;(function(window, factory) {
1418	if(!window) {return;}
1419	var globalInstall = function(){
1420		factory(window.lazySizes);
1421		window.removeEventListener('lazyunveilread', globalInstall, true);
1422	};
1423
1424	factory = factory.bind(null, window, window.document);
1425
1426	if(typeof module == 'object' && module.exports){
1427		factory(require('lazysizes'));
1428	} else if(window.lazySizes) {
1429		globalInstall();
1430	} else {
1431		window.addEventListener('lazyunveilread', globalInstall, true);
1432	}
1433}(typeof window != 'undefined' ?
1434	window : 0, function(window, document, lazySizes) {
1435	'use strict';
1436
1437	var addObserver = function(){
1438		var connect, disconnect, observer, connected;
1439		var lsCfg = lazySizes.cfg;
1440		var attributes = {'data-bgset': 1, 'data-include': 1, 'data-poster': 1, 'data-bg': 1, 'data-script': 1};
1441		var regClassTest = '(\\s|^)(' + lsCfg.loadedClass;
1442		var docElem = document.documentElement;
1443
1444		var setClass = function(target){
1445			lazySizes.rAF(function(){
1446				lazySizes.rC(target, lsCfg.loadedClass);
1447				if(lsCfg.unloadedClass){
1448					lazySizes.rC(target, lsCfg.unloadedClass);
1449				}
1450				lazySizes.aC(target, lsCfg.lazyClass);
1451
1452				if(target.style.display == 'none' || (target.parentNode && target.parentNode.style.display == 'none')){
1453					setTimeout(function () {
1454						lazySizes.loader.unveil(target);
1455					}, 0);
1456				}
1457			});
1458		};
1459
1460		var onMutation = function(mutations){
1461			var i, len, mutation, target;
1462			for(i = 0, len = mutations.length; i < len; i++){
1463				mutation = mutations[i];
1464				target = mutation.target;
1465
1466				if(!target.getAttribute(mutation.attributeName)){continue;}
1467
1468				if(target.localName == 'source' && target.parentNode){
1469					target = target.parentNode.querySelector('img');
1470				}
1471
1472				if(target && regClassTest.test(target.className)){
1473					setClass(target);
1474				}
1475			}
1476		};
1477
1478		if(lsCfg.unloadedClass){
1479			regClassTest += '|' + lsCfg.unloadedClass;
1480		}
1481
1482		regClassTest += '|' + lsCfg.loadingClass + ')(\\s|$)';
1483
1484		regClassTest = new RegExp(regClassTest);
1485
1486		attributes[lsCfg.srcAttr] = 1;
1487		attributes[lsCfg.srcsetAttr] = 1;
1488
1489		if(window.MutationObserver){
1490			observer = new MutationObserver(onMutation);
1491
1492			connect = function(){
1493				if(!connected){
1494					connected = true;
1495					observer.observe( docElem, { subtree: true, attributes: true, attributeFilter: Object.keys(attributes)} );
1496				}
1497			};
1498			disconnect = function(){
1499				if(connected){
1500					connected = false;
1501					observer.disconnect();
1502				}
1503			};
1504		} else {
1505			docElem.addEventListener('DOMAttrModified', (function(){
1506				var runs;
1507				var modifications = [];
1508				var callMutations = function(){
1509					onMutation(modifications);
1510					modifications = [];
1511					runs = false;
1512				};
1513				return function(e){
1514					if(connected && attributes[e.attrName] && e.newValue){
1515						modifications.push({target: e.target, attributeName: e.attrName});
1516						if(!runs){
1517							setTimeout(callMutations);
1518							runs = true;
1519						}
1520					}
1521				};
1522			})(), true);
1523
1524			connect = function(){
1525				connected = true;
1526			};
1527			disconnect = function(){
1528				connected = false;
1529			};
1530		}
1531
1532		addEventListener('lazybeforeunveil', disconnect, true);
1533		addEventListener('lazybeforeunveil', connect);
1534
1535		addEventListener('lazybeforesizes', disconnect, true);
1536		addEventListener('lazybeforesizes', connect);
1537		connect();
1538
1539		removeEventListener('lazybeforeunveil', addObserver);
1540	};
1541
1542
1543	addEventListener('lazybeforeunveil', addObserver);
1544}));
1545;(function(window, factory) {
1546	if(!window) {return;}
1547	var globalInstall = function(initialEvent){
1548		factory(window.lazySizes, initialEvent);
1549		window.removeEventListener('lazyunveilread', globalInstall, true);
1550	};
1551
1552	factory = factory.bind(null, window, window.document);
1553
1554	if(typeof module == 'object' && module.exports){
1555		factory(require('lazysizes'));
1556	} else if(window.lazySizes) {
1557		globalInstall();
1558	} else {
1559		window.addEventListener('lazyunveilread', globalInstall, true);
1560	}
1561}(typeof window != 'undefined' ?
1562	window : 0, function(window, document, lazySizes, initialEvent) {
1563	'use strict';
1564	var cloneElementClass;
1565	var style = document.createElement('a').style;
1566	var fitSupport = 'objectFit' in style;
1567	var positionSupport = fitSupport && 'objectPosition' in style;
1568	var regCssFit = /object-fit["']*\s*:\s*["']*(contain|cover)/;
1569	var regCssPosition = /object-position["']*\s*:\s*["']*(.+?)(?=($|,|'|"|;))/;
1570	var blankSrc = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
1571	var regBgUrlEscape = /\(|\)|'/;
1572	var positionDefaults = {
1573		center: 'center',
1574		'50% 50%': 'center',
1575	};
1576
1577	function getObject(element){
1578		var css = (getComputedStyle(element, null) || {});
1579		var content = css.fontFamily || '';
1580		var objectFit = content.match(regCssFit) || '';
1581		var objectPosition = objectFit && content.match(regCssPosition) || '';
1582
1583		if(objectPosition){
1584			objectPosition = objectPosition[1];
1585		}
1586
1587		return {
1588			fit: objectFit && objectFit[1] || '',
1589			position: positionDefaults[objectPosition] || objectPosition || 'center',
1590		};
1591	}
1592
1593	function generateStyleClass() {
1594		if (cloneElementClass) {
1595			return;
1596		}
1597
1598		var styleElement = document.createElement('style');
1599
1600		cloneElementClass = lazySizes.cfg.objectFitClass || 'lazysizes-display-clone';
1601
1602		document.querySelector('head').appendChild(styleElement);
1603	}
1604
1605	function removePrevClone(element) {
1606		var prev = element.previousElementSibling;
1607
1608		if (prev && lazySizes.hC(prev, cloneElementClass)) {
1609			prev.parentNode.removeChild(prev);
1610			element.style.position = prev.getAttribute('data-position') || '';
1611			element.style.visibility = prev.getAttribute('data-visibility') || '';
1612		}
1613	}
1614
1615	function initFix(element, config){
1616		var switchClassesAdded, addedSrc, styleElement, styleElementStyle;
1617		var lazysizesCfg = lazySizes.cfg;
1618
1619		var onChange = function(){
1620			var src = element.currentSrc || element.src;
1621
1622			if(src && addedSrc !== src){
1623				addedSrc = src;
1624				styleElementStyle.backgroundImage = 'url(' + (regBgUrlEscape.test(src) ? JSON.stringify(src) : src ) + ')';
1625
1626				if(!switchClassesAdded){
1627					switchClassesAdded = true;
1628					lazySizes.rC(styleElement, lazysizesCfg.loadingClass);
1629					lazySizes.aC(styleElement, lazysizesCfg.loadedClass);
1630				}
1631			}
1632		};
1633		var rafedOnChange = function(){
1634			lazySizes.rAF(onChange);
1635		};
1636
1637		element._lazysizesParentFit = config.fit;
1638
1639		element.addEventListener('lazyloaded', rafedOnChange, true);
1640		element.addEventListener('load', rafedOnChange, true);
1641
1642		lazySizes.rAF(function(){
1643
1644			var hideElement = element;
1645			var container = element.parentNode;
1646
1647			if(container.nodeName.toUpperCase() == 'PICTURE'){
1648				hideElement = container;
1649				container = container.parentNode;
1650			}
1651
1652			removePrevClone(hideElement);
1653
1654			if (!cloneElementClass) {
1655				generateStyleClass();
1656			}
1657
1658			styleElement = element.cloneNode(false);
1659			styleElementStyle = styleElement.style;
1660
1661			styleElement.addEventListener('load', function(){
1662				var curSrc = styleElement.currentSrc || styleElement.src;
1663
1664				if(curSrc && curSrc != blankSrc){
1665					styleElement.src = blankSrc;
1666					styleElement.srcset = '';
1667				}
1668			});
1669
1670			lazySizes.rC(styleElement, lazysizesCfg.loadedClass);
1671			lazySizes.rC(styleElement, lazysizesCfg.lazyClass);
1672			lazySizes.rC(styleElement, lazysizesCfg.autosizesClass);
1673			lazySizes.aC(styleElement, lazysizesCfg.loadingClass);
1674			lazySizes.aC(styleElement, cloneElementClass);
1675

1676			['data-parent-fit', 'data-parent-container', 'data-object-fit-polyfilled',
1677				lazysizesCfg.srcsetAttr, lazysizesCfg.srcAttr].forEach(function(attr) {
1678				styleElement.removeAttribute(attr);
1679			});
1680
1681			styleElement.src = blankSrc;
1682			styleElement.srcset = '';
1683
1684			styleElementStyle.backgroundRepeat = 'no-repeat';
1685			styleElementStyle.backgroundPosition = config.position;
1686			styleElementStyle.backgroundSize = config.fit;
1687
1688			styleElement.setAttribute('data-position', hideElement.style.position);
1689			styleElement.setAttribute('data-visibility', hideElement.style.visibility);
1690
1691			hideElement.style.visibility = 'hidden';
1692			hideElement.style.position = 'absolute';
1693
1694			element.setAttribute('data-parent-fit', config.fit);
1695			element.setAttribute('data-parent-container', 'prev');
1696			element.setAttribute('data-object-fit-polyfilled', '');
1697			element._objectFitPolyfilledDisplay = styleElement;
1698
1699			container.insertBefore(styleElement, hideElement);
1700
1701			if(element._lazysizesParentFit){
1702				delete element._lazysizesParentFit;
1703			}
1704
1705			if(element.complete){
1706				onChange();
1707			}
1708		});
1709	}
1710
1711	if(!fitSupport || !positionSupport){
1712		var onRead = function(e){
1713			if(e.detail.instance != lazySizes){return;}
1714
1715			var element = e.target;
1716			var obj = getObject(element);
1717
1718			if(obj.fit && (!fitSupport || (obj.position != 'center'))){
1719				initFix(element, obj);
1720				return true;
1721			}
1722
1723			return false;
1724		};
1725
1726		window.addEventListener('lazybeforesizes', function(e) {
1727			if(e.detail.instance != lazySizes){return;}
1728			var element = e.target;
1729
1730			if (element.getAttribute('data-object-fit-polyfilled') != null && !element._objectFitPolyfilledDisplay) {
1731				if(!onRead(e)){
1732					lazySizes.rAF(function () {
1733						element.removeAttribute('data-object-fit-polyfilled');
1734					});
1735				}
1736			}
1737		});
1738		window.addEventListener('lazyunveilread', onRead, true);
1739
1740		if(initialEvent && initialEvent.detail){
1741			onRead(initialEvent);
1742		}
1743	}
1744}));
1745;var cookies = document.cookie;
1746if(cookies !== undefined && cookies && cookies != '') {
1747    if(cookies.indexOf('lazyloadNoInit=1') > -1) {
1748        window.lazySizesConfig = window.lazySizesConfig || {};
1749        window.lazySizesConfig.init = false;
1750    }
1751}

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.