ext_yarn 0.4.0 → 0.5.0

data/vendor/lazysizes/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "lazysizes",
+  "version": "4.1.4",
+  "filename": "lazysizes.min.js",
+  "license": "MIT",
+  "author": "Alexander Farkas <info@corrupt-system.de>",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/aFarkas/lazysizes.git"
+  },
+  "namespace": "lazySizes",
+  "main": "lazysizes.js",
+  "browser": "lazysizes.js",
+  "devDependencies": {
+    "grunt": "~0.4.2",
+    "grunt-bytesize": "~0.1.1",
+    "grunt-cli": "~0.1",
+    "grunt-contrib-jshint": "^1.0.0",
+    "grunt-contrib-qunit": "^0.5.2",
+    "grunt-contrib-uglify": "^0.7.0",
+    "grunt-contrib-watch": "~0.4.0",
+    "grunt-max-filesize": "^0.1.0",
+    "grunt-plato": "^1.2.1",
+    "grunt-uncss": "~0.3.7",
+    "jquery": "^2.1.4",
+    "jquery-deparam": "^0.1.0",
+    "picturefill": "^2.2.0",
+    "qunitjs": "^1.17.0",
+    "respimage": "^1.4.2"
+  },
+  "npmName": "lazysizes",
+  "npmFileMap": [
+    {
+      "basePath": "",
+      "files": [
+        "lazysizes.min.js",
+        "plugins/**/*.min.js"
+      ]
+    }
+  ],
+  "description": "High performance (jankfree) lazy loader for images (including responsive images), iframes and scripts (widgets).",
+  "keywords": [
+    "lazy",
+    "loader",
+    "lazyloader",
+    "lazyload",
+    "lazySizes",
+    "performance",
+    "responsive",
+    "image",
+    "images",
+    "responsive images",
+    "picture",
+    "srcset",
+    "respimg",
+    "respimage",
+    "include",
+    "ajax",
+    "img",
+    "imager",
+    "imager.js",
+    "picturefill",
+    "component"
+  ]
+}

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

