ext_yarn 0.4.0 → 0.5.0

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

@@ -0,0 +1,198 @@
+(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 regWhite = /\s+/g;
+	var regSplitSet = /\s*\|\s+|\s+\|\s*/g;
+	var regSource = /^(.+?)(?:\s+\[\s*(.+?)\s*\])(?:\s+\[\s*(.+?)\s*\])?$/;
+	var regType = /^\s*\(*\s*type\s*:\s*(.+?)\s*\)*\s*$/;
+	var regBgUrlEscape = /\(|\)|'/;
+	var allowedBackgroundSize = {contain: 1, cover: 1};
+	var proxyWidth = function(elem){
+		var width = lazySizes.gW(elem, elem.parentNode);
+
+		if(!elem._lazysizesWidth || width > elem._lazysizesWidth){
+			elem._lazysizesWidth = width;
+		}
+		return elem._lazysizesWidth;
+	};
+	var getBgSize = function(elem){
+		var bgSize;
+
+		bgSize = (getComputedStyle(elem) || {getPropertyValue: function(){}}).getPropertyValue('background-size');
+
+		if(!allowedBackgroundSize[bgSize] && allowedBackgroundSize[elem.style.backgroundSize]){
+			bgSize = elem.style.backgroundSize;
+		}
+
+		return bgSize;
+	};
+	var setTypeOrMedia = function(source, match){
+		if(match){
+			var typeMatch = match.match(regType);
+			if(typeMatch && typeMatch[1]){
+				source.setAttribute('type', typeMatch[1]);
+			} else {
+				source.setAttribute('media', lazySizesConfig.customMedia[match] || match);
+			}
+		}
+	};
+	var createPicture = function(sets, elem, img){
+		var picture = document.createElement('picture');
+		var sizes = elem.getAttribute(lazySizesConfig.sizesAttr);
+		var ratio = elem.getAttribute('data-ratio');
+		var optimumx = elem.getAttribute('data-optimumx');
+
+		if(elem._lazybgset && elem._lazybgset.parentNode == elem){
+			elem.removeChild(elem._lazybgset);
+		}
+
+		Object.defineProperty(img, '_lazybgset', {
+			value: elem,
+			writable: true
+		});
+		Object.defineProperty(elem, '_lazybgset', {
+			value: picture,
+			writable: true
+		});
+
+		sets = sets.replace(regWhite, ' ').split(regSplitSet);
+
+		picture.style.display = 'none';
+		img.className = lazySizesConfig.lazyClass;
+
+		if(sets.length == 1 && !sizes){
+			sizes = 'auto';
+		}
+
+		sets.forEach(function(set){
+			var match;
+			var source = document.createElement('source');
+
+			if(sizes && sizes != 'auto'){
+				source.setAttribute('sizes', sizes);
+			}
+
+			if((match = set.match(regSource))){
+				source.setAttribute(lazySizesConfig.srcsetAttr, match[1]);
+
+				setTypeOrMedia(source, match[2]);
+				setTypeOrMedia(source, match[3]);
+			} else {
+				source.setAttribute(lazySizesConfig.srcsetAttr, set);
+			}
+
+			picture.appendChild(source);
+		});
+
+		if(sizes){
+			img.setAttribute(lazySizesConfig.sizesAttr, sizes);
+			elem.removeAttribute(lazySizesConfig.sizesAttr);
+			elem.removeAttribute('sizes');
+		}
+		if(optimumx){
+			img.setAttribute('data-optimumx', optimumx);
+		}
+		if(ratio) {
+			img.setAttribute('data-ratio', ratio);
+		}
+
+		picture.appendChild(img);
+
+		elem.appendChild(picture);
+	};
+
+	var proxyLoad = function(e){
+		if(!e.target._lazybgset){return;}
+
+		var image = e.target;
+		var elem = image._lazybgset;
+		var bg = image.currentSrc || image.src;
+
+
+		if(bg){
+			var event = lazySizes.fire(elem, 'bgsetproxy', {
+				src: bg,
+				useSrc: regBgUrlEscape.test(bg) ? JSON.stringify(bg) : bg,
+			});
+
+			if(!event.defaultPrevented){
+				elem.style.backgroundImage = 'url(' + event.detail.useSrc + ')';
+			}
+		}
+
+		if(image._lazybgsetLoading){
+			lazySizes.fire(elem, '_lazyloaded', {}, false, true);
+			delete image._lazybgsetLoading;
+		}
+	};
+
+	addEventListener('lazybeforeunveil', function(e){
+		var set, image, elem;
+
+		if(e.defaultPrevented || !(set = e.target.getAttribute('data-bgset'))){return;}
+
+		elem = e.target;
+		image = document.createElement('img');
+
+		image.alt = '';
+
+		image._lazybgsetLoading = true;
+		e.detail.firesLoad = true;
+
+		createPicture(set, elem, image);
+
+		setTimeout(function(){
+			lazySizes.loader.unveil(image);
+
+			lazySizes.rAF(function(){
+				lazySizes.fire(image, '_lazyloaded', {}, true, true);
+				if(image.complete) {
+					proxyLoad({target: image});
+				}
+			});
+		});
+
+	});
+
+	document.addEventListener('load', proxyLoad, true);
+
+	window.addEventListener('lazybeforesizes', function(e){
+		if(e.detail.instance != lazySizes){return;}
+		if(e.target._lazybgset && e.detail.dataAttr){
+			var elem = e.target._lazybgset;
+			var bgSize = getBgSize(elem);
+
+			if(allowedBackgroundSize[bgSize]){
+				e.target._lazysizesParentFit = bgSize;
+
+				lazySizes.rAF(function(){
+					e.target.setAttribute('data-parent-fit', bgSize);
+					if(e.target._lazysizesParentFit){
+						delete e.target._lazysizesParentFit;
+					}
+				});
+			}
+		}
+	}, true);
+
+	document.documentElement.addEventListener('lazybeforesizes', function(e){
+		if(e.defaultPrevented || !e.target._lazybgset || e.detail.instance != lazySizes){return;}
+		e.detail.width = proxyWidth(e.target._lazybgset);
+	});
+}));

