ext_yarn 0.4.0 → 0.5.0

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

@@ -0,0 +1,314 @@
+(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'), require('../fix-ios-sizes/fix-ios-sizes'));
+	} else if(window.lazySizes) {
+		globalInstall();
+	} else {
+		window.addEventListener('lazyunveilread', globalInstall, true);
+	}
+}(window, function(window, document, lazySizes) {
+	/*jshint eqnull:true */
+	'use strict';
+	var polyfill;
+	var config = (lazySizes && lazySizes.cfg) || window.lazySizesConfig;
+	var img = document.createElement('img');
+	var supportSrcset = ('sizes' in img) && ('srcset' in img);
+	var regHDesc = /\s+\d+h/g;
+	var fixEdgeHDescriptor = (function(){
+		var regDescriptors = /\s+(\d+)(w|h)\s+(\d+)(w|h)/;
+		var forEach = Array.prototype.forEach;
+
+		return function(){
+			var img = document.createElement('img');
+			var removeHDescriptors = function(source){
+				var ratio, match;
+				var srcset = source.getAttribute(lazySizesConfig.srcsetAttr);
+				if(srcset){
+					if((match = srcset.match(regDescriptors))){
+						if(match[2] == 'w'){
+							ratio = match[1] / match[3];
+						} else {
+							ratio = match[3] / match[1];
+						}
+
+						if(ratio){
+							source.setAttribute('data-aspectratio', ratio);
+						}
+					}
+					source.setAttribute(lazySizesConfig.srcsetAttr, srcset.replace(regHDesc, ''));
+				}
+			};
+			var handler = function(e){
+				var picture = e.target.parentNode;
+
+				if(picture && picture.nodeName == 'PICTURE'){
+					forEach.call(picture.getElementsByTagName('source'), removeHDescriptors);
+				}
+				removeHDescriptors(e.target);
+			};
+
+			var test = function(){
+				if(!!img.currentSrc){
+					document.removeEventListener('lazybeforeunveil', handler);
+				}
+			};
+
+			document.addEventListener('lazybeforeunveil', handler);
+
+			img.onload = test;
+			img.onerror = test;
+
+			img.srcset = 'data:,a 1w 1h';
+
+			if(img.complete){
+				test();
+			}
+		};
+	})();
+
+
+	if(!config){
+		config = {};
+		window.lazySizesConfig = config;
+	}
+
+	if(!config.supportsType){
+		config.supportsType = function(type/*, elem*/){
+			return !type;
+		};
+	}
+
+	if(window.picturefill || config.pf){return;}
+
+	if(window.HTMLPictureElement && supportSrcset){
+
+		if(document.msElementsFromPoint){
+			fixEdgeHDescriptor(navigator.userAgent.match(/Edge\/(\d+)/));
+		}
+
+		config.pf = function(){};
+		return;
+	}
+
+	config.pf = function(options){
+		var i, len;
+		if(window.picturefill){return;}
+		for(i = 0, len = options.elements.length; i < len; i++){
+			polyfill(options.elements[i]);
+		}
+	};
+
+	// partial polyfill
+	polyfill = (function(){
+		var ascendingSort = function( a, b ) {
+			return a.w - b.w;
+		};
+		var regPxLength = /^\s*\d+\.*\d*px\s*$/;
+		var reduceCandidate = function (srces) {
+			var lowerCandidate, bonusFactor;
+			var len = srces.length;
+			var candidate = srces[len -1];
+			var i = 0;
+
+			for(i; i < len;i++){
+				candidate = srces[i];
+				candidate.d = candidate.w / srces.w;
+
+				if(candidate.d >= srces.d){
+					if(!candidate.cached && (lowerCandidate = srces[i - 1]) &&
+						lowerCandidate.d > srces.d - (0.13 * Math.pow(srces.d, 2.2))){
+
+						bonusFactor = Math.pow(lowerCandidate.d - 0.6, 1.6);
+
+						if(lowerCandidate.cached) {
+							lowerCandidate.d += 0.15 * bonusFactor;
+						}
+
+						if(lowerCandidate.d + ((candidate.d - srces.d) * bonusFactor) > srces.d){
+							candidate = lowerCandidate;
+						}
+					}
+					break;
+				}
+			}
+			return candidate;
+		};
+
+		var parseWsrcset = (function(){
+			var candidates;
+			var regWCandidates = /(([^,\s].[^\s]+)\s+(\d+)w)/g;
+			var regMultiple = /\s/;
+			var addCandidate = function(match, candidate, url, wDescriptor){
+				candidates.push({
+					c: candidate,
+					u: url,
+					w: wDescriptor * 1
+				});
+			};
+
+			return function(input){
+				candidates = [];
+				input = input.trim();
+				input
+					.replace(regHDesc, '')
+					.replace(regWCandidates, addCandidate)
+				;
+
+				if(!candidates.length && input && !regMultiple.test(input)){
+					candidates.push({
+						c: input,
+						u: input,
+						w: 99
+					});
+				}
+
+				return candidates;
+			};
+		})();
+
+		var runMatchMedia = function(){
+			if(runMatchMedia.init){return;}
+
+			runMatchMedia.init = true;
+			addEventListener('resize', (function(){
+				var timer;
+				var matchMediaElems = document.getElementsByClassName('lazymatchmedia');
+				var run = function(){
+					var i, len;
+					for(i = 0, len = matchMediaElems.length; i < len; i++){
+						polyfill(matchMediaElems[i]);
+					}
+				};
+
+				return function(){
+					clearTimeout(timer);
+					timer = setTimeout(run, 66);
+				};
+			})());
+		};
+
+		var createSrcset = function(elem, isImage){
+			var parsedSet;
+			var srcSet = elem.getAttribute('srcset') || elem.getAttribute(config.srcsetAttr);
+
+			if(!srcSet && isImage){
+				srcSet = !elem._lazypolyfill ?
+					(elem.getAttribute(config.srcAttr) || elem.getAttribute('src')) :
+					elem._lazypolyfill._set
+				;
+			}
+
+			if(!elem._lazypolyfill || elem._lazypolyfill._set != srcSet){
+
+				parsedSet = parseWsrcset( srcSet || '' );
+				if(isImage && elem.parentNode){
+					parsedSet.isPicture = elem.parentNode.nodeName.toUpperCase() == 'PICTURE';
+
+					if(parsedSet.isPicture){
+						if(window.matchMedia){
+							lazySizes.aC(elem, 'lazymatchmedia');
+							runMatchMedia();
+						}
+					}
+				}
+
+				parsedSet._set = srcSet;
+				Object.defineProperty(elem, '_lazypolyfill', {
+					value: parsedSet,
+					writable: true
+				});
+			}
+		};
+
+		var getX = function(elem){
+			var dpr = window.devicePixelRatio || 1;
+			var optimum = lazySizes.getX && lazySizes.getX(elem);
+			return Math.min(optimum || dpr, 2.5, dpr);
+		};
+
+		var matchesMedia = function(media){
+			if(window.matchMedia){
+				matchesMedia = function(media){
+					return !media || (matchMedia(media) || {}).matches;
+				};
+			} else {
+				return !media;
+			}
+
+			return matchesMedia(media);
+		};
+
+		var getCandidate = function(elem){
+			var sources, i, len, media, source, srces, src, width;
+
+			source = elem;
+			createSrcset(source, true);
+			srces = source._lazypolyfill;
+
+			if(srces.isPicture){
+				for(i = 0, sources = elem.parentNode.getElementsByTagName('source'), len = sources.length; i < len; i++){
+					if( config.supportsType(sources[i].getAttribute('type'), elem) && matchesMedia( sources[i].getAttribute('media')) ){
+						source = sources[i];
+						createSrcset(source);
+						srces = source._lazypolyfill;
+						break;
+					}
+				}
+			}
+
+			if(srces.length > 1){
+				width = source.getAttribute('sizes') || '';
+				width = regPxLength.test(width) && parseInt(width, 10) || lazySizes.gW(elem, elem.parentNode);
+				srces.d = getX(elem);
+				if(!srces.src || !srces.w || srces.w < width){
+					srces.w = width;
+					src = reduceCandidate(srces.sort(ascendingSort));
+					srces.src = src;
+				} else {
+					src = srces.src;
+				}
+			} else {
+				src = srces[0];
+			}
+
+			return src;
+		};
+
+		var p = function(elem){
+			if(supportSrcset && elem.parentNode && elem.parentNode.nodeName.toUpperCase() != 'PICTURE'){return;}
+			var candidate = getCandidate(elem);
+
+			if(candidate && candidate.u && elem._lazypolyfill.cur != candidate.u){
+				elem._lazypolyfill.cur = candidate.u;
+				candidate.cached = true;
+				elem.setAttribute(config.srcAttr, candidate.u);
+				elem.setAttribute('src', candidate.u);
+			}
+		};
+
+		p.parse = parseWsrcset;
+
+		return p;
+	})();
+
+	if(config.loadedClass && config.loadingClass){
+		(function(){
+			var sels = [];
+			['img[sizes$="px"][srcset].', 'picture > img:not([srcset]).'].forEach(function(sel){
+				sels.push(sel + config.loadedClass);
+				sels.push(sel + config.loadingClass);
+			});
+			config.pf({
+				elements: document.querySelectorAll(sels.join(', '))
+			});
+		})();
+
+	}
+}));

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