@@ -0,0 +1,160 @@
+(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 lazySizesConfig = lazySizes.cfg;
+
+	var  ElementPrototype = (window.Element || Node || window.HTMLElement).prototype;
+	var regArtDirect = /artdirect/;
+	var regDescriptors = /\s+(\d+)(w|h)\s+(\d+)(w|h)/;
+	var regArtDirectTags = /artdirect["']*\s*:\s*["']*(.+?)(?=($|'|"|;))/;
+	var regPicture = /^picture$/i;
+	var regSplit = /[\s,]+/g;
+	var slice = [].slice;
+
+	function getCandidatesAspectRatio(element){
+		var match;
+		var ratio = parseFloat(element.getAttribute('data-aspectratio'));
+		var srcset = element.getAttribute(lazySizesConfig.srcsetAttr) || element.getAttribute('srcset');
+
+		if(!ratio && (match = srcset.match(regDescriptors))){
+			if(match[2] == 'w'){
+				ratio = match[1] / match[3];
+			} else {
+				ratio = match[3] / match[1];
+			}
+		}
+
+		return ratio;
+	}
+
+	function getLayoutAspectRatio(element){
+		return element.offsetWidth / element.offsetHeight;
+	}
+
+	function toTagSelector(tag){
+		return 'source[data-tag~="' + tag + '"]';
+	}
+
+	function getArtDirectConfig(img){
+		var picture = img.parentNode;
+		var isPicture = regPicture.test(picture.nodeName || '');
+		var content = (window.getComputedStyle(img) || {}).fontFamily;
+		var config = null;
+
+		if(isPicture && (lazySizesConfig.autoArtDirect || regArtDirect.test(content || ''))){
+			config = {
+				picture: picture,
+				img: img,
+				tags: content.match(regArtDirectTags)
+			};
+
+			if(config.tags){
+				config.selector = config.tags[1].split(regSplit).map(toTagSelector).join(',');
+			}
+		}
+
+		return config;
+	}
+
+	function toSourceObj(source){
+		var media = source.getAttribute('media');
+
+		return {
+			source: source,
+			aspectRatio: getCandidatesAspectRatio(source),
+			isSelected: !media || window.matchMedia(media).matches,
+		};
+	}
+
+	function sortAspectRatio(source1, source2){
+		return source1.aspectRatio < source2.aspectRatio;
+	}
+
+	function getClosestSource(sources, aspecRatio){
+		var i, len;
+		var closest = sources[0];
+
+		for(i = 1, len = sources.length; i < len; i++){
+			if(Math.abs(closest.aspectRatio - aspecRatio) > Math.abs(sources[i].aspectRatio - aspecRatio)){
+				closest = sources[i];
+			}
+		}
+
+		return closest;
+	}
+
+	function setMedia(source, media){
+		source._lsMedia = media;
+		lazySizes.rAF(function(){
+			if(source._lsMedia){
+				delete source._lsMedia;
+			}
+			source.setAttribute('media', media);
+		});
+	}
+
+	function selectSource(imgCfg){
+		var imgAspectRatio = getLayoutAspectRatio(imgCfg.img);
+		var sources = slice.call(imgCfg.picture.getElementsByTagName('source'))
+			.map(toSourceObj)
+			.sort(sortAspectRatio)
+		;
+		var matchedSources = imgCfg.selector ?
+			sources.filter(function(source){
+				return source.source.matches(imgCfg.selector);
+			}) :
+			sources
+		;
+		var closestSource = getClosestSource(matchedSources, imgAspectRatio);
+
+		if(!closestSource.isSelected){
+			setMedia(closestSource.source, '(min-width: 1px)');
+		}
+
+		sources
+			.filter(function(source){
+				return (source != closestSource && source.isSelected);
+			})
+			.forEach(function (source) {
+				setMedia(source.source, '(x)');
+			})
+		;
+	}
+
+	function addAutoArtDirection(e){
+
+		if(e.detail.instance != lazySizes){return;}
+
+		var img = e.target;
+		var imgCfg = getArtDirectConfig(img);
+
+		if(imgCfg){
+			selectSource(imgCfg);
+		}
+	}
+
+	if(!ElementPrototype.matches){
+		ElementPrototype.matches = ElementPrototype.matchesSelector ||
+			ElementPrototype.webkitMatchesSelector ||
+			ElementPrototype.msMatchesSelector ||
+			ElementPrototype.oMatchesSelector;
+	}
+
+	window.addEventListener('lazybeforesizes', addAutoArtDirection, true);
+}));

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