data/vendor/lazysizes/plugins/blur-up/ls.blur-up.js

@@ -0,0 +1,191 @@
+(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';
+
+	var slice = [].slice;
+	var regBlurUp = /blur-up["']*\s*:\s*["']*(always|auto|unobtrusive)/;
+	var regType = /image\/(jpeg|png|gif|svg\+xml)/;
+	var transSrc = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==';
+
+	var matchesMedia = function (source) {
+		var media = source.getAttribute('data-media') || source.getAttribute('media');
+		var type = source.getAttribute('type');
+
+		return (!type || regType.test(type)) && (!media || window.matchMedia(lazySizes.cfg.customMedia[media] || media).matches);
+	};
+
+	var getLowSrc = function (picture, img) {
+		var sources = picture ? slice.call(picture.querySelectorAll('source, img')) : [img];
+		var element = sources.find(function (src) {
+			return src.getAttribute('data-lowsrc') && matchesMedia(src);
+		});
+
+		return element && element.getAttribute('data-lowsrc');
+	};
+
+	var createBlurup = function(picture, img, src, blurUp){
+		var blurImg;
+		var isBlurUpLoaded = false;
+		var isForced = false;
+		var start = blurUp == 'always' ? 0 : Date.now();
+		var isState = 0;
+		var parent = (picture || img).parentNode;
+
+		var createBlurUpImg = function () {
+
+			if(!src){return;}
+
+			var onloadBlurUp = function(){
+				isBlurUpLoaded = true;
+
+				if(blurImg){
+					lazySizes.rAF(function () {
+						if(blurImg) {
+							lazySizes.aC(blurImg, 'ls-blur-up-loaded');
+						}
+					});
+
+					blurImg.removeEventListener('load', onloadBlurUp);
+					blurImg.removeEventListener('error', onloadBlurUp);
+				}
+			};
+
+			blurImg = document.createElement('img');
+
+			blurImg.addEventListener('load', onloadBlurUp);
+			blurImg.addEventListener('error', onloadBlurUp);
+
+			blurImg.className = 'ls-blur-up-img';
+			blurImg.src = src;
+
+			blurImg.className += ' ls-inview';
+
+			parent.insertBefore(blurImg, (picture || img).nextSibling);
+
+			if(blurUp != 'always'){
+				blurImg.style.visibility = 'hidden';
+
+				setTimeout(function(){
+					lazySizes.rAF(function () {
+						if(!isForced){
+							blurImg.style.visibility = '';
+						}
+					});
+				}, 20);
+			}
+		};
+
+		var remove = function () {
+			if(blurImg){
+				lazySizes.rAF(function() {
+					try {
+						blurImg.parentNode.removeChild(blurImg);
+					} catch(er){}
+					blurImg = null;
+				});
+			}
+		};
+
+		var setStateUp = function(force){
+			isState++;
+
+			isForced = force || isForced;
+
+			if(force){
+				remove();
+			} else if(isState > 1) {
+				setTimeout(remove, 5000);
+			}
+		};
+
+		var onload = function() {
+			img.removeEventListener('load', onload);
+			img.removeEventListener('error', onload);
+
+			if(blurImg){
+				lazySizes.rAF(function(){
+					lazySizes.aC(blurImg, 'ls-original-loaded');
+				});
+			}
+
+			if(!isBlurUpLoaded || Date.now() - start < 66){
+				setStateUp(true);
+			} else {
+				setStateUp();
+			}
+		};
+
+		createBlurUpImg();
+
+		img.addEventListener('load', onload);
+		img.addEventListener('error', onload);
+
+
+		if(blurUp == 'unobtrusive'){
+			setStateUp();
+		} else {
+			var parentUnveil = function (e) {
+				if(parent != e.target){
+					return;
+				}
+
+				lazySizes.aC(blurImg || img, 'ls-inview');
+
+				setStateUp();
+
+				parent.removeEventListener('lazybeforeunveil', parentUnveil);
+			};
+
+			if(!parent.getAttribute('data-expand')){
+				parent.setAttribute('data-expand', -1);
+			}
+
+			parent.addEventListener('lazybeforeunveil', parentUnveil);
+
+			lazySizes.aC(parent, lazySizes.cfg.lazyClass);
+		}
+
+	};
+
+	window.addEventListener('lazybeforeunveil', function (e) {
+		var detail = e.detail;
+
+		if(detail.instance != lazySizes || !detail.blurUp){return;}
+
+		var img = e.target;
+		var picture = img.parentNode;
+
+		if(picture.nodeName != 'PICTURE'){
+			picture = null;
+		}
+
+		createBlurup(picture, img, getLowSrc(picture, img) || transSrc, detail.blurUp);
+	});
+
+	window.addEventListener('lazyunveilread', function (e) {
+		var detail = e.detail;
+
+		if(detail.instance != lazySizes){return;}
+
+		var img = e.target;
+		var match = (getComputedStyle(img, null) || {fontFamily: ''}).fontFamily.match(regBlurUp);
+
+		if(!match && !img.getAttribute('data-lowsrc')){return;}
+
+		detail.blurUp = match && match[1] || 'always';
+	});
+}));

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

