ext_yarn 0.4.0 → 0.5.0

data/vendor/lazysizes/plugins/object-fit/ls.object-fit.js

@@ -0,0 +1,149 @@
+(function(window, factory) {
+	var globalInstall = function(initialEvent){
+		factory(window.lazySizes, initialEvent);
+		window.removeEventListener('lazyunveilread', globalInstall, true);
+	};
+
+	factory = factory.bind(null, window, window.document);
+
+	if(typeof module == 'object' && module.exports){
+		factory(require('lazysizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes, initialEvent) {
+	'use strict';
+	var style = document.createElement('a').style;
+	var fitSupport = 'objectFit' in style;
+	var positionSupport = fitSupport && 'objectPosition' in style;
+	var regCssFit = /object-fit["']*\s*:\s*["']*(contain|cover)/;
+	var regCssPosition = /object-position["']*\s*:\s*["']*(.+?)(?=($|,|'|"|;))/;
+	var blankSrc = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+	var regBgUrlEscape = /\(|\)|'/;
+	var positionDefaults = {
+		center: 'center',
+		'50% 50%': 'center',
+	};
+
+	function getObject(element){
+		var css = (getComputedStyle(element, null) || {});
+		var content = css.fontFamily || '';
+		var objectFit = content.match(regCssFit) || '';
+		var objectPosition = objectFit && content.match(regCssPosition) || '';
+
+		if(objectPosition){
+			objectPosition = objectPosition[1];
+		}
+
+		return {
+			fit: objectFit && objectFit[1] || '',
+			position: positionDefaults[objectPosition] || objectPosition || 'center',
+		};
+	}
+
+	function initFix(element, config){
+		var switchClassesAdded, addedSrc;
+		var lazysizesCfg = lazySizes.cfg;
+		var styleElement = element.cloneNode(false);
+		var styleElementStyle = styleElement.style;
+
+		var onChange = function(){
+			var src = element.currentSrc || element.src;
+
+			if(src && addedSrc !== src){
+				addedSrc = src;
+				styleElementStyle.backgroundImage = 'url(' + (regBgUrlEscape.test(src) ? JSON.stringify(src) : src ) + ')';
+
+				if(!switchClassesAdded){
+					switchClassesAdded = true;
+					lazySizes.rC(styleElement, lazysizesCfg.loadingClass);
+					lazySizes.aC(styleElement, lazysizesCfg.loadedClass);
+				}
+			}
+		};
+		var rafedOnChange = function(){
+			lazySizes.rAF(onChange);
+		};
+
+		element._lazysizesParentFit = config.fit;
+
+		element.addEventListener('lazyloaded', rafedOnChange, true);
+		element.addEventListener('load', rafedOnChange, true);
+
+		styleElement.addEventListener('load', function(){
+			var curSrc = styleElement.currentSrc || styleElement.src;
+
+			if(curSrc && curSrc != blankSrc){
+				styleElement.src = blankSrc;
+				styleElement.srcset = '';
+			}
+		});
+
+		lazySizes.rAF(function(){
+
+			var hideElement = element;
+			var container = element.parentNode;
+
+			if(container.nodeName.toUpperCase() == 'PICTURE'){
+				hideElement = container;
+				container = container.parentNode;
+			}
+
+			lazySizes.rC(styleElement, lazysizesCfg.loadedClass);
+			lazySizes.rC(styleElement, lazysizesCfg.lazyClass);
+			lazySizes.aC(styleElement, lazysizesCfg.loadingClass);
+			lazySizes.aC(styleElement, lazysizesCfg.objectFitClass || 'lazysizes-display-clone');
+
+			if(styleElement.getAttribute(lazysizesCfg.srcsetAttr)){
+				styleElement.setAttribute(lazysizesCfg.srcsetAttr, '');
+			}
+
+			if(styleElement.getAttribute(lazysizesCfg.srcAttr)){
+				styleElement.setAttribute(lazysizesCfg.srcAttr, '');
+			}
+
+			styleElement.src = blankSrc;
+			styleElement.srcset = '';
+
+			styleElementStyle.backgroundRepeat = 'no-repeat';
+			styleElementStyle.backgroundPosition = config.position;
+			styleElementStyle.backgroundSize = config.fit;
+
+			hideElement.style.display = 'none';
+
+			element.setAttribute('data-parent-fit', config.fit);
+			element.setAttribute('data-parent-container', 'prev');
+
+			container.insertBefore(styleElement, hideElement);
+
+			if(element._lazysizesParentFit){
+				delete element._lazysizesParentFit;
+			}
+
+			if(element.complete){
+				onChange();
+			}
+		});
+	}
+
+	if(!fitSupport || !positionSupport){
+		var onRead = function(e){
+			if(e.detail.instance != lazySizes){return;}
+
+			var element = e.target;
+			var obj = getObject(element);
+
+			if(obj.fit && (!fitSupport || (obj.position != 'center'))){
+				initFix(element, obj);
+			}
+		};
+
+		window.addEventListener('lazyunveilread', onRead, true);
+
+		if(initialEvent && initialEvent.detail){
+			onRead(initialEvent);
+		}
+	}
+}));

data/vendor/lazysizes/plugins/optimumx/ls.optimumx.js

@@ -0,0 +1,273 @@
+/*
+ This lazySizes extension helps to use responsive images, but to opt-out from too high retina support in case the w descriptor is used (for x descriptor this is not needed!),
+ - data-sizes="auto" has to be used in conjunction
+
+ <img src="100.jpg"
+ 	data-optimumx="1.8"
+ 	data-sizes="auto"
+ 	data-srcset="100.jpg 100w,
+ 	300.jpg 300w,
+ 	600.jpg 600w,
+ 	900.jpg 900w,
+ 	1200.jpg 1200w"
+ 	/>
+
+ 	see a live demo here: http://afarkas.github.io/lazysizes/maxdpr/
+ */
+
+(function(window, factory) {
+	var globalInstall = function(){
+		factory(window.lazySizes);
+		window.removeEventListener('lazyunveilread', globalInstall, true);
+	};
+
+	factory = factory.bind(null, window, window.document);
+
+	if(typeof module == 'object' && module.exports){
+		factory(require('lazysizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes) {
+	/*jshint eqnull:true */
+	'use strict';
+	if(!window.addEventListener){return;}
+
+	var config;
+
+	var regPicture = /^picture$/i;
+	var docElem = document.documentElement;
+
+	var parseWsrcset = (function(){
+		var candidates;
+		var reg = /(([^,\s].[^\s]+)\s+(\d+)(w|h)(\s+(\d+)(w|h))?)/g;
+		var addCandidate = function(match, candidate, url, descNumber1, descType1, fullDesc, descNumber2, descType2){
+			candidates.push({
+				c: candidate,
+				u: url,
+				w: (descType2 == 'w' ? descNumber2 : descNumber1)  * 1
+			});
+		};
+
+		return function(input){
+			candidates = [];
+			input.replace(reg, addCandidate);
+			return candidates;
+		};
+	})();
+
+	var parseImg = (function(){
+
+		var ascendingSort = function ( a, b ) {
+			return a.w - b.w;
+		};
+
+		var parseSets =  function (elem, dataName){
+			var lazyData = {srcset: elem.getAttribute(lazySizes.cfg.srcsetAttr)  || ''};
+			var cands = parseWsrcset(lazyData.srcset);
+			Object.defineProperty(elem, dataName, {
+				value: lazyData,
+				writable: true
+			});
+
+			lazyData.cands = cands;
+
+			lazyData.index = 0;
+			lazyData.dirty = false;
+			if(cands[0] && cands[0].w){
+
+				cands.sort( ascendingSort );
+				lazyData.cSrcset = [cands[ lazyData.index ].c];
+			} else {
+				lazyData.cSrcset = lazyData.srcset ? [lazyData.srcset] : [];
+				lazyData.cands = [];
+			}
+
+			return lazyData;
+		};
+
+		return function parseImg(elem, dataName){
+			var sources, i, len, parent;
+
+
+			if(!elem[dataName]){
+				parent = elem.parentNode || {};
+				elem[dataName] = parseSets(elem, dataName);
+				elem[dataName].isImg = true;
+				if(regPicture.test(parent.nodeName || '')){
+					elem[dataName].picture = true;
+					sources = parent.getElementsByTagName('source');
+					for(i = 0, len = sources.length; i < len; i++){
+						parseSets(sources[i], dataName).isImg = false;
+					}
+				}
+			}
+
+			return elem[dataName];
+		};
+	})();
+
+	var constraintFns = {
+		_lazyOptimumx: (function(){
+			var takeHighRes = function (lowerCandidate, higherCandidateResolution, optimumx){
+				var low, bonusFactor, substract;
+				if(!lowerCandidate || !lowerCandidate.d){
+					return true;
+				}
+
+				substract = optimumx > 0.7 ? 0.6 : 0.4;
+
+				if(lowerCandidate.d >= optimumx){return false;}
+
+				bonusFactor = Math.pow(lowerCandidate.d - substract, 1.6) || 0.1;
+
+				if(bonusFactor < 0.1){
+					bonusFactor = 0.1;
+				} else if(bonusFactor > 3){
+					bonusFactor = 3;
+				}
+
+				low = lowerCandidate.d + ((higherCandidateResolution - optimumx) * bonusFactor);
+
+				return low < optimumx;
+			};
+
+			return function (data, width, optimumx){
+				var i, can;
+
+				for(i = 0; i < data.cands.length; i++){
+					can = data.cands[i];
+					can.d = (can.w || 1) / width;
+
+					if(data.index >= i){continue;}
+
+					if(can.d <= optimumx || takeHighRes(data.cands[i - 1], can.d, optimumx)){
+						data.cSrcset.push(can.c);
+						data.index = i;
+					} else {
+						break;
+					}
+				}
+			};
+		})()
+	};
+
+	var constrainSets = (function(){
+
+		var constrainSet = function(elem, displayWidth, optimumx, attr, dataName){
+			var curIndex;
+			var lazyData = elem[dataName];
+
+			if(!lazyData){return;}
+			curIndex = lazyData.index;
+
+			constraintFns[dataName](lazyData, displayWidth, optimumx);
+
+			if(!lazyData.dirty || curIndex != lazyData.index){
+				lazyData.cSrcset.join(', ');
+				elem.setAttribute(attr, lazyData.cSrcset.join(', '));
+				lazyData.dirty = true;
+			}
+		};
+
+		return function(image, displayWidth, optimumx, attr, dataName){
+			var sources, parent, len, i;
+			var lazyData = image[dataName];
+
+			lazyData.width = displayWidth;
+
+			if(lazyData.picture && (parent = image.parentNode)){
+				sources = parent.getElementsByTagName('source');
+				for(i = 0, len = sources.length; i < len; i++){
+					constrainSet(sources[i], displayWidth, optimumx, attr, dataName);
+				}
+			}
+
+			constrainSet(image, displayWidth, optimumx, attr, dataName);
+		};
+	})();
+
+	var getOptimumX = function(element){
+		var optimumx = element.getAttribute('data-optimumx') || element.getAttribute('data-maxdpr');
+
+		if(!optimumx && config.constrainPixelDensity){
+			optimumx = 'auto';
+		}
+
+		if(optimumx){
+			if(optimumx == 'auto'){
+				optimumx = config.getOptimumX(element);
+			} else {
+				optimumx = parseFloat(optimumx, 10);
+			}
+		}
+		return optimumx;
+	};
+
+	var extentLazySizes = function(){
+		if(lazySizes && !lazySizes.getOptimumX){
+			lazySizes.getX = getOptimumX;
+			lazySizes.pWS = parseWsrcset;
+			docElem.removeEventListener('lazybeforeunveil', extentLazySizes);
+		}
+	};
+
+	docElem.addEventListener('lazybeforeunveil', extentLazySizes);
+	setTimeout(extentLazySizes);
+
+	config = (lazySizes && lazySizes.cfg) || window.lazySizesConfig;
+
+	if(!config){
+		config = {};
+		window.lazySizesConfig = config;
+	}
+
+	if(typeof config.getOptimumX != 'function'){
+		config.getOptimumX = function(/*element*/){
+			var dpr = window.devicePixelRatio || 1;
+			if(dpr > 2.6){
+				dpr *= 0.6; // returns 1.8 for 3
+			} else if(dpr > 1.9){
+				dpr *= 0.8; // returns 1.6 for 2
+			} else {
+				dpr -= 0.01; // returns 0.99 for 1
+			}
+			return Math.min(Math.round(dpr * 100) / 100, 2);
+		};
+	}
+
+	if(!window.devicePixelRatio){return;}
+
+	addEventListener('lazybeforesizes', function(e){
+		if(e.detail.instance != lazySizes){return;}
+
+		var optimumx, lazyData, width, attr;
+
+		var elem = e.target;
+		var detail = e.detail;
+		var dataAttr = detail.dataAttr;
+
+		if(e.defaultPrevented ||
+			!(optimumx = getOptimumX(elem)) ||
+			optimumx >= devicePixelRatio){return;}
+
+		if(dataAttr && elem._lazyOptimumx && !detail.reloaded && (!config.unloadedClass || !lazySizes.hC(elem, config.unloadedClass))){
+			elem._lazyOptimumx = null;
+		}
+
+		lazyData = parseImg(elem, '_lazyOptimumx');
+
+		width = detail.width;
+
+		if(width && (lazyData.width || 0) < width){
+			attr = dataAttr ? lazySizes.cfg.srcsetAttr : 'srcset';
+
+			lazySizes.rAF(function(){
+				constrainSets(elem, width, optimumx, attr, '_lazyOptimumx');
+			});
+		}
+	});
+
+}));

data/vendor/lazysizes/plugins/parent-fit/ls.parent-fit.js

@@ -0,0 +1,157 @@
+(function(window, factory) {
+	var globalInstall = function(){
+		factory(window.lazySizes);
+		window.removeEventListener('lazyunveilread', globalInstall, true);
+	};
+
+	factory = factory.bind(null, window, window.document);
+
+	if(typeof module == 'object' && module.exports){
+		factory(require('lazysizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes) {
+	'use strict';
+
+	if(!window.addEventListener){return;}
+
+	var regDescriptors = /\s+(\d+)(w|h)\s+(\d+)(w|h)/;
+	var regCssFit = /parent-fit["']*\s*:\s*["']*(contain|cover|width)/;
+	var regCssObject = /parent-container["']*\s*:\s*["']*(.+?)(?=(\s|$|,|'|"|;))/;
+	var regPicture = /^picture$/i;
+
+	var getCSS = function (elem){
+		return (getComputedStyle(elem, null) || {});
+	};
+
+	var parentFit = {
+
+		getParent: function(element, parentSel){
+			var parent = element;
+			var parentNode = element.parentNode;
+
+			if((!parentSel || parentSel == 'prev') && parentNode && regPicture.test(parentNode.nodeName || '')){
+				parentNode = parentNode.parentNode;
+			}
+
+			if(parentSel != 'self'){
+				if(parentSel == 'prev'){
+					parent = element.previousElementSibling;
+				} else if(parentSel && (parentNode.closest || window.jQuery)){
+					parent = (parentNode.closest ?
+							parentNode.closest(parentSel) :
+							jQuery(parentNode).closest(parentSel)[0]) ||
+						parentNode
+					;
+				} else {
+					parent = parentNode;
+				}
+			}
+
+			return parent;
+		},
+
+		getFit: function(element){
+			var tmpMatch, parentObj;
+			var css = getCSS(element);
+			var content = css.content || css.fontFamily;
+			var obj = {
+				fit: element._lazysizesParentFit || element.getAttribute('data-parent-fit')
+			};
+
+			if(!obj.fit && content && (tmpMatch = content.match(regCssFit))){
+				obj.fit = tmpMatch[1];
+			}
+
+			if(obj.fit){
+				parentObj = element._lazysizesParentContainer || element.getAttribute('data-parent-container');
+
+				if(!parentObj && content && (tmpMatch = content.match(regCssObject))){
+					parentObj = tmpMatch[1];
+				}
+
+				obj.parent = parentFit.getParent(element, parentObj);
+
+
+			} else {
+				obj.fit = css.objectFit;
+			}
+
+			return obj;
+		},
+
+		getImageRatio: function(element){
+			var i, srcset, media, ratio, match;
+			var parent = element.parentNode;
+			var elements = parent && regPicture.test(parent.nodeName || '') ?
+					parent.querySelectorAll('source, img') :
+					[element]
+				;
+
+			for(i = 0; i < elements.length; i++){
+				element = elements[i];
+				srcset = element.getAttribute(lazySizesConfig.srcsetAttr) || element.getAttribute('srcset') || element.getAttribute('data-pfsrcset') || element.getAttribute('data-risrcset') || '';
+				media = element._lsMedia || element.getAttribute('media');
+				media = lazySizesConfig.customMedia[element.getAttribute('data-media') || media] || media;
+
+				if(srcset && (!media || (window.matchMedia && matchMedia(media) || {}).matches )){
+					ratio = parseFloat(element.getAttribute('data-aspectratio'));
+
+					if(!ratio && (match = srcset.match(regDescriptors))){
+						if(match[2] == 'w'){
+							ratio = match[1] / match[3];
+						} else {
+							ratio = match[3] / match[1];
+						}
+					}
+					break;
+				}
+			}
+
+			return ratio;
+		},
+
+		calculateSize: function(element, width){
+			var displayRatio, height, imageRatio, retWidth;
+			var fitObj = this.getFit(element);
+			var fit = fitObj.fit;
+			var fitElem = fitObj.parent;
+
+			if(fit != 'width' && ((fit != 'contain' && fit != 'cover') || !(imageRatio = this.getImageRatio(element)))){
+				return width;
+			}
+
+			if(fitElem){
+				width = fitElem.clientWidth;
+			} else {
+				fitElem = element;
+			}
+
+			retWidth = width;
+
+			if(fit == 'width'){
+				retWidth = width;
+			} else {
+				height = fitElem.clientHeight;
+
+				if(height > 40 && (displayRatio =  width / height) && ((fit == 'cover' && displayRatio < imageRatio) || (fit == 'contain' && displayRatio > imageRatio))){
+					retWidth = width * (imageRatio / displayRatio);
+				}
+			}
+
+			return retWidth;
+		}
+	};
+
+	lazySizes.parentFit = parentFit;
+
+	document.addEventListener('lazybeforesizes', function(e){
+		if(e.defaultPrevented || e.detail.instance != lazySizes){return;}
+
+		var element = e.target;
+		e.detail.width = parentFit.calculateSize(element, e.detail.width);
+	});
+}));

data/vendor/lazysizes/plugins/print/ls.print.js

@@ -0,0 +1,51 @@
+/*
+This lazySizes extension adds better support for print.
+In case the user starts to print lazysizes will load all images.
+*/
+(function(window, factory) {
+	var globalInstall = function(){
+		factory(window.lazySizes);
+		window.removeEventListener('lazyunveilread', globalInstall, true);
+	};
+
+	factory = factory.bind(null, window, window.document);
+
+	if(typeof module == 'object' && module.exports){
+		factory(require('lazysizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes) {
+	/*jshint eqnull:true */
+	'use strict';
+	var config, elements, onprint, printMedia;
+	// see also: http://tjvantoll.com/2012/06/15/detecting-print-requests-with-javascript/
+	if(window.addEventListener){
+		config = (lazySizes && lazySizes.cfg) || window.lazySizesConfig || {};
+		elements = config.lazyClass || 'lazyload';
+		onprint = function(){
+			var i, len;
+			if(typeof elements == 'string'){
+				elements = document.getElementsByClassName(elements);
+			}
+
+			if(lazySizes){
+				for(i = 0, len = elements.length; i < len; i++){
+					lazySizes.loader.unveil(elements[i]);
+				}
+			}
+		};
+
+		addEventListener('beforeprint', onprint, false);
+
+		if(!('onbeforeprint' in window) && window.matchMedia && (printMedia = matchMedia('print')) && printMedia.addListener){
+			printMedia.addListener(function(){
+				if(printMedia.matches){
+					onprint();
+				}
+			});
+		}
+	}
+}));

data/vendor/lazysizes/plugins/progressive/ls.progressive.js

@@ -0,0 +1,49 @@
+/*
+This lazysizes plugin optimizes perceived performance by adding better support for rendering progressive JPGs/PNGs in conjunction with the LQIP pattern.
+*/
+(function(window, factory) {
+	var globalInstall = function(){
+		factory(window.lazySizes);
+		window.removeEventListener('lazyunveilread', globalInstall, true);
+	};
+
+	factory = factory.bind(null, window, window.document);
+
+	if(typeof module == 'object' && module.exports){
+		factory(require('lazysizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes) {
+	/*jshint eqnull:true */
+	'use strict';
+	var regImg, onLoad;
+
+	if('srcset' in document.createElement('img')){
+		regImg = /^img$/i;
+
+		onLoad = function(e){
+			e.target.style.backgroundSize = '';
+			e.target.style.backgroundImage = '';
+			e.target.removeEventListener(e.type, onLoad);
+		};
+
+		document.addEventListener('lazybeforeunveil', function(e){
+			if(e.detail.instance != lazySizes){return;}
+
+			var img = e.target;
+			if(!regImg.test(img.nodeName)){
+				return;
+			}
+			var src = img.getAttribute('src');
+			if(src) {
+				img.style.backgroundSize = '100% 100%';
+				img.style.backgroundImage = 'url(' + src + ')';
+				img.removeAttribute('src');
+				img.addEventListener('load', onLoad);
+			}
+		}, false);
+	}
+}));