@@ -0,0 +1,209 @@
+(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 forEach = Array.prototype.forEach;
+
+	var imageRatio, extend$, $;
+
+	var regPicture = /^picture$/i;
+	var aspectRatioAttr = 'data-aspectratio';
+	var aspectRatioSel = 'img[' + aspectRatioAttr + ']';
+
+	var matchesMedia = function(media){
+		if(window.matchMedia){
+			matchesMedia = function(media){
+				return !media || (matchMedia(media) || {}).matches;
+			};
+		} else if(window.Modernizr && Modernizr.mq){
+			return !media || Modernizr.mq(media);
+		} else {
+			return !media;
+		}
+		return matchesMedia(media);
+	};
+
+	var addClass = lazySizes.aC;
+	var removeClass = lazySizes.rC;
+	var lazySizesConfig = lazySizes.cfg;
+
+	function AspectRatio(){
+		this.ratioElems = document.getElementsByClassName('lazyaspectratio');
+		this._setupEvents();
+		this.processImages();
+	}
+
+	AspectRatio.prototype = {
+		_setupEvents: function(){
+			var module = this;
+
+			var addRemoveAspectRatio = function(elem){
+				if(elem.naturalWidth < 36){
+					module.addAspectRatio(elem, true);
+				} else {
+					module.removeAspectRatio(elem, true);
+				}
+			};
+			var onload = function(){
+				module.processImages();
+			};
+
+			document.addEventListener('load', function(e){
+				if(e.target.getAttribute && e.target.getAttribute(aspectRatioAttr)){
+					addRemoveAspectRatio(e.target);
+				}
+			}, true);
+
+			addEventListener('resize', (function(){
+				var timer;
+				var resize = function(){
+					forEach.call(module.ratioElems, addRemoveAspectRatio);
+				};
+
+				return function(){
+					clearTimeout(timer);
+					timer = setTimeout(resize, 99);
+				};
+			})());
+
+			document.addEventListener('DOMContentLoaded', onload);
+
+			addEventListener('load', onload);
+		},
+		processImages: function(context){
+			var elements, i;
+
+			if(!context){
+				context = document;
+			}
+
+			if('length' in context && !context.nodeName){
+				elements = context;
+			} else {
+				elements = context.querySelectorAll(aspectRatioSel);
+			}
+
+			for(i = 0; i < elements.length; i++){
+				if(elements[i].naturalWidth > 36){
+					this.removeAspectRatio(elements[i]);
+					continue;
+				}
+				this.addAspectRatio(elements[i]);
+			}
+		},
+		getSelectedRatio: function(img){
+			var i, len, sources, customMedia, ratio;
+			var parent = img.parentNode;
+			if(parent && regPicture.test(parent.nodeName || '')){
+				sources = parent.getElementsByTagName('source');
+
+				for(i = 0, len = sources.length; i < len; i++){
+					customMedia = sources[i].getAttribute('data-media') || sources[i].getAttribute('media');
+
+					if(lazySizesConfig.customMedia[customMedia]){
+						customMedia = lazySizesConfig.customMedia[customMedia];
+					}
+
+					if(matchesMedia(customMedia)){
+						ratio = sources[i].getAttribute(aspectRatioAttr);
+						break;
+					}
+				}
+			}
+
+			return ratio || img.getAttribute(aspectRatioAttr) || '';
+		},
+		parseRatio: (function(){
+			var regRatio = /^\s*([+\d\.]+)(\s*[\/x]\s*([+\d\.]+))?\s*$/;
+			var ratioCache = {};
+			return function(ratio){
+				var match;
+
+				if(!ratioCache[ratio] && (match = ratio.match(regRatio))){
+					if(match[3]){
+						ratioCache[ratio] = match[1] / match[3];
+					} else {
+						ratioCache[ratio] = match[1] * 1;
+					}
+				}
+
+				return ratioCache[ratio];
+			};
+		})(),
+		addAspectRatio: function(img, notNew){
+			var ratio;
+			var width = img.offsetWidth;
+			var height = img.offsetHeight;
+
+			if(!notNew){
+				addClass(img, 'lazyaspectratio');
+			}
+
+			if(width < 36 && height <= 0){
+				if(width || height && window.console){
+					console.log('Define width or height of image, so we can calculate the other dimension');
+				}
+				return;
+			}
+
+			ratio = this.getSelectedRatio(img);
+			ratio = this.parseRatio(ratio);
+
+			if(ratio){
+				if(width){
+					img.style.height = (width / ratio) + 'px';
+				} else {
+					img.style.width = (height * ratio) + 'px';
+				}
+			}
+		},
+		removeAspectRatio: function(img){
+			removeClass(img, 'lazyaspectratio');
+			img.style.height = '';
+			img.style.width = '';
+			img.removeAttribute(aspectRatioAttr);
+		}
+	};
+
+	extend$ = function(){
+		$ = window.jQuery || window.Zepto || window.shoestring || window.$;
+		if($ && $.fn && !$.fn.imageRatio && $.fn.filter && $.fn.add && $.fn.find){
+			$.fn.imageRatio = function(){
+				imageRatio.processImages(this.find(aspectRatioSel).add(this.filter(aspectRatioSel)));
+				return this;
+			};
+		} else {
+			$ = false;
+		}
+	};
+
+	extend$();
+	setTimeout(extend$);
+
+	imageRatio = new AspectRatio();
+
+	window.imageRatio = imageRatio;
+
+	if(typeof module == 'object' && module.exports){
+		module.exports = imageRatio;
+	} else if (typeof define == 'function' && define.amd) {
+		define(imageRatio);
+	}
+
+}));

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