@@ -0,0 +1,75 @@
+/*
+ html:after {
+ 	display: none;
+ 	content: '--small: (max-width: 500px) | --medium: (max-width: 1100px) | --large: (min-width: 1100px)';
+ }
+*/
+(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 docElem = document.documentElement;
+
+	lazySizes.getCustomMedias = (function(){
+		var regCleanPseudos = /['"]/g;
+		var regSplit = /\s*\|\s*/g;
+		var regNamedQueries = /^([a-z0-9_-]+)\s*:\s*(.+)$/i;
+
+		var getStyle = function(elem, pseudo){
+			return ((getComputedStyle(elem, pseudo) || {getPropertyValue: function(){}}).getPropertyValue('content') || 'none').replace(regCleanPseudos, '').trim();
+		};
+		var parse = function(string, object){
+			string.split(regSplit).forEach(function(query){
+				var match = query.match(regNamedQueries);
+
+				if(match){
+					object[match[1]] = match[2];
+				}
+			});
+		};
+		return function(object, element){
+			object = object || lazySizes.cfg.customMedia;
+			element = element || document.querySelector('html');
+			parse(getStyle(element, ':before'), object);
+			parse(getStyle(element, ':after'), object);
+			return object;
+		};
+	})();
+
+	lazySizes.updateCustomMedia = function(){
+		var i, len, customMedia;
+		var elems = docElem.querySelectorAll('source[media][data-media][srcset]');
+
+		lazySizes.getCustomMedias();
+
+		for(i = 0, len = elems.length; i < len; i++){
+			if( (customMedia = lazySizes.cfg.customMedia[elems[i].getAttribute('data-media') || elems[i].getAttribute('media')]) ){
+				elems[i].setAttribute('media', customMedia);
+			}
+		}
+
+		elems = docElem.querySelector('source[media][data-media][srcset] ~ img');
+		for(i = 0, len = elems.length; i < len; i++){
+			lazySizes.uP(elems[i]);
+		}
+
+		lazySizes.autoSizer.checkElems();
+	};
+
+	lazySizes.getCustomMedias();
+
+}));