@@ -0,0 +1,391 @@
+(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, riasCfg;
+	var replaceTypes = {string: 1, number: 1};
+	var regNumber = /^\-*\+*\d+\.*\d*$/;
+	var regPicture = /^picture$/i;
+	var regWidth = /\s*\{\s*width\s*\}\s*/i;
+	var regHeight = /\s*\{\s*height\s*\}\s*/i;
+	var regPlaceholder = /\s*\{\s*([a-z0-9]+)\s*\}\s*/ig;
+	var regObj = /^\[.*\]|\{.*\}$/;
+	var regAllowedSizes = /^(?:auto|\d+(px)?)$/;
+	var anchor = document.createElement('a');
+	var img = document.createElement('img');
+	var buggySizes = ('srcset' in img) && !('sizes' in img);
+	var supportPicture = !!window.HTMLPictureElement && !buggySizes;
+
+	(function(){
+		var prop;
+		var noop = function(){};
+		var riasDefaults = {
+			prefix: '',
+			postfix: '',
+			srcAttr: 'data-src',
+			absUrl: false,
+			modifyOptions: noop,
+			widthmap: {},
+			ratio: false
+		};
+
+		config = (lazySizes && lazySizes.cfg) || window.lazySizesConfig;
+
+		if(!config){
+			config = {};
+			window.lazySizesConfig = config;
+		}
+
+		if(!config.supportsType){
+			config.supportsType = function(type/*, elem*/){
+				return !type;
+			};
+		}
+
+		if(!config.rias){
+			config.rias = {};
+		}
+		riasCfg = config.rias;
+
+		if(!('widths' in riasCfg)){
+			riasCfg.widths = [];
+			(function (widths){
+				var width;
+				var i = 0;
+				while(!width || width < 3000){
+					i += 5;
+					if(i > 30){
+						i += 1;
+					}
+					width = (36 * i);
+					widths.push(width);
+				}
+			})(riasCfg.widths);
+		}
+
+		for(prop in riasDefaults){
+			if(!(prop in riasCfg)){
+				riasCfg[prop] = riasDefaults[prop];
+			}
+		}
+	})();
+
+	function getElementOptions(elem, src){
+		var attr, parent, setOption, options;
+		var elemStyles = window.getComputedStyle(elem);
+
+
+		parent = elem.parentNode;
+		options = {
+			isPicture: !!(parent && regPicture.test(parent.nodeName || ''))
+		};
+
+		setOption = function(attr, run){
+			var attrVal = elem.getAttribute('data-'+ attr);
+
+			if (!attrVal) {
+				// no data- attr, get value from the CSS
+				var styles = elemStyles.getPropertyValue('--ls-' + attr);
+				// at least Safari 9 returns null rather than
+				// an empty string for getPropertyValue causing
+				// .trim() to fail
+				if (styles) {
+					attrVal = styles.trim();
+				}
+			}
+
+			if (attrVal) {
+				if(attrVal == 'true'){
+					attrVal = true;
+				} else if(attrVal == 'false'){
+					attrVal = false;
+				} else if(regNumber.test(attrVal)){
+					attrVal = parseFloat(attrVal);
+				} else if(typeof riasCfg[attr] == 'function'){
+					attrVal = riasCfg[attr](elem, attrVal);
+				} else if(regObj.test(attrVal)){
+					try {
+						attrVal = JSON.parse(attrVal);
+					} catch(e){}
+				}
+				options[attr] = attrVal;
+			} else if((attr in riasCfg) && typeof riasCfg[attr] != 'function'){
+				options[attr] = riasCfg[attr];
+			} else if(run && typeof riasCfg[attr] == 'function'){
+				options[attr] = riasCfg[attr](elem, attrVal);
+			}
+		};
+
+		for(attr in riasCfg){
+			setOption(attr);
+		}
+		src.replace(regPlaceholder, function(full, match){
+			if(!(match in options)){
+				setOption(match, true);
+			}
+		});
+
+		return options;
+	}
+
+	function replaceUrlProps(url, options){
+		var candidates = [];
+		var replaceFn = function(full, match){
+			return (replaceTypes[typeof options[match]]) ? options[match] : full;
+		};
+		candidates.srcset = [];
+
+		if(options.absUrl){
+			anchor.setAttribute('href', url);
+			url = anchor.href;
+		}
+
+		url = ((options.prefix || '') + url + (options.postfix || '')).replace(regPlaceholder, replaceFn);
+
+		options.widths.forEach(function(width){
+			var widthAlias = options.widthmap[width] || width;
+			var candidate = {
+				u: url.replace(regWidth, widthAlias)
+						.replace(regHeight, options.ratio ? Math.round(width * options.ratio) : ''),
+				w: width
+			};
+
+			candidates.push(candidate);
+			candidates.srcset.push( (candidate.c = candidate.u + ' ' + width + 'w') );
+		});
+		return candidates;
+	}
+
+	function setSrc(src, opts, elem){
+		var elemW = 0;
+		var elemH = 0;
+		var sizeElement = elem;
+
+		if(!src){return;}
+
+		if (opts.ratio === 'container') {
+			// calculate image or parent ratio
+			elemW = sizeElement.scrollWidth;
+			elemH = sizeElement.scrollHeight;
+
+			while ((!elemW || !elemH) && sizeElement !== document) {
+				sizeElement = sizeElement.parentNode;
+				elemW = sizeElement.scrollWidth;
+				elemH = sizeElement.scrollHeight;
+			}
+			if (elemW && elemH) {
+				opts.ratio = elemH / elemW;
+			}
+		}
+
+		src = replaceUrlProps(src, opts);
+
+		src.isPicture = opts.isPicture;
+
+		if(buggySizes && elem.nodeName.toUpperCase() == 'IMG'){
+			elem.removeAttribute(config.srcsetAttr);
+		} else {
+			elem.setAttribute(config.srcsetAttr, src.srcset.join(', '));
+		}
+
+		Object.defineProperty(elem, '_lazyrias', {
+			value: src,
+			writable: true
+		});
+	}
+
+	function createAttrObject(elem, src){
+		var opts = getElementOptions(elem, src);
+
+		riasCfg.modifyOptions.call(elem, {target: elem, details: opts, detail: opts});
+
+		lazySizes.fire(elem, 'lazyriasmodifyoptions', opts);
+		return opts;
+	}
+
+	function getSrc(elem){
+		return elem.getAttribute( elem.getAttribute('data-srcattr') || riasCfg.srcAttr ) || elem.getAttribute(config.srcsetAttr) || elem.getAttribute(config.srcAttr) || elem.getAttribute('data-pfsrcset') || '';
+	}
+
+	addEventListener('lazybeforesizes', function(e){
+		if(e.detail.instance != lazySizes){return;}
+
+		var elem, src, elemOpts, parent, sources, i, len, sourceSrc, sizes, detail, hasPlaceholder, modified, emptyList;
+		elem = e.target;
+
+		if(!e.detail.dataAttr || e.defaultPrevented || riasCfg.disabled || !((sizes = elem.getAttribute(config.sizesAttr) || elem.getAttribute('sizes')) && regAllowedSizes.test(sizes))){return;}
+
+		src = getSrc(elem);
+
+		elemOpts = createAttrObject(elem, src);
+
+		hasPlaceholder = regWidth.test(elemOpts.prefix) || regWidth.test(elemOpts.postfix);
+
+		if(elemOpts.isPicture && (parent = elem.parentNode)){
+			sources = parent.getElementsByTagName('source');
+			for(i = 0, len = sources.length; i < len; i++){
+				if ( hasPlaceholder || regWidth.test(sourceSrc = getSrc(sources[i])) ){
+					setSrc(sourceSrc, elemOpts, sources[i]);
+					modified = true;
+				}
+			}
+		}
+
+		if ( hasPlaceholder || regWidth.test(src) ){
+			setSrc(src, elemOpts, elem);
+			modified = true;
+		} else if (modified) {
+			emptyList = [];
+			emptyList.srcset = [];
+			emptyList.isPicture = true;
+			Object.defineProperty(elem, '_lazyrias', {
+				value: emptyList,
+				writable: true
+			});
+		}
+
+		if(modified){
+			if(supportPicture){
+				elem.removeAttribute(config.srcAttr);
+			} else if(sizes != 'auto') {
+				detail = {
+					width: parseInt(sizes, 10)
+				};
+				polyfill({
+					target: elem,
+					detail: detail
+				});
+			}
+		}
+	}, true);
+	// partial polyfill
+	var polyfill = (function(){
+		var ascendingSort = function( a, b ) {
+			return a.w - b.w;
+		};
+
+		var reduceCandidate = function (srces) {
+			var lowerCandidate, bonusFactor;
+			var len = srces.length;
+			var candidate = srces[len -1];
+			var i = 0;
+
+			for(i; i < len;i++){
+				candidate = srces[i];
+				candidate.d = candidate.w / srces.w;
+				if(candidate.d >= srces.d){
+					if(!candidate.cached && (lowerCandidate = srces[i - 1]) &&
+						lowerCandidate.d > srces.d - (0.13 * Math.pow(srces.d, 2.2))){
+
+						bonusFactor = Math.pow(lowerCandidate.d - 0.6, 1.6);
+
+						if(lowerCandidate.cached) {
+							lowerCandidate.d += 0.15 * bonusFactor;
+						}
+
+						if(lowerCandidate.d + ((candidate.d - srces.d) * bonusFactor) > srces.d){
+							candidate = lowerCandidate;
+						}
+					}
+					break;
+				}
+			}
+			return candidate;
+		};
+
+		var getWSet = function(elem, testPicture){
+			var src;
+			if(!elem._lazyrias && lazySizes.pWS && (src = lazySizes.pWS(elem.getAttribute(config.srcsetAttr || ''))).length){
+				Object.defineProperty(elem, '_lazyrias', {
+					value: src,
+					writable: true
+				});
+				if(testPicture && elem.parentNode){
+					src.isPicture = elem.parentNode.nodeName.toUpperCase() == 'PICTURE';
+				}
+			}
+			return elem._lazyrias;
+		};
+
+		var getX = function(elem){
+			var dpr = window.devicePixelRatio || 1;
+			var optimum = lazySizes.getX && lazySizes.getX(elem);
+			return Math.min(optimum || dpr, 2.4, dpr);
+		};
+
+		var getCandidate = function(elem, width){
+			var sources, i, len, media, srces, src;
+
+			srces = elem._lazyrias;
+
+			if(srces.isPicture && window.matchMedia){
+				for(i = 0, sources = elem.parentNode.getElementsByTagName('source'), len = sources.length; i < len; i++){
+					if(getWSet(sources[i]) && !sources[i].getAttribute('type') && ( !(media = sources[i].getAttribute('media')) || ((matchMedia(media) || {}).matches))){
+						srces = sources[i]._lazyrias;
+						break;
+					}
+				}
+			}
+
+			if(!srces.w || srces.w < width){
+				srces.w = width;
+				srces.d = getX(elem);
+				src = reduceCandidate(srces.sort(ascendingSort));
+			}
+
+			return src;
+		};
+
+		var polyfill = function(e){
+			if(e.detail.instance != lazySizes){return;}
+
+			var candidate;
+			var elem = e.target;
+
+			if(!buggySizes && (window.respimage || window.picturefill || lazySizesConfig.pf)){
+				document.removeEventListener('lazybeforesizes', polyfill);
+				return;
+			}
+
+			if(!('_lazyrias' in elem) && (!e.detail.dataAttr || !getWSet(elem, true))){
+				return;
+			}
+
+			candidate = getCandidate(elem, e.detail.width);
+
+			if(candidate && candidate.u && elem._lazyrias.cur != candidate.u){
+				elem._lazyrias.cur = candidate.u;
+				candidate.cached = true;
+				lazySizes.rAF(function(){
+					elem.setAttribute(config.srcAttr, candidate.u);
+					elem.setAttribute('src', candidate.u);
+				});
+			}
+		};
+
+		if(!supportPicture){
+			addEventListener('lazybeforesizes', polyfill);
+		} else {
+			polyfill = function(){};
+		}
+
+		return polyfill;
+
+	})();
+
+}));