@@ -0,0 +1,129 @@
+(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 rAF = window.requestAnimationFrame || setTimeout;
+
+	var addObserver = function(){
+		var connect, disconnect, observer, connected;
+		var lsCfg = lazySizes.cfg;
+		var attributes = {'data-bgset': 1, 'data-include': 1, 'data-poster': 1, 'data-bg': 1, 'data-script': 1};
+		var regClassTest = '(\\s|^)(' + lsCfg.loadedClass;
+		var docElem = document.documentElement;
+
+		var setClass = function(target){
+			rAF(function(){
+				lazySizes.rC(target, lsCfg.loadedClass);
+				if(lsCfg.unloadedClass){
+					lazySizes.rC(target, lsCfg.unloadedClass);
+				}
+				lazySizes.aC(target, lsCfg.lazyClass);
+
+				if(target.style.display == 'none' || (target.parentNode && target.parentNode.style.display == 'none')){
+					setTimeout(function () {
+						lazySizes.loader.unveil(target);
+					}, 0);
+				}
+			});
+		};
+
+		var onMutation = function(mutations){
+			var i, len, mutation, target;
+			for(i = 0, len = mutations.length; i < len; i++){
+				mutation = mutations[i];
+				target = mutation.target;
+
+				if(!target.getAttribute(mutation.attributeName)){continue;}
+
+				if(target.localName == 'source' && target.parentNode){
+					target = target.parentNode.querySelector('img');
+				}
+
+				if(target && regClassTest.test(target.className)){
+					setClass(target);
+				}
+			}
+		};
+
+		if(lsCfg.unloadedClass){
+			regClassTest += '|' + lsCfg.unloadedClass;
+		}
+
+		regClassTest += '|' + lsCfg.loadingClass + ')(\\s|$)';
+
+		regClassTest = new RegExp(regClassTest);
+
+		attributes[lsCfg.srcAttr] = 1;
+		attributes[lsCfg.srcsetAttr] = 1;
+
+		if(window.MutationObserver){
+			observer = new MutationObserver(onMutation);
+
+			connect = function(){
+				if(!connected){
+					connected = true;
+					observer.observe( docElem, { subtree: true, attributes: true, attributeFilter: Object.keys(attributes)} );
+				}
+			};
+			disconnect = function(){
+				if(connected){
+					connected = false;
+					observer.disconnect();
+				}
+			};
+		} else {
+			docElem.addEventListener('DOMAttrModified', (function(){
+				var runs;
+				var modifications = [];
+				var callMutations = function(){
+					onMutation(modifications);
+					modifications = [];
+					runs = false;
+				};
+				return function(e){
+					if(connected && attributes[e.attrName] && e.newValue){
+						modifications.push({target: e.target, attributeName: e.attrName});
+						if(!runs){
+							setTimeout(callMutations);
+							runs = true;
+						}
+					}
+				};
+			})(), true);
+
+			connect = function(){
+				connected = true;
+			};
+			disconnect = function(){
+				connected = false;
+			};
+		}
+
+		addEventListener('lazybeforeunveil', disconnect, true);
+		addEventListener('lazybeforeunveil', connect);
+
+		addEventListener('lazybeforesizes', disconnect, true);
+		addEventListener('lazybeforesizes', connect);
+		connect();
+
+		removeEventListener('lazybeforeunveil', addObserver);
+	};
+
+
+	addEventListener('lazybeforeunveil', addObserver);
+}));