data/vendor/lazysizes/plugins/fix-ios-sizes/fix-ios-sizes.js

@@ -0,0 +1,80 @@
+/**
+ * Some versions of iOS (8.1-) do load the first candidate of a srcset candidate list, if width descriptors with the sizes attribute is used.
+ * This tiny extension prevents this wasted download by creating a picture structure around the image.
+ * Note: This extension is already included in the ls.respimg.js file.
+ *
+ * Usage:
+ *
+ * <img
+ * 	class="lazyload"
+ * 	data-sizes="auto"
+ * 	data-srcset="small.jpg 640px,
+ * 		medium.jpg 980w,
+ * 		large.jpg 1280w"
+ * 	/>
+ */
+
+(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';
+	var regPicture;
+	var img = document.createElement('img');
+
+	if(('srcset' in img) && !('sizes' in img) && !window.HTMLPictureElement){
+		regPicture = /^picture$/i;
+		document.addEventListener('lazybeforeunveil', function(e){
+			if(e.detail.instance != lazySizes){return;}
+
+			var elem, parent, srcset, sizes, isPicture;
+			var picture, source;
+			if(e.defaultPrevented ||
+				lazySizesConfig.noIOSFix ||
+				!(elem = e.target) ||
+				!(srcset = elem.getAttribute(lazySizesConfig.srcsetAttr)) ||
+				!(parent = elem.parentNode) ||
+				(
+					!(isPicture = regPicture.test(parent.nodeName || '')) &&
+					!(sizes = elem.getAttribute('sizes') || elem.getAttribute(lazySizesConfig.sizesAttr))
+				)
+			){return;}
+
+			picture = isPicture ? parent : document.createElement('picture');
+
+			if(!elem._lazyImgSrc){
+				Object.defineProperty(elem, '_lazyImgSrc', {
+					value: document.createElement('source'),
+					writable: true
+				});
+			}
+			source = elem._lazyImgSrc;
+
+			if(sizes){
+				source.setAttribute('sizes', sizes);
+			}
+
+			source.setAttribute(lazySizesConfig.srcsetAttr, srcset);
+			elem.setAttribute('data-pfsrcset', srcset);
+			elem.removeAttribute(lazySizesConfig.srcsetAttr);
+
+			if(!isPicture){
+				parent.insertBefore(picture, elem);
+				picture.appendChild(elem);
+			}
+			picture.insertBefore(source, elem);
+		});
+	}
+}));