https://www.primariacovasna.ro/fileadmin/templates/js/holder.js?1456604474

1/*!
2
3Holder - client side image placeholders
4Version 2.9.2+30qun
5© 2016 Ivan Malopinsky - http://imsky.co
6
7Site:     http://holderjs.com
8Issues:   https://github.com/imsky/holder/issues
9License:  MIT
10
11*/
12(function (window) {
13  if (!window.document) return;
14  var document = window.document;
15
16  //https://github.com/inexorabletash/polyfill/blob/master/web.js
17    if (!document.querySelectorAll) {
18      document.querySelectorAll = function (selectors) {
19        var style = document.createElement('style'), elements = [], element;
20        document.documentElement.firstChild.appendChild(style);
21        document._qsa = [];
22
23        style.styleSheet.cssText = selectors + '{x-qsa:expression(document._qsa && document._qsa.push(this))}';
24        window.scrollBy(0, 0);
25        style.parentNode.removeChild(style);
26
27        while (document._qsa.length) {
28          element = document._qsa.shift();
29          element.style.removeAttribute('x-qsa');
30          elements.push(element);
31        }
32        document._qsa = null;
33        return elements;
34      };
35    }
36
37    if (!document.querySelector) {
38      document.querySelector = function (selectors) {
39        var elements = document.querySelectorAll(selectors);
40        return (elements.length) ? elements[0] : null;
41      };
42    }
43
44    if (!document.getElementsByClassName) {
45      document.getElementsByClassName = function (classNames) {
46        classNames = String(classNames).replace(/^|\s+/g, '.');
47        return document.querySelectorAll(classNames);
48      };
49    }
50
51  //https://github.com/inexorabletash/polyfill
52  // ES5 15.2.3.14 Object.keys ( O )
53  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys
54  if (!Object.keys) {
55    Object.keys = function (o) {
56      if (o !== Object(o)) { throw TypeError('Object.keys called on non-object'); }
57      var ret = [], p;
58      for (p in o) {
59        if (Object.prototype.hasOwnProperty.call(o, p)) {
60          ret.push(p);
61        }
62      }
63      return ret;
64    };
65  }
66
67  // ES5 15.4.4.18 Array.prototype.forEach ( callbackfn [ , thisArg ] )
68  // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
69  if (!Array.prototype.forEach) {
70    Array.prototype.forEach = function (fun /*, thisp */) {
71      if (this === void 0 || this === null) { throw TypeError(); }
72
73      var t = Object(this);
74      var len = t.length >>> 0;
75      if (typeof fun !== "function") { throw TypeError(); }
76
77      var thisp = arguments[1], i;
78      for (i = 0; i < len; i++) {
79        if (i in t) {
80          fun.call(thisp, t[i], i, t);
81        }
82      }
83    };
84  }
85
86  //https://github.com/inexorabletash/polyfill/blob/master/web.js
87  (function (global) {
88    var B64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
89    global.atob = global.atob || function (input) {
90      input = String(input);
91      var position = 0,
92          output = [],
93          buffer = 0, bits = 0, n;
94
95      input = input.replace(/\s/g, '');
96      if ((input.length % 4) === 0) { input = input.replace(/=+$/, ''); }
97      if ((input.length % 4) === 1) { throw Error('InvalidCharacterError'); }
98      if (/[^+/0-9A-Za-z]/.test(input)) { throw Error('InvalidCharacterError'); }
99
100      while (position < input.length) {
101        n = B64_ALPHABET.indexOf(input.charAt(position));
102        buffer = (buffer << 6) | n;
103        bits += 6;
104
105        if (bits === 24) {
106          output.push(String.fromCharCode((buffer >> 16) & 0xFF));
107          output.push(String.fromCharCode((buffer >>  8) & 0xFF));
108          output.push(String.fromCharCode(buffer & 0xFF));
109          bits = 0;
110          buffer = 0;
111        }
112        position += 1;
113      }
114
115      if (bits === 12) {
116        buffer = buffer >> 4;
117        output.push(String.fromCharCode(buffer & 0xFF));
118      } else if (bits === 18) {
119        buffer = buffer >> 2;
120        output.push(String.fromCharCode((buffer >> 8) & 0xFF));
121        output.push(String.fromCharCode(buffer & 0xFF));
122      }
123
124      return output.join('');
125    };
126
127    global.btoa = global.btoa || function (input) {
128      input = String(input);
129      var position = 0,
130          out = [],
131          o1, o2, o3,
132          e1, e2, e3, e4;
133
134      if (/[^\x00-\xFF]/.test(input)) { throw Error('InvalidCharacterError'); }
135
136      while (position < input.length) {
137        o1 = input.charCodeAt(position++);
138        o2 = input.charCodeAt(position++);
139        o3 = input.charCodeAt(position++);
140
141        // 111111 112222 222233 333333
142        e1 = o1 >> 2;
143        e2 = ((o1 & 0x3) << 4) | (o2 >> 4);
144        e3 = ((o2 & 0xf) << 2) | (o3 >> 6);
145        e4 = o3 & 0x3f;
146
147        if (position === input.length + 2) {
148          e3 = 64; e4 = 64;
149        }
150        else if (position === input.length + 1) {
151          e4 = 64;
152        }
153
154        out.push(B64_ALPHABET.charAt(e1),
155                 B64_ALPHABET.charAt(e2),
156                 B64_ALPHABET.charAt(e3),
157                 B64_ALPHABET.charAt(e4));
158      }
159
160      return out.join('');
161    };
162  }(window));
163
164  //https://gist.github.com/jimeh/332357
165  if (!Object.prototype.hasOwnProperty){
166      /*jshint -W001, -W103 */
167      Object.prototype.hasOwnProperty = function(prop) {
168      var proto = this.__proto__ || this.constructor.prototype;
169      return (prop in this) && (!(prop in proto) || proto[prop] !== this[prop]);
170    };
171      /*jshint +W001, +W103 */
172  }
173
174  // @license http://opensource.org/licenses/MIT
175  // copyright Paul Irish 2015
176
177
178  // Date.now() is supported everywhere except IE8. For IE8 we use the Date.now polyfill
179  //   github.com/Financial-Times/polyfill-service/blob/master/polyfills/Date.now/polyfill.js
180  // as Safari 6 doesn't have support for NavigationTiming, we use a Date.now() timestamp for relative values
181
182  // if you want values similar to what you'd get with real perf.now, place this towards the head of the page
183  // but in reality, you're just getting the delta between now() calls, so it's not terribly important where it's placed
184
185
186  (function(){
187
188    if ('performance' in window === false) {
189        window.performance = {};
190    }
191    
192    Date.now = (Date.now || function () {  // thanks IE8
193      return new Date().getTime();
194    });
195
196    if ('now' in window.performance === false){
197      
198      var nowOffset = Date.now();
199      
200      if (performance.timing && performance.timing.navigationStart){
201        nowOffset = performance.timing.navigationStart;
202      }
203
204      window.performance.now = function now(){
205        return Date.now() - nowOffset;
206      };
207    }
208
209  })();
210
211  //requestAnimationFrame polyfill for older Firefox/Chrome versions
212  if (!window.requestAnimationFrame) {
213    if (window.webkitRequestAnimationFrame && window.webkitCancelAnimationFrame) {
214    //https://github.com/Financial-Times/polyfill-service/blob/master/polyfills/requestAnimationFrame/polyfill-webkit.js
215    (function (global) {
216      global.requestAnimationFrame = function (callback) {
217        return webkitRequestAnimationFrame(function () {
218          callback(global.performance.now());
219        });
220      };
221
222      global.cancelAnimationFrame = global.webkitCancelAnimationFrame;
223    }(window));
224    } else if (window.mozRequestAnimationFrame && window.mozCancelAnimationFrame) {
225      //https://github.com/Financial-Times/polyfill-service/blob/master/polyfills/requestAnimationFrame/polyfill-moz.js
226    (function (global) {
227      global.requestAnimationFrame = function (callback) {
228        return mozRequestAnimationFrame(function () {
229          callback(global.performance.now());
230        });
231      };
232
233      global.cancelAnimationFrame = global.mozCancelAnimationFrame;
234    }(window));
235    } else {
236    (function (global) {
237      global.requestAnimationFrame = function (callback) {
238        return global.setTimeout(callback, 1000 / 60);
239      };
240
241      global.cancelAnimationFrame = global.clearTimeout;
242    })(window);
243    }
244  }
245})(this);
246
247(function webpackUniversalModuleDefinition(root, factory) {
248	if(typeof exports === 'object' && typeof module === 'object')
249		module.exports = factory();
250	else if(typeof define === 'function' && define.amd)
251		define([], factory);
252	else if(typeof exports === 'object')
253		exports["Holder"] = factory();
254	else
255		root["Holder"] = factory();
256})(this, function() {
257return /******/ (function(modules) { // webpackBootstrap
258/******/ 	// The module cache
259/******/ 	var installedModules = {};
260
261/******/ 	// The require function
262/******/ 	function __webpack_require__(moduleId) {
263
264/******/ 		// Check if module is in cache
265/******/ 		if(installedModules[moduleId])
266/******/ 			return installedModules[moduleId].exports;
267
268/******/ 		// Create a new module (and put it into the cache)
269/******/ 		var module = installedModules[moduleId] = {
270/******/ 			exports: {},
271/******/ 			id: moduleId,
272/******/ 			loaded: false
273/******/ 		};
274
275/******/ 		// Execute the module function
276/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
277
278/******/ 		// Flag the module as loaded
279/******/ 		module.loaded = true;
280
281/******/ 		// Return the exports of the module
282/******/ 		return module.exports;
283/******/ 	}
284
285
286/******/ 	// expose the modules object (__webpack_modules__)
287/******/ 	__webpack_require__.m = modules;
288
289/******/ 	// expose the module cache
290/******/ 	__webpack_require__.c = installedModules;
291
292/******/ 	// __webpack_public_path__
293/******/ 	__webpack_require__.p = "";
294
295/******/ 	// Load entry module and return exports
296/******/ 	return __webpack_require__(0);
297/******/ })
298/************************************************************************/
299/******/ ([
300/* 0 */
301/***/ function(module, exports, __webpack_require__) {
302
303	/*
304	Holder.js - client side image placeholders
305	(c) 2012-2015 Ivan Malopinsky - http://imsky.co
306	*/
307
308	module.exports = __webpack_require__(1);
309
310
311/***/ },
312/* 1 */
313/***/ function(module, exports, __webpack_require__) {
314
315	/* WEBPACK VAR INJECTION */(function(global) {/*
316	Holder.js - client side image placeholders
317	(c) 2012-2015 Ivan Malopinsky - http://imsky.co
318	*/
319
320	//Libraries and functions
321	var onDomReady = __webpack_require__(2);
322	var querystring = __webpack_require__(3);
323
324	var SceneGraph = __webpack_require__(10);
325	var utils = __webpack_require__(11);
326	var SVG = __webpack_require__(12);
327	var DOM = __webpack_require__(13);
328	var Color = __webpack_require__(14);
329	var constants = __webpack_require__(15);
330
331	var svgRenderer = __webpack_require__(16);
332	var sgCanvasRenderer = __webpack_require__(19);
333
334	var extend = utils.extend;
335	var dimensionCheck = utils.dimensionCheck;
336
337	//Constants and definitions
338	var SVG_NS = constants.svg_ns;
339
340	var Holder = {
341	    version: constants.version,
342
343	    /**
344	     * Adds a theme to default settings
345	     *
346	     * @param {string} name Theme name
347	     * @param {Object} theme Theme object, with foreground, background, size, font, and fontweight properties.
348	     */
349	    addTheme: function(name, theme) {
350	        name != null && theme != null && (App.settings.themes[name] = theme);
351	        delete App.vars.cache.themeKeys;
352	        return this;
353	    },
354
355	    /**
356	     * Appends a placeholder to an element
357	     *
358	     * @param {string} src Placeholder URL string
359	     * @param el A selector or a reference to a DOM node
360	     */
361	    addImage: function(src, el) {
362	        //todo: use jquery fallback if available for all QSA references
363	        var nodes = DOM.getNodeArray(el);
364	        nodes.forEach(function (node) {
365	            var img = DOM.newEl('img');
366	            var domProps = {};
367	            domProps[App.setup.dataAttr] = src;
368	            DOM.setAttr(img, domProps);
369	            node.appendChild(img);
370	        });
371	        return this;
372	    },
373
374	    /**
375	     * Sets whether or not an image is updated on resize.
376	     * If an image is set to be updated, it is immediately rendered.
377	     *
378	     * @param {Object} el Image DOM element
379	     * @param {Boolean} value Resizable update flag value
380	     */
381	    setResizeUpdate: function(el, value) {
382	        if (el.holderData) {
383	            el.holderData.resizeUpdate = !!value;
384	            if (el.holderData.resizeUpdate) {
385	                updateResizableElements(el);
386	            }
387	        }
388	    },
389
390	    /**
391	     * Runs Holder with options. By default runs Holder on all images with "holder.js" in their source attributes.
392	     *
393	     * @param {Object} userOptions Options object, can contain domain, themes, images, and bgnodes properties
394	     */
395	    run: function(userOptions) {
396	        //todo: split processing into separate queues
397	        userOptions = userOptions || {};
398	        var engineSettings = {};
399	        var options = extend(App.settings, userOptions);
400
401	        App.vars.preempted = true;
402	        App.vars.dataAttr = options.dataAttr || App.setup.dataAttr;
403
404	        engineSettings.renderer = options.renderer ? options.renderer : App.setup.renderer;
405	        if (App.setup.renderers.join(',').indexOf(engineSettings.renderer) === -1) {
406	            engineSettings.renderer = App.setup.supportsSVG ? 'svg' : (App.setup.supportsCanvas ? 'canvas' : 'html');
407	        }
408
409	        var images = DOM.getNodeArray(options.images);
410	        var bgnodes = DOM.getNodeArray(options.bgnodes);
411	        var stylenodes = DOM.getNodeArray(options.stylenodes);
412	        var objects = DOM.getNodeArray(options.objects);
413
414	        engineSettings.stylesheets = [];
415	        engineSettings.svgXMLStylesheet = true;
416	        engineSettings.noFontFallback = options.noFontFallback ? options.noFontFallback : false;
417
418	        stylenodes.forEach(function (styleNode) {
419	            if (styleNode.attributes.rel && styleNode.attributes.href && styleNode.attributes.rel.value == 'stylesheet') {
420	                var href = styleNode.attributes.href.value;
421	                //todo: write isomorphic relative-to-absolute URL function
422	                var proxyLink = DOM.newEl('a');
423	                proxyLink.href = href;
424	                var stylesheetURL = proxyLink.protocol + '//' + proxyLink.host + proxyLink.pathname + proxyLink.search;
425	                engineSettings.stylesheets.push(stylesheetURL);
426	            }
427	        });
428
429	        bgnodes.forEach(function (bgNode) {
430	            //Skip processing background nodes if getComputedStyle is unavailable, since only modern browsers would be able to use canvas or SVG to render to background
431	            if (!global.getComputedStyle) return;
432	            var backgroundImage = global.getComputedStyle(bgNode, null).getPropertyValue('background-image');
433	            var dataBackgroundImage = bgNode.getAttribute('data-background-src');
434	            var rawURL = dataBackgroundImage || backgroundImage;
435
436	            var holderURL = null;
437	            var holderString = options.domain + '/';
438	            var holderStringIndex = rawURL.indexOf(holderString);
439
440	            if (holderStringIndex === 0) {
441	                holderURL = rawURL;
442	            } else if (holderStringIndex === 1 && rawURL[0] === '?') {
443	                holderURL = rawURL.slice(1);
444	            } else {
445	                var fragment = rawURL.substr(holderStringIndex).match(/([^\"]*)"?\)/);
446	                if (fragment !== null) {
447	                    holderURL = fragment[1];
448	                } else if (rawURL.indexOf('url(') === 0) {
449	                    throw 'Holder: unable to parse background URL: ' + rawURL;
450	                }
451	            }
452
453	            if (holderURL != null) {
454	                var holderFlags = parseURL(holderURL, options);
455	                if (holderFlags) {
456	                    prepareDOMElement({
457	                        mode: 'background',
458	                        el: bgNode,
459	                        flags: holderFlags,
460	                        engineSettings: engineSettings
461	                    });
462	                }
463	            }
464	        });
465
466	        objects.forEach(function (object) {
467	            var objectAttr = {};
468
469	            try {
470	                objectAttr.data = object.getAttribute('data');
471	                objectAttr.dataSrc = object.getAttribute(App.vars.dataAttr);
472	            } catch (e) {}
473
474	            var objectHasSrcURL = objectAttr.data != null && objectAttr.data.indexOf(options.domain) === 0;
475	            var objectHasDataSrcURL = objectAttr.dataSrc != null && objectAttr.dataSrc.indexOf(options.domain) === 0;
476
477	            if (objectHasSrcURL) {
478	                prepareImageElement(options, engineSettings, objectAttr.data, object);
479	            } else if (objectHasDataSrcURL) {
480	                prepareImageElement(options, engineSettings, objectAttr.dataSrc, object);
481	            }
482	        });
483
484	        images.forEach(function (image) {
485	            var imageAttr = {};
486
487	            try {
488	                imageAttr.src = image.getAttribute('src');
489	                imageAttr.dataSrc = image.getAttribute(App.vars.dataAttr);
490	                imageAttr.rendered = image.getAttribute('data-holder-rendered');
491	            } catch (e) {}
492
493	            var imageHasSrc = imageAttr.src != null;
494	            var imageHasDataSrcURL = imageAttr.dataSrc != null && imageAttr.dataSrc.indexOf(options.domain) === 0;
495	            var imageRendered = imageAttr.rendered != null && imageAttr.rendered == 'true';
496
497	            if (imageHasSrc) {
498	                if (imageAttr.src.indexOf(options.domain) === 0) {
499	                    prepareImageElement(options, engineSettings, imageAttr.src, image);
500	                } else if (imageHasDataSrcURL) {
501	                    //Image has a valid data-src and an invalid src
502	                    if (imageRendered) {
503	                        //If the placeholder has already been render, re-render it
504	                        prepareImageElement(options, engineSettings, imageAttr.dataSrc, image);
505	                    } else {
506	                        //If the placeholder has not been rendered, check if the image exists and render a fallback if it doesn't
507	                        (function(src, options, engineSettings, dataSrc, image) {
508	                            utils.imageExists(src, function(exists) {
509	                                if (!exists) {
510	                                    prepareImageElement(options, engineSettings, dataSrc, image);
511	                                }
512	                            });
513	                        })(imageAttr.src, options, engineSettings, imageAttr.dataSrc, image);
514	                    }
515	                }
516	            } else if (imageHasDataSrcURL) {
517	                prepareImageElement(options, engineSettings, imageAttr.dataSrc, image);
518	            }
519	        });
520
521	        return this;
522	    }
523	};
524
525	var App = {
526	    settings: {
527	        domain: 'holder.js',
528	        images: 'img',
529	        objects: 'object',
530	        bgnodes: 'body .holderjs',
531	        stylenodes: 'head link.holderjs',
532	        themes: {
533	            'gray': {
534	                bg: '#EEEEEE',
535	                fg: '#AAAAAA'
536	            },
537	            'social': {
538	                bg: '#3a5a97',
539	                fg: '#FFFFFF'
540	            },
541	            'industrial': {
542	                bg: '#434A52',
543	                fg: '#C2F200'
544	            },
545	            'sky': {
546	                bg: '#0D8FDB',
547	                fg: '#FFFFFF'
548	            },
549	            'vine': {
550	                bg: '#39DBAC',
551	                fg: '#1E292C'
552	            },
553	            'lava': {
554	                bg: '#F8591A',
555	                fg: '#1C2846'
556	            }
557	        }
558	    },
559	    defaults: {
560	        size: 10,
561	        units: 'pt',
562	        scale: 1 / 16
563	    }
564	};
565
566	/**
567	 * Processes provided source attribute and sets up the appropriate rendering workflow
568	 *
569	 * @private
570	 * @param options Instance options from Holder.run
571	 * @param renderSettings Instance configuration
572	 * @param src Image URL
573	 * @param el Image DOM element
574	 */
575	function prepareImageElement(options, engineSettings, src, el) {
576	    var holderFlags = parseURL(src.substr(src.lastIndexOf(options.domain)), options);
577	    if (holderFlags) {
578	        prepareDOMElement({
579	            mode: null,
580	            el: el,
581	            flags: holderFlags,
582	            engineSettings: engineSettings
583	        });
584	    }
585	}
586
587	/**
588	 * Processes a Holder URL and extracts configuration from query string
589	 *
590	 * @private
591	 * @param url URL
592	 * @param instanceOptions Instance options from Holder.run
593	 */
594	function parseURL(url, instanceOptions) {
595	    var holder = {
596	        theme: extend(App.settings.themes.gray, null),
597	        stylesheets: instanceOptions.stylesheets,
598	        instanceOptions: instanceOptions
599	    };
600
601	    var firstQuestionMark = url.indexOf('?');
602	    var parts = [url];
603
604	    if (firstQuestionMark !== -1) {
605	        parts = [url.slice(0, firstQuestionMark), url.slice(firstQuestionMark + 1)];
606	    }
607
608	    var basics = parts[0].split('/');
609
610	    holder.holderURL = url;
611
612	    var dimensions = basics[1];
613	    var dimensionData = dimensions.match(/([\d]+p?)x([\d]+p?)/);
614
615	    if (!dimensionData) return false;
616
617	    holder.fluid = dimensions.indexOf('p') !== -1;
618
619	    holder.dimensions = {
620	        width: dimensionData[1].replace('p', '%'),
621	        height: dimensionData[2].replace('p', '%')
622	    };
623
624	    if (parts.length === 2) {
625	        var options = querystring.parse(parts[1]);
626
627	        // Colors
628
629	        if (options.bg) {
630	            holder.theme.bg = utils.parseColor(options.bg);
631	        }
632
633	        if (options.fg) {
634	            holder.theme.fg = utils.parseColor(options.fg);
635	        }
636
637	        //todo: add automatic foreground to themes without foreground
638	        if (options.bg && !options.fg) {
639	            holder.autoFg = true;
640	        }
641
642	        if (options.theme && holder.instanceOptions.themes.hasOwnProperty(options.theme)) {
643	            holder.theme = extend(holder.instanceOptions.themes[options.theme], null);
644	        }
645
646	        // Text
647
648	        if (options.text) {
649	            holder.text = options.text;
650	        }
651
652	        if (options.textmode) {
653	            holder.textmode = options.textmode;
654	        }
655
656	        if (options.size) {
657	            holder.size = options.size;
658	        }
659
660	        if (options.font) {
661	            holder.font = options.font;
662	        }
663
664	        if (options.align) {
665	            holder.align = options.align;
666	        }
667
668	        if (options.lineWrap) {
669	            holder.lineWrap = options.lineWrap;
670	        }
671
672	        holder.nowrap = utils.truthy(options.nowrap);
673
674	        // Miscellaneous
675
676	        holder.auto = utils.truthy(options.auto);
677
678	        holder.outline = utils.truthy(options.outline);
679
680	        if (utils.truthy(options.random)) {
681	            App.vars.cache.themeKeys = App.vars.cache.themeKeys || Object.keys(holder.instanceOptions.themes);
682	            var _theme = App.vars.cache.themeKeys[0 | Math.random() * App.vars.cache.themeKeys.length];
683	            holder.theme = extend(holder.instanceOptions.themes[_theme], null);
684	        }
685	    }
686
687	    return holder;
688	}
689
690	/**
691	 * Modifies the DOM to fit placeholders and sets up resizable image callbacks (for fluid and automatically sized placeholders)
692	 *
693	 * @private
694	 * @param settings DOM prep settings
695	 */
696	function prepareDOMElement(prepSettings) {
697	    var mode = prepSettings.mode;
698	    var el = prepSettings.el;
699	    var flags = prepSettings.flags;
700	    var _engineSettings = prepSettings.engineSettings;
701	    var dimensions = flags.dimensions,
702	        theme = flags.theme;
703	    var dimensionsCaption = dimensions.width + 'x' + dimensions.height;
704	    mode = mode == null ? (flags.fluid ? 'fluid' : 'image') : mode;
705	    var holderTemplateRe = /holder_([a-z]+)/g;
706	    var dimensionsInText = false;
707
708	    if (flags.text != null) {
709	        theme.text = flags.text;
710
711	        //<object> SVG embedding doesn't parse Unicode properly
712	        if (el.nodeName.toLowerCase() === 'object') {
713	            var textLines = theme.text.split('\\n');
714	            for (var k = 0; k < textLines.length; k++) {
715	                textLines[k] = utils.encodeHtmlEntity(textLines[k]);
716	            }
717	            theme.text = textLines.join('\\n');
718	        }
719	    }
720
721	    if (theme.text) {
722	        var holderTemplateMatches = theme.text.match(holderTemplateRe);
723
724	        if (holderTemplateMatches !== null) {
725	            //todo: optimize template replacement
726	            holderTemplateMatches.forEach(function (match) {
727	                if (match === 'holder_dimensions') {
728	                    theme.text = theme.text.replace(match, dimensionsCaption);
729	                }
730	            });
731	        }
732	    }
733
734	    var holderURL = flags.holderURL;
735	    var engineSettings = extend(_engineSettings, null);
736
737	    if (flags.font) {
738	        /*
739	        If external fonts are used in a <img> placeholder rendered with SVG, Holder falls back to canvas.
740
741	        This is done because Firefox and Chrome disallow embedded SVGs from referencing external assets.
742	        The workaround is either to change the placeholder tag from <img> to <object> or to use the canvas renderer.
743	        */
744	        theme.font = flags.font;
745	        if (!engineSettings.noFontFallback && el.nodeName.toLowerCase() === 'img' && App.setup.supportsCanvas && engineSettings.renderer === 'svg') {
746	            engineSettings = extend(engineSettings, {
747	                renderer: 'canvas'
748	            });
749	        }
750	    }
751
752	    //Chrome and Opera require a quick 10ms re-render if web fonts are used with canvas
753	    if (flags.font && engineSettings.renderer == 'canvas') {
754	        engineSettings.reRender = true;
755	    }
756
757	    if (mode == 'background') {
758	        if (el.getAttribute('data-background-src') == null) {
759	            DOM.setAttr(el, {
760	                'data-background-src': holderURL
761	            });
762	        }
763	    } else {
764	        var domProps = {};
765	        domProps[App.vars.dataAttr] = holderURL;
766	        DOM.setAttr(el, domProps);
767	    }
768
769	    flags.theme = theme;
770
771	    //todo consider using all renderSettings in holderData
772	    el.holderData = {
773	        flags: flags,
774	        engineSettings: engineSettings
775	    };
776
777	    if (mode == 'image' || mode == 'fluid') {
778	        DOM.setAttr(el, {
779	            'alt': theme.text ? (dimensionsInText ? theme.text : theme.text + ' [' + dimensionsCaption + ']') : dimensionsCaption
780	        });
781	    }
782
783	    var renderSettings = {
784	        mode: mode,
785	        el: el,
786	        holderSettings: {
787	            dimensions: dimensions,
788	            theme: theme,
789	            flags: flags
790	        },
791	        engineSettings: engineSettings
792	    };
793
794	    if (mode == 'image') {
795	        if (!flags.auto) {
796	            el.style.width = dimensions.width + 'px';
797	            el.style.height = dimensions.height + 'px';
798	        }
799
800	        if (engineSettings.renderer == 'html') {
801	            el.style.backgroundColor = theme.bg;
802	        } else {
803	            render(renderSettings);
804
805	            if (flags.textmode == 'exact') {
806	                el.holderData.resizeUpdate = true;
807	                App.vars.resizableImages.push(el);
808	                updateResizableElements(el);
809	            }
810	        }
811	    } else if (mode == 'background' && engineSettings.renderer != 'html') {
812	        render(renderSettings);
813	    } else if (mode == 'fluid') {
814	        el.holderData.resizeUpdate = true;
815
816	        if (dimensions.height.slice(-1) == '%') {
817	            el.style.height = dimensions.height;
818	        } else if (flags.auto == null || !flags.auto) {
819	            el.style.height = dimensions.height + 'px';
820	        }
821	        if (dimensions.width.slice(-1) == '%') {
822	            el.style.width = dimensions.width;
823	        } else if (flags.auto == null || !flags.auto) {
824	            el.style.width = dimensions.width + 'px';
825	        }
826	        if (el.style.display == 'inline' || el.style.display === '' || el.style.display == 'none') {
827	            el.style.display = 'block';
828	        }
829
830	        setInitialDimensions(el);
831
832	        if (engineSettings.renderer == 'html') {
833	            el.style.backgroundColor = theme.bg;
834	        } else {
835	            App.vars.resizableImages.push(el);
836	            updateResizableElements(el);
837	        }
838	    }
839	}
840
841	/**
842	 * Core function that takes output from renderers and sets it as the source or background-image of the target element
843	 *
844	 * @private
845	 * @param renderSettings Renderer settings
846	 */
847	function render(renderSettings) {
848	    var image = null;
849	    var mode = renderSettings.mode;
850	    var el = renderSettings.el;
851	    var holderSettings = renderSettings.holderSettings;
852	    var engineSettings = renderSettings.engineSettings;
853
854	    switch (engineSettings.renderer) {
855	        case 'svg':
856	            if (!App.setup.supportsSVG) return;
857	            break;
858	        case 'canvas':
859	            if (!App.setup.supportsCanvas) return;
860	            break;
861	        default:
862	            return;
863	    }
864
865	    //todo: move generation of scene up to flag generation to reduce extra object creation
866	    var scene = {
867	        width: holderSettings.dimensions.width,
868	        height: holderSettings.dimensions.height,
869	        theme: holderSettings.theme,
870	        flags: holderSettings.flags
871	    };
872
873	    var sceneGraph = buildSceneGraph(scene);
874
875	    function getRenderedImage() {
876	        var image = null;
877	        switch (engineSettings.renderer) {
878	            case 'canvas':
879	                image = sgCanvasRenderer(sceneGraph, renderSettings);
880	                break;
881	            case 'svg':
882	                image = svgRenderer(sceneGraph, renderSettings);
883	                break;
884	            default:
885	                throw 'Holder: invalid renderer: ' + engineSettings.renderer;
886	        }
887
888	        return image;
889	    }
890
891	    image = getRenderedImage();
892
893	    if (image == null) {
894	        throw 'Holder: couldn\'t render placeholder';
895	    }
896
897	    //todo: add <object> canvas rendering
898	    if (mode == 'background') {
899	        el.style.backgroundImage = 'url(' + image + ')';
900	        el.style.backgroundSize = scene.width + 'px ' + scene.height + 'px';
901	    } else {
902	        if (el.nodeName.toLowerCase() === 'img') {
903	            DOM.setAttr(el, {
904	                'src': image
905	            });
906	        } else if (el.nodeName.toLowerCase() === 'object') {
907	            DOM.setAttr(el, {
908	                'data': image,
909	                'type': 'image/svg+xml'
910	            });
911	        }
912	        if (engineSettings.reRender) {
913	            global.setTimeout(function () {
914	                var image = getRenderedImage();
915	                if (image == null) {
916	                    throw 'Holder: couldn\'t render placeholder';
917	                }
918	                //todo: refactor this code into a function
919	                if (el.nodeName.toLowerCase() === 'img') {
920	                    DOM.setAttr(el, {
921	                        'src': image
922	                    });
923	                } else if (el.nodeName.toLowerCase() === 'object') {
924	                    DOM.setAttr(el, {
925	                        'data': image,
926	                        'type': 'image/svg+xml'
927	                    });
928	                }
929	            }, 150);
930	        }
931	    }
932	    //todo: account for re-rendering
933	    DOM.setAttr(el, {
934	        'data-holder-rendered': true
935	    });
936	}
937
938	/**
939	 * Core function that takes a Holder scene description and builds a scene graph
940	 *
941	 * @private
942	 * @param scene Holder scene object
943	 */
944	//todo: make this function reusable
945	//todo: merge app defaults and setup properties into the scene argument
946	function buildSceneGraph(scene) {
947	    var fontSize = App.defaults.size;
948	    if (parseFloat(scene.theme.size)) {
949	        fontSize = scene.theme.size;
950	    } else if (parseFloat(scene.flags.size)) {
951	        fontSize = scene.flags.size;
952	    }
953
954	    scene.font = {
955	        family: scene.theme.font ? scene.theme.font : 'Arial, Helvetica, Open Sans, sans-serif',
956	        size: textSize(scene.width, scene.height, fontSize, App.defaults.scale),
957	        units: scene.theme.units ? scene.theme.units : App.defaults.units,
958	        weight: scene.theme.fontweight ? scene.theme.fontweight : 'bold'
959	    };
960
961	    scene.text = scene.theme.text || Math.floor(scene.width) + 'x' + Math.floor(scene.height);
962
963	    scene.noWrap = scene.theme.nowrap || scene.flags.nowrap;
964
965	    scene.align = scene.theme.align || scene.flags.align || 'center';
966
967	    switch (scene.flags.textmode) {
968	        case 'literal':
969	            scene.text = scene.flags.dimensions.width + 'x' + scene.flags.dimensions.height;
970	            break;
971	        case 'exact':
972	            if (!scene.flags.exactDimensions) break;
973	            scene.text = Math.floor(scene.flags.exactDimensions.width) + 'x' + Math.floor(scene.flags.exactDimensions.height);
974	            break;
975	    }
976
977	    var lineWrap = scene.flags.lineWrap || App.setup.lineWrapRatio;
978	    var sceneMargin = scene.width * lineWrap;
979	    var maxLineWidth = sceneMargin;
980
981	    var sceneGraph = new SceneGraph({
982	        width: scene.width,
983	        height: scene.height
984	    });
985
986	    var Shape = sceneGraph.Shape;
987
988	    var holderBg = new Shape.Rect('holderBg', {
989	        fill: scene.theme.bg
990	    });
991
992	    holderBg.resize(scene.width, scene.height);
993	    sceneGraph.root.add(holderBg);
994
995	    if (scene.flags.outline) {
996	        var outlineColor = new Color(holderBg.properties.fill);
997	        outlineColor = outlineColor.lighten(outlineColor.lighterThan('7f7f7f') ? -0.1 : 0.1);
998	        holderBg.properties.outline = {
999	            fill: outlineColor.toHex(true),
1000	            width: 2
1001	        };
1002	    }
1003
1004	    var holderTextColor = scene.theme.fg;
1005
1006	    if (scene.flags.autoFg) {
1007	        var holderBgColor = new Color(holderBg.properties.fill);
1008	        var lightColor = new Color('fff');
1009	        var darkColor = new Color('000', {
1010	            'alpha': 0.285714
1011	        });
1012
1013	        holderTextColor = holderBgColor.blendAlpha(holderBgColor.lighterThan('7f7f7f') ? darkColor : lightColor).toHex(true);
1014	    }
1015
1016	    var holderTextGroup = new Shape.Group('holderTextGroup', {
1017	        text: scene.text,
1018	        align: scene.align,
1019	        font: scene.font,
1020	        fill: holderTextColor
1021	    });
1022
1023	    holderTextGroup.moveTo(null, null, 1);
1024	    sceneGraph.root.add(holderTextGroup);
1025
1026	    var tpdata = holderTextGroup.textPositionData = stagingRenderer(sceneGraph);
1027	    if (!tpdata) {
1028	        throw 'Holder: staging fallback not supported yet.';
1029	    }
1030	    holderTextGroup.properties.leading = tpdata.boundingBox.height;
1031
1032	    var textNode = null;
1033	    var line = null;
1034
1035	    function finalizeLine(parent, line, width, height) {
1036	        line.width = width;
1037	        line.height = height;
1038	        parent.width = Math.max(parent.width, line.width);
1039	        parent.height += line.height;
1040	    }
1041
1042	    if (tpdata.lineCount > 1) {
1043	        var offsetX = 0;
1044	        var offsetY = 0;
1045	        var lineIndex = 0;
1046	        var lineKey;
1047	        line = new Shape.Group('line' + lineIndex);
1048
1049	        //Double margin so that left/right-aligned next is not flush with edge of image
1050	        if (scene.align === 'left' || scene.align === 'right') {
1051	            maxLineWidth = scene.width * (1 - (1 - lineWrap) * 2);
1052	        }
1053
1054	        for (var i = 0; i < tpdata.words.length; i++) {
1055	            var word = tpdata.words[i];
1056	            textNode = new Shape.Text(word.text);
1057	            var newline = word.text == '\\n';
1058	            if (!scene.noWrap && (offsetX + word.width >= maxLineWidth || newline === true)) {
1059	                finalizeLine(holderTextGroup, line, offsetX, holderTextGroup.properties.leading);
1060	                holderTextGroup.add(line);
1061	                offsetX = 0;
1062	                offsetY += holderTextGroup.properties.leading;
1063	                lineIndex += 1;
1064	                line = new Shape.Group('line' + lineIndex);
1065	                line.y = offsetY;
1066	            }
1067	            if (newline === true) {
1068	                continue;
1069	            }
1070	            textNode.moveTo(offsetX, 0);
1071	            offsetX += tpdata.spaceWidth + word.width;
1072	            line.add(textNode);
1073	        }
1074
1075	        finalizeLine(holderTextGroup, line, offsetX, holderTextGroup.properties.leading);
1076	        holderTextGroup.add(line);
1077
1078	        if (scene.align === 'left') {
1079	            holderTextGroup.moveTo(scene.width - sceneMargin, null, null);
1080	        } else if (scene.align === 'right') {
1081	            for (lineKey in holderTextGroup.children) {
1082	                line = holderTextGroup.children[lineKey];
1083	                line.moveTo(scene.width - line.width, null, null);
1084	            }
1085
1086	            holderTextGroup.moveTo(0 - (scene.width - sceneMargin), null, null);
1087	        } else {
1088	            for (lineKey in holderTextGroup.children) {
1089	                line = holderTextGroup.children[lineKey];
1090	                line.moveTo((holderTextGroup.width - line.width) / 2, null, null);
1091	            }
1092
1093	            holderTextGroup.moveTo((scene.width - holderTextGroup.width) / 2, null, null);
1094	        }
1095
1096	        holderTextGroup.moveTo(null, (scene.height - holderTextGroup.height) / 2, null);
1097
1098	        //If the text exceeds vertical space, move it down so the first line is visible
1099	        if ((scene.height - holderTextGroup.height) / 2 < 0) {
1100	            holderTextGroup.moveTo(null, 0, null);
1101	        }
1102	    } else {
1103	        textNode = new Shape.Text(scene.text);
1104	        line = new Shape.Group('line0');
1105	        line.add(textNode);
1106	        holderTextGroup.add(line);
1107
1108	        if (scene.align === 'left') {
1109	            holderTextGroup.moveTo(scene.width - sceneMargin, null, null);
1110	        } else if (scene.align === 'right') {
1111	            holderTextGroup.moveTo(0 - (scene.width - sceneMargin), null, null);
1112	        } else {
1113	            holderTextGroup.moveTo((scene.width - tpdata.boundingBox.width) / 2, null, null);
1114	        }
1115
1116	        holderTextGroup.moveTo(null, (scene.height - tpdata.boundingBox.height) / 2, null);
1117	    }
1118
1119	    //todo: renderlist
1120	    return sceneGraph;
1121	}
1122
1123	/**
1124	 * Adaptive text sizing function
1125	 *
1126	 * @private
1127	 * @param width Parent width
1128	 * @param height Parent height
1129	 * @param fontSize Requested text size
1130	 * @param scale Proportional scale of text
1131	 */
1132	function textSize(width, height, fontSize, scale) {
1133	    var stageWidth = parseInt(width, 10);
1134	    var stageHeight = parseInt(height, 10);
1135
1136	    var bigSide = Math.max(stageWidth, stageHeight);
1137	    var smallSide = Math.min(stageWidth, stageHeight);
1138
1139	    var newHeight = 0.8 * Math.min(smallSide, bigSide * scale);
1140	    return Math.round(Math.max(fontSize, newHeight));
1141	}
1142
1143	/**
1144	 * Iterates over resizable (fluid or auto) placeholders and renders them
1145	 *
1146	 * @private
1147	 * @param element Optional element selector, specified only if a specific element needs to be re-rendered
1148	 */
1149	function updateResizableElements(element) {
1150	    var images;
1151	    if (element == null || element.nodeType == null) {
1152	        images = App.vars.resizableImages;
1153	    } else {
1154	        images = [element];
1155	    }
1156	    for (var i = 0, l = images.length; i < l; i++) {
1157	        var el = images[i];
1158	        if (el.holderData) {
1159	            var flags = el.holderData.flags;
1160	            var dimensions = dimensionCheck(el);
1161	            if (dimensions) {
1162	                if (!el.holderData.resizeUpdate) {
1163	                    continue;
1164	                }
1165
1166	                if (flags.fluid && flags.auto) {
1167	                    var fluidConfig = el.holderData.fluidConfig;
1168	                    switch (fluidConfig.mode) {
1169	                        case 'width':
1170	                            dimensions.height = dimensions.width / fluidConfig.ratio;
1171	                            break;
1172	                        case 'height':
1173	                            dimensions.width = dimensions.height * fluidConfig.ratio;
1174	                            break;
1175	                    }
1176	                }
1177
1178	                var settings = {
1179	                    mode: 'image',
1180	                    holderSettings: {
1181	                        dimensions: dimensions,
1182	                        theme: flags.theme,
1183	                        flags: flags
1184	                    },
1185	                    el: el,
1186	                    engineSettings: el.holderData.engineSettings
1187	                };
1188
1189	                if (flags.textmode == 'exact') {
1190	                    flags.exactDimensions = dimensions;
1191	                    settings.holderSettings.dimensions = flags.dimensions;
1192	                }
1193
1194	                render(settings);
1195	            } else {
1196	                setInvisible(el);
1197	            }
1198	        }
1199	    }
1200	}
1201
1202	/**
1203	 * Sets up aspect ratio metadata for fluid placeholders, in order to preserve proportions when resizing
1204	 *
1205	 * @private
1206	 * @param el Image DOM element
1207	 */
1208	function setInitialDimensions(el) {
1209	    if (el.holderData) {
1210	        var dimensions = dimensionCheck(el);
1211	        if (dimensions) {
1212	            var flags = el.holderData.flags;
1213
1214	            var fluidConfig = {
1215	                fluidHeight: flags.dimensions.height.slice(-1) == '%',
1216	                fluidWidth: flags.dimensions.width.slice(-1) == '%',
1217	                mode: null,
1218	                initialDimensions: dimensions
1219	            };
1220
1221	            if (fluidConfig.fluidWidth && !fluidConfig.fluidHeight) {
1222	                fluidConfig.mode = 'width';
1223	                fluidConfig.ratio = fluidConfig.initialDimensions.width / parseFloat(flags.dimensions.height);
1224	            } else if (!fluidConfig.fluidWidth && fluidConfig.fluidHeight) {
1225	                fluidConfig.mode = 'height';
1226	                fluidConfig.ratio = parseFloat(flags.dimensions.width) / fluidConfig.initialDimensions.height;
1227	            }
1228
1229	            el.holderData.fluidConfig = fluidConfig;
1230	        } else {
1231	            setInvisible(el);
1232	        }
1233	    }
1234	}
1235
1236	/**
1237	 * Iterates through all current invisible images, and if they're visible, renders them and removes them from further checks. Runs every animation frame.
1238	 *
1239	 * @private
1240	 */
1241	function visibilityCheck() {
1242	    var renderableImages = [];
1243	    var keys = Object.keys(App.vars.invisibleImages);
1244	    var el;
1245
1246	    keys.forEach(function (key) {
1247	        el = App.vars.invisibleImages[key];
1248	        if (dimensionCheck(el) && el.nodeName.toLowerCase() == 'img') {
1249	            renderableImages.push(el);
1250	            delete App.vars.invisibleImages[key];
1251	        }
1252	    });
1253
1254	    if (renderableImages.length) {
1255	        Holder.run({
1256	            images: renderableImages
1257	        });
1258	    }
1259
1260	    // Done to prevent 100% CPU usage via aggressive calling of requestAnimationFrame
1261	    setTimeout(function () {
1262	        global.requestAnimationFrame(visibilityCheck);
1263	    }, 10);
1264	}
1265
1266	/**
1267	 * Starts checking for invisible placeholders if not doing so yet. Does nothing otherwise.
1268	 *
1269	 * @private
1270	 */
1271	function startVisibilityCheck() {
1272	    if (!App.vars.visibilityCheckStarted) {
1273	        global.requestAnimationFrame(visibilityCheck);
1274	        App.vars.visibilityCheckStarted = true;
1275	    }
1276	}
1277
1278	/**
1279	 * Sets a unique ID for an image detected to be invisible and adds it to the map of invisible images checked by visibilityCheck
1280	 *
1281	 * @private
1282	 * @param el Invisible DOM element
1283	 */
1284	function setInvisible(el) {
1285	    if (!el.holderData.invisibleId) {
1286	        App.vars.invisibleId += 1;
1287	        App.vars.invisibleImages['i' + App.vars.invisibleId] = el;
1288	        el.holderData.invisibleId = App.vars.invisibleId;
1289	    }
1290	}
1291
1292	//todo: see if possible to convert stagingRenderer to use HTML only
1293	var stagingRenderer = (function() {
1294	    var svg = null,
1295	        stagingText = null,
1296	        stagingTextNode = null;
1297	    return function(graph) {
1298	        var rootNode = graph.root;
1299	        if (App.setup.supportsSVG) {
1300	            var firstTimeSetup = false;
1301	            var tnode = function(text) {
1302	                return document.createTextNode(text);
1303	            };
1304	            if (svg == null || svg.parentNode !== document.body) {
1305	                firstTimeSetup = true;
1306	            }
1307
1308	            svg = SVG.initSVG(svg, rootNode.properties.width, rootNode.properties.height);
1309	            //Show staging element before staging
1310	            svg.style.display = 'block';
1311
1312	            if (firstTimeSetup) {
1313	                stagingText = DOM.newEl('text', SVG_NS);
1314	                stagingTextNode = tnode(null);
1315	                DOM.setAttr(stagingText, {
1316	                    x: 0
1317	                });
1318	                stagingText.appendChild(stagingTextNode);
1319	                svg.appendChild(stagingText);
1320	                document.body.appendChild(svg);
1321	                svg.style.visibility = 'hidden';
1322	                svg.style.position = 'absolute';
1323	                svg.style.top = '-100%';
1324	                svg.style.left = '-100%';
1325	                //todo: workaround for zero-dimension <svg> tag in Opera 12
1326	                //svg.setAttribute('width', 0);
1327	                //svg.setAttribute('height', 0);
1328	            }
1329
1330	            var holderTextGroup = rootNode.children.holderTextGroup;
1331	            var htgProps = holderTextGroup.properties;
1332	            DOM.setAttr(stagingText, {
1333	                'y': htgProps.font.size,
1334	                'style': utils.cssProps({
1335	                    'font-weight': htgProps.font.weight,
1336	                    'font-size': htgProps.font.size + htgProps.font.units,
1337	                    'font-family': htgProps.font.family
1338	                })
1339	            });
1340
1341	            //Get bounding box for the whole string (total width and height)
1342	            stagingTextNode.nodeValue = htgProps.text;
1343	            var stagingTextBBox = stagingText.getBBox();
1344
1345	            //Get line count and split the string into words
1346	            var lineCount = Math.ceil(stagingTextBBox.width / rootNode.properties.width);
1347	            var words = htgProps.text.split(' ');
1348	            var newlines = htgProps.text.match(/\\n/g);
1349	            lineCount += newlines == null ? 0 : newlines.length;
1350
1351	            //Get bounding box for the string with spaces removed
1352	            stagingTextNode.nodeValue = htgProps.text.replace(/[ ]+/g, '');
1353	            var computedNoSpaceLength = stagingText.getComputedTextLength();
1354
1355	            //Compute average space width
1356	            var diffLength = stagingTextBBox.width - computedNoSpaceLength;
1357	            var spaceWidth = Math.round(diffLength / Math.max(1, words.length - 1));
1358
1359	            //Get widths for every word with space only if there is more than one line
1360	            var wordWidths = [];
1361	            if (lineCount > 1) {
1362	                stagingTextNode.nodeValue = '';
1363	                for (var i = 0; i < words.length; i++) {
1364	                    if (words[i].length === 0) continue;
1365	                    stagingTextNode.nodeValue = utils.decodeHtmlEntity(words[i]);
1366	                    var bbox = stagingText.getBBox();
1367	                    wordWidths.push({
1368	                        text: words[i],
1369	                        width: bbox.width
1370	                    });
1371	                }
1372	            }
1373
1374	            //Hide staging element after staging
1375	            svg.style.display = 'none';
1376
1377	            return {
1378	                spaceWidth: spaceWidth,
1379	                lineCount: lineCount,
1380	                boundingBox: stagingTextBBox,
1381	                words: wordWidths
1382	            };
1383	        } else {
1384	            //todo: canvas fallback for measuring text on android 2.3
1385	            return false;
1386	        }
1387	    };
1388	})();
1389
1390	//Helpers
1391
1392	/**
1393	 * Prevents a function from being called too often, waits until a timer elapses to call it again
1394	 *
1395	 * @param fn Function to call
1396	 */
1397	function debounce(fn) {
1398	    if (!App.vars.debounceTimer) fn.call(this);
1399	    if (App.vars.debounceTimer) global.clearTimeout(App.vars.debounceTimer);
1400	    App.vars.debounceTimer = global.setTimeout(function() {
1401	        App.vars.debounceTimer = null;
1402	        fn.call(this);
1403	    }, App.setup.debounce);
1404	}
1405
1406	/**
1407	 * Holder-specific resize/orientation change callback, debounced to prevent excessive execution
1408	 */
1409	function resizeEvent() {
1410	    debounce(function() {
1411	        updateResizableElements(null);
1412	    });
1413	}
1414
1415	//Set up flags
1416
1417	for (var flag in App.flags) {
1418	    if (!App.flags.hasOwnProperty(flag)) continue;
1419	    App.flags[flag].match = function(val) {
1420	        return val.match(this.regex);
1421	    };
1422	}
1423
1424	//Properties set once on setup
1425
1426	App.setup = {
1427	    renderer: 'html',
1428	    debounce: 100,
1429	    ratio: 1,
1430	    supportsCanvas: false,
1431	    supportsSVG: false,
1432	    lineWrapRatio: 0.9,
1433	    dataAttr: 'data-src',
1434	    renderers: ['html', 'canvas', 'svg']
1435	};
1436
1437	//Properties modified during runtime
1438
1439	App.vars = {
1440	    preempted: false,
1441	    resizableImages: [],
1442	    invisibleImages: {},
1443	    invisibleId: 0,
1444	    visibilityCheckStarted: false,
1445	    debounceTimer: null,
1446	    cache: {}
1447	};
1448
1449	//Pre-flight
1450
1451	(function() {
1452	    var canvas = DOM.newEl('canvas');
1453
1454	    if (canvas.getContext) {
1455	        if (canvas.toDataURL('image/png').indexOf('data:image/png') != -1) {
1456	            App.setup.renderer = 'canvas';
1457	            App.setup.supportsCanvas = true;
1458	        }
1459	    }
1460
1461	    if (!!document.createElementNS && !!document.createElementNS(SVG_NS, 'svg').createSVGRect) {
1462	        App.setup.renderer = 'svg';
1463	        App.setup.supportsSVG = true;
1464	    }
1465	})();
1466
1467	//Starts checking for invisible placeholders
1468	startVisibilityCheck();
1469
1470	if (onDomReady) {
1471	    onDomReady(function() {
1472	        if (!App.vars.preempted) {
1473	            Holder.run();
1474	        }
1475	        if (global.addEventListener) {
1476	            global.addEventListener('resize', resizeEvent, false);
1477	            global.addEventListener('orientationchange', resizeEvent, false);
1478	        } else {
1479	            global.attachEvent('onresize', resizeEvent);
1480	        }
1481
1482	        if (typeof global.Turbolinks == 'object') {
1483	            global.document.addEventListener('page:change', function() {
1484	                Holder.run();
1485	            });
1486	        }
1487	    });
1488	}
1489
1490	module.exports = Holder;
1491
1492	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
1493
1494/***/ },
1495/* 2 */
1496/***/ function(module, exports) {
1497
1498	/*!
1499	 * onDomReady.js 1.4.0 (c) 2013 Tubal Martin - MIT license
1500	 *
1501	 * Specially modified to work with Holder.js
1502	 */
1503
1504	function _onDomReady(win) {
1505	    //Lazy loading fix for Firefox < 3.6
1506	    //http://webreflection.blogspot.com/2009/11/195-chars-to-help-lazy-loading.html
1507	    if (document.readyState == null && document.addEventListener) {
1508	        document.addEventListener("DOMContentLoaded", function DOMContentLoaded() {
1509	            document.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
1510	            document.readyState = "complete";
1511	        }, false);
1512	        document.readyState = "loading";
1513	    }
1514	    
1515	    var doc = win.document,
1516	        docElem = doc.documentElement,
1517	    
1518	        LOAD = "load",
1519	        FALSE = false,
1520	        ONLOAD = "on"+LOAD,
1521	        COMPLETE = "complete",
1522	        READYSTATE = "readyState",
1523	        ATTACHEVENT = "attachEvent",
1524	        DETACHEVENT = "detachEvent",
1525	        ADDEVENTLISTENER = "addEventListener",
1526	        DOMCONTENTLOADED = "DOMContentLoaded",
1527	        ONREADYSTATECHANGE = "onreadystatechange",
1528	        REMOVEEVENTLISTENER = "removeEventListener",
1529	    
1530	        // W3C Event model
1531	        w3c = ADDEVENTLISTENER in doc,
1532	        _top = FALSE,
1533	    
1534	        // isReady: Is the DOM ready to be used? Set to true once it occurs.
1535	        isReady = FALSE,
1536	    
1537	        // Callbacks pending execution until DOM is ready
1538	        callbacks = [];
1539	    
1540	    // Handle when the DOM is ready
1541	    function ready( fn ) {
1542	        if ( !isReady ) {
1543	    
1544	            // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1545	            if ( !doc.body ) {
1546	                return defer( ready );
1547	            }
1548	    
1549	            // Remember that the DOM is ready
1550	            isReady = true;
1551	    
1552	            // Execute all callbacks
1553	            while ( fn = callbacks.shift() ) {
1554	                defer( fn );
1555	            }
1556	        }
1557	    }
1558	    
1559	    // The ready event handler
1560	    function completed( event ) {
1561	        // readyState === "complete" is good enough for us to call the dom ready in oldIE
1562	        if ( w3c || event.type === LOAD || doc[READYSTATE] === COMPLETE ) {
1563	            detach();
1564	            ready();
1565	        }
1566	    }
1567	    
1568	    // Clean-up method for dom ready events
1569	    function detach() {
1570	        if ( w3c ) {
1571	            doc[REMOVEEVENTLISTENER]( DOMCONTENTLOADED, completed, FALSE );
1572	            win[REMOVEEVENTLISTENER]( LOAD, completed, FALSE );
1573	        } else {
1574	            doc[DETACHEVENT]( ONREADYSTATECHANGE, completed );
1575	            win[DETACHEVENT]( ONLOAD, completed );
1576	        }
1577	    }
1578	    
1579	    // Defers a function, scheduling it to run after the current call stack has cleared.
1580	    function defer( fn, wait ) {
1581	        // Allow 0 to be passed
1582	        setTimeout( fn, +wait >= 0 ? wait : 1 );
1583	    }
1584	    
1585	    // Attach the listeners:
1586	    
1587	    // Catch cases where onDomReady is called after the browser event has already occurred.
1588	    // we once tried to use readyState "interactive" here, but it caused issues like the one
1589	    // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
1590	    if ( doc[READYSTATE] === COMPLETE ) {
1591	        // Handle it asynchronously to allow scripts the opportunity to delay ready
1592	        defer( ready );
1593	    
1594	    // Standards-based browsers support DOMContentLoaded
1595	    } else if ( w3c ) {
1596	        // Use the handy event callback
1597	        doc[ADDEVENTLISTENER]( DOMCONTENTLOADED, completed, FALSE );
1598	    
1599	        // A fallback to window.onload, that will always work
1600	        win[ADDEVENTLISTENER]( LOAD, completed, FALSE );
1601	    
1602	    // If IE event model is used
1603	    } else {
1604	        // Ensure firing before onload, maybe late but safe also for iframes
1605	        doc[ATTACHEVENT]( ONREADYSTATECHANGE, completed );
1606	    
1607	        // A fallback to window.onload, that will always work
1608	        win[ATTACHEVENT]( ONLOAD, completed );
1609	    
1610	        // If IE and not a frame
1611	        // continually check to see if the document is ready
1612	        try {
1613	            _top = win.frameElement == null && docElem;
1614	        } catch(e) {}
1615	    
1616	        if ( _top && _top.doScroll ) {
1617	            (function doScrollCheck() {
1618	                if ( !isReady ) {
1619	                    try {
1620	                        // Use the trick by Diego Perini
1621	                        // http://javascript.nwbox.com/IEContentLoaded/
1622	                        _top.doScroll("left");
1623	                    } catch(e) {
1624	                        return defer( doScrollCheck, 50 );
1625	                    }
1626	    
1627	                    // detach all dom ready events
1628	                    detach();
1629	    
1630	                    // and execute any waiting functions
1631	                    ready();
1632	                }
1633	            })();
1634	        }
1635	    }
1636	    
1637	    function onDomReady( fn ) {
1638	        // If DOM is ready, execute the function (async), otherwise wait
1639	        isReady ? defer( fn ) : callbacks.push( fn );
1640	    }
1641	    
1642	    // Add version
1643	    onDomReady.version = "1.4.0";
1644	    // Add method to check if DOM is ready
1645	    onDomReady.isReady = function(){
1646	        return isReady;
1647	    };
1648
1649	    return onDomReady;
1650	}
1651
1652	module.exports = typeof window !== "undefined" && _onDomReady(window);
1653
1654/***/ },
1655/* 3 */
1656/***/ function(module, exports, __webpack_require__) {
1657
1658	//Modified version of component/querystring
1659	//Changes: updated dependencies, dot notation parsing, JSHint fixes
1660	//Fork at https://github.com/imsky/querystring
1661
1662	/**
1663	 * Module dependencies.
1664	 */
1665
1666	var encode = encodeURIComponent;
1667	var decode = decodeURIComponent;
1668	var trim = __webpack_require__(4);
1669	var type = __webpack_require__(5);
1670
1671	var arrayRegex = /(\w+)\[(\d+)\]/;
1672	var objectRegex = /\w+\.\w+/;
1673
1674	/**
1675	 * Parse the given query `str`.
1676	 *
1677	 * @param {String} str
1678	 * @return {Object}
1679	 * @api public
1680	 */
1681
1682	exports.parse = function(str){
1683	  if ('string' !== typeof str) return {};
1684
1685	  str = trim(str);
1686	  if ('' === str) return {};
1687	  if ('?' === str.charAt(0)) str = str.slice(1);
1688
1689	  var obj = {};
1690	  var pairs = str.split('&');
1691	  for (var i = 0; i < pairs.length; i++) {
1692	    var parts = pairs[i].split('=');
1693	    var key = decode(parts[0]);
1694	    var m, ctx, prop;
1695
1696	    if (m = arrayRegex.exec(key)) {
1697	      obj[m[1]] = obj[m[1]] || [];
1698	      obj[m[1]][m[2]] = decode(parts[1]);
1699	      continue;
1700	    }
1701
1702	    if (m = objectRegex.test(key)) {
1703	      m = key.split('.');
1704	      ctx = obj;
1705	      
1706	      while (m.length) {
1707	        prop = m.shift();
1708
1709	        if (!prop.length) continue;
1710
1711	        if (!ctx[prop]) {
1712	          ctx[prop] = {};
1713	        } else if (ctx[prop] && typeof ctx[prop] !== 'object') {
1714	          break;
1715	        }
1716
1717	        if (!m.length) {
1718	          ctx[prop] = decode(parts[1]);
1719	        }
1720
1721	        ctx = ctx[prop];
1722	      }
1723
1724	      continue;
1725	    }
1726
1727	    obj[parts[0]] = null == parts[1] ? '' : decode(parts[1]);
1728	  }
1729
1730	  return obj;
1731	};
1732
1733	/**
1734	 * Stringify the given `obj`.
1735	 *
1736	 * @param {Object} obj
1737	 * @return {String}
1738	 * @api public
1739	 */
1740
1741	exports.stringify = function(obj){
1742	  if (!obj) return '';
1743	  var pairs = [];
1744
1745	  for (var key in obj) {
1746	    var value = obj[key];
1747
1748	    if ('array' == type(value)) {
1749	      for (var i = 0; i < value.length; ++i) {
1750	        pairs.push(encode(key + '[' + i + ']') + '=' + encode(value[i]));
1751	      }
1752	      continue;
1753	    }
1754
1755	    pairs.push(encode(key) + '=' + encode(obj[key]));
1756	  }
1757
1758	  return pairs.join('&');
1759	};
1760
1761
1762/***/ },
1763/* 4 */

2320indexes instead.')
2321	  return this.readUInt8(offset)
2322	}
2323
2324	// `set` is deprecated
2325	Buffer.prototype.set = function set (v, offset) {
2326	  console.log('.set() is deprecated. Access using array indexes instead.')
2327	  return this.writeUInt8(v, offset)
2328	}
2329
2330	function hexWrite (buf, string, offset, length) {
2331	  offset = Number(offset) || 0
2332	  var remaining = buf.length - offset
2333	  if (!length) {
2334	    length = remaining
2335	  } else {
2336	    length = Number(length)
2337	    if (length > remaining) {
2338	      length = remaining
2339	    }
2340	  }
2341
2342	  // must be an even number of digits
2343	  var strLen = string.length
2344	  if (strLen % 2 !== 0) throw new Error('Invalid hex string')
2345
2346	  if (length > strLen / 2) {
2347	    length = strLen / 2
2348	  }
2349	  for (var i = 0; i < length; i++) {
2350	    var parsed = parseInt(string.substr(i * 2, 2), 16)
2351	    if (isNaN(parsed)) throw new Error('Invalid hex string')
2352	    buf[offset + i] = parsed
2353	  }
2354	  return i
2355	}
2356
2357	function utf8Write (buf, string, offset, length) {
2358	  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
2359	}
2360
2361	function asciiWrite (buf, string, offset, length) {
2362	  return blitBuffer(asciiToBytes(string), buf, offset, length)
2363	}
2364
2365	function binaryWrite (buf, string, offset, length) {
2366	  return asciiWrite(buf, string, offset, length)
2367	}
2368
2369	function base64Write (buf, string, offset, length) {
2370	  return blitBuffer(base64ToBytes(string), buf, offset, length)
2371	}
2372
2373	function ucs2Write (buf, string, offset, length) {
2374	  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
2375	}
2376
2377	Buffer.prototype.write = function write (string, offset, length, encoding) {
2378	  // Buffer#write(string)
2379	  if (offset === undefined) {
2380	    encoding = 'utf8'
2381	    length = this.length
2382	    offset = 0
2383	  // Buffer#write(string, encoding)
2384	  } else if (length === undefined && typeof offset === 'string') {
2385	    encoding = offset
2386	    length = this.length
2387	    offset = 0
2388	  // Buffer#write(string, offset[, length][, encoding])
2389	  } else if (isFinite(offset)) {
2390	    offset = offset | 0
2391	    if (isFinite(length)) {
2392	      length = length | 0
2393	      if (encoding === undefined) encoding = 'utf8'
2394	    } else {
2395	      encoding = length
2396	      length = undefined
2397	    }
2398	  // legacy write(string, encoding, offset, length) - remove in v0.13
2399	  } else {
2400	    var swap = encoding
2401	    encoding = offset
2402	    offset = length | 0
2403	    length = swap
2404	  }
2405
2406	  var remaining = this.length - offset
2407	  if (length === undefined || length > remaining) length = remaining
2408
2409	  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
2410	    throw new RangeError('attempt to write outside buffer bounds')
2411	  }
2412
2413	  if (!encoding) encoding = 'utf8'
2414
2415	  var loweredCase = false
2416	  for (;;) {
2417	    switch (encoding) {
2418	      case 'hex':
2419	        return hexWrite(this, string, offset, length)
2420
2421	      case 'utf8':
2422	      case 'utf-8':
2423	        return utf8Write(this, string, offset, length)
2424
2425	      case 'ascii':
2426	        return asciiWrite(this, string, offset, length)
2427
2428	      case 'binary':
2429	        return binaryWrite(this, string, offset, length)
2430
2431	      case 'base64':
2432	        // Warning: maxLength not taken into account in base64Write
2433	        return base64Write(this, string, offset, length)
2434
2435	      case 'ucs2':
2436	      case 'ucs-2':
2437	      case 'utf16le':
2438	      case 'utf-16le':
2439	        return ucs2Write(this, string, offset, length)
2440
2441	      default:
2442	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
2443	        encoding = ('' + encoding).toLowerCase()
2444	        loweredCase = true
2445	    }
2446	  }
2447	}
2448
2449	Buffer.prototype.toJSON = function toJSON () {
2450	  return {
2451	    type: 'Buffer',
2452	    data: Array.prototype.slice.call(this._arr || this, 0)
2453	  }
2454	}
2455
2456	function base64Slice (buf, start, end) {
2457	  if (start === 0 && end === buf.length) {
2458	    return base64.fromByteArray(buf)
2459	  } else {
2460	    return base64.fromByteArray(buf.slice(start, end))
2461	  }
2462	}
2463
2464	function utf8Slice (buf, start, end) {
2465	  end = Math.min(buf.length, end)
2466	  var res = []
2467
2468	  var i = start
2469	  while (i < end) {
2470	    var firstByte = buf[i]
2471	    var codePoint = null
2472	    var bytesPerSequence = (firstByte > 0xEF) ? 4
2473	      : (firstByte > 0xDF) ? 3
2474	      : (firstByte > 0xBF) ? 2
2475	      : 1
2476
2477	    if (i + bytesPerSequence <= end) {
2478	      var secondByte, thirdByte, fourthByte, tempCodePoint
2479
2480	      switch (bytesPerSequence) {
2481	        case 1:
2482	          if (firstByte < 0x80) {
2483	            codePoint = firstByte
2484	          }
2485	          break
2486	        case 2:
2487	          secondByte = buf[i + 1]
2488	          if ((secondByte & 0xC0) === 0x80) {
2489	            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
2490	            if (tempCodePoint > 0x7F) {
2491	              codePoint = tempCodePoint
2492	            }
2493	          }
2494	          break
2495	        case 3:
2496	          secondByte = buf[i + 1]
2497	          thirdByte = buf[i + 2]
2498	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
2499	            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
2500	            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
2501	              codePoint = tempCodePoint
2502	            }
2503	          }
2504	          break
2505	        case 4:
2506	          secondByte = buf[i + 1]
2507	          thirdByte = buf[i + 2]
2508	          fourthByte = buf[i + 3]
2509	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
2510	            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
2511	            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
2512	              codePoint = tempCodePoint
2513	            }
2514	          }
2515	      }
2516	    }
2517
2518	    if (codePoint === null) {
2519	      // we did not generate a valid codePoint so insert a
2520	      // replacement char (U+FFFD) and advance only 1 byte
2521	      codePoint = 0xFFFD
2522	      bytesPerSequence = 1
2523	    } else if (codePoint > 0xFFFF) {
2524	      // encode to utf16 (surrogate pair dance)
2525	      codePoint -= 0x10000
2526	      res.push(codePoint >>>

2526 10 & 0x3FF | 0xD800)
2527	      codePoint = 0xDC00 | codePoint & 0x3FF
2528	    }
2529
2530	    res.push(codePoint)
2531	    i += bytesPerSequence
2532	  }
2533
2534	  return decodeCodePointsArray(res)
2535	}
2536
2537	// Based on http://stackoverflow.com/a/22747272/680742, the browser with
2538	// the lowest limit is Chrome, with 0x10000 args.
2539	// We go 1 magnitude less, for safety
2540	var MAX_ARGUMENTS_LENGTH = 0x1000
2541
2542	function decodeCodePointsArray (codePoints) {
2543	  var len = codePoints.length
2544	  if (len <= MAX_ARGUMENTS_LENGTH) {
2545	    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
2546	  }
2547
2548	  // Decode in chunks to avoid "call stack size exceeded".
2549	  var res = ''
2550	  var i = 0
2551	  while (i < len) {
2552	    res += String.fromCharCode.apply(
2553	      String,
2554	      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
2555	    )
2556	  }
2557	  return res
2558	}
2559
2560	function asciiSlice (buf, start, end) {
2561	  var ret = ''
2562	  end = Math.min(buf.length, end)
2563
2564	  for (var i = start; i < end; i++) {
2565	    ret += String.fromCharCode(buf[i] & 0x7F)
2566	  }
2567	  return ret
2568	}
2569
2570	function binarySlice (buf, start, end) {
2571	  var ret = ''
2572	  end = Math.min(buf.length, end)
2573
2574	  for (var i = start; i < end; i++) {
2575	    ret += String.fromCharCode(buf[i])
2576	  }
2577	  return ret
2578	}
2579
2580	function hexSlice (buf, start, end) {
2581	  var len = buf.length
2582
2583	  if (!start || start < 0) start = 0
2584	  if (!end || end < 0 || end > len) end = len
2585
2586	  var out = ''
2587	  for (var i = start; i < end; i++) {
2588	    out += toHex(buf[i])
2589	  }
2590	  return out
2591	}
2592
2593	function utf16leSlice (buf, start, end) {
2594	  var bytes = buf.slice(start, end)
2595	  var res = ''
2596	  for (var i = 0; i < bytes.length; i += 2) {
2597	    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
2598	  }
2599	  return res
2600	}
2601
2602	Buffer.prototype.slice = function slice (start, end) {
2603	  var len = this.length
2604	  start = ~~start
2605	  end = end === undefined ? len : ~~end
2606
2607	  if (start < 0) {
2608	    start += len
2609	    if (start < 0) start = 0
2610	  } else if (start > len) {
2611	    start = len
2612	  }
2613
2614	  if (end < 0) {
2615	    end += len
2616	    if (end < 0) end = 0
2617	  } else if (end > len) {
2618	    end = len
2619	  }
2620
2621	  if (end < start) end = start
2622
2623	  var newBuf
2624	  if (Buffer.TYPED_ARRAY_SUPPORT) {
2625	    newBuf = Buffer._augment(this.subarray(start, end))
2626	  } else {
2627	    var sliceLen = end - start
2628	    newBuf = new Buffer(sliceLen, undefined)
2629	    for (var i = 0; i < sliceLen; i++) {
2630	      newBuf[i] = this[i + start]
2631	    }
2632	  }
2633
2634	  if (newBuf.length) newBuf.parent = this.parent || this
2635
2636	  return newBuf
2637	}
2638
2639	/*
2640	 * Need to make sure that buffer isn't trying to write out of bounds.
2641	 */

2642	function checkOffset (offset, ext, length) {
2643	  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
2644	  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
2645	}
2646
2647	Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
2648	  offset = offset | 0
2649	  byteLength = byteLength | 0
2650	  if (!noAssert) checkOffset(offset, byteLength, this.length)
2651
2652	  var val = this[offset]
2653	  var mul = 1
2654	  var i = 0
2655	  while (++i < byteLength && (mul *= 0x100)) {
2656	    val += this[offset + i] * mul
2657	  }
2658
2659	  return val
2660	}
2661
2662	Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
2663	  offset = offset | 0
2664	  byteLength = byteLength | 0
2665	  if (!noAssert) {
2666	    checkOffset(offset, byteLength, this.length)
2667	  }
2668
2669	  var val = this[offset + --byteLength]
2670	  var mul = 1
2671	  while (byteLength > 0 && (mul *= 0x100)) {
2672	    val += this[offset + --byteLength] * mul
2673	  }
2674
2675	  return val
2676	}
2677
2678	Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
2679	  if (!noAssert) checkOffset(offset, 1, this.length)
2680	  return this[offset]
2681	}
2682
2683	Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
2684	  if (!noAssert) checkOffset(offset, 2, this.length)
2685	  return this[offset] | (this[offset + 1] << 8)
2686	}
2687
2688	Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
2689	  if (!noAssert) checkOffset(offset, 2, this.length)
2690	  return (this[offset] << 8) | this[offset + 1]
2691	}
2692
2693	Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
2694	  if (!noAssert) checkOffset(offset, 4, this.length)
2695
2696	  return ((this[offset]) |
2697	      (this[offset + 1] << 8) |
2698	      (this[offset + 2] << 16)) +
2699	      (this[offset + 3] * 0x1000000)
2700	}
2701
2702	Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
2703	  if (!noAssert) checkOffset(offset, 4, this.length)
2704
2705	  return (this[offset] * 0x1000000) +
2706	    ((this[offset + 1] << 16) |
2707	    (this[offset + 2] << 8) |
2708	    this[offset + 3])
2709	}
2710
2711	Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
2712	  offset = offset | 0
2713	  byteLength = byteLength | 0
2714	  if (!noAssert) checkOffset(offset, byteLength, this.length)
2715
2716	  var val = this[offset]
2717	  var mul = 1
2718	  var i = 0
2719	  while (++i < byteLength && (mul *= 0x100)) {
2720	    val += this[offset + i] * mul
2721	  }
2722	  mul *= 0x80
2723
2724	  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
2725
2726	  return val
2727	}
2728
2729	Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
2730	  offset = offset | 0
2731	  byteLength = byteLength | 0
2732	  if (!noAssert) checkOffset(offset, byteLength, this.length)
2733
2734	  var i = byteLength
2735	  var mul = 1
2736	  var val = this[offset + --i]
2737	  while (i > 0 && (mul *= 0x100)) {
2738	    val += this[offset + --i] * mul
2739	  }
2740	  mul *= 0x80
2741
2742	  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
2743
2744	  return val
2745	}
2746
2747	Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
2748	  if (!noAssert) checkOffset(offset, 1, this.length)
2749	  if (!(this[offset] & 0x80)) return (this[offset])
2750	  return ((0xff - this[offset] + 1) * -1)
2751	}
2752
2753	Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
2754	  if (!noAssert) checkOffset(offset, 2, this.length)
2755	  var val = this[offset] | (this[offset + 1] << 8)
2756	  return (val & 0x8000) ? val | 0xFFFF0000 : val
2757	}
2758
2759	Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
2760	  if (!noAssert) checkOffset(offset, 2, this.length)
2761	  var val = this[offset + 1] | (this[offset] << 8)
2762	  return (val & 0x8000) ? val | 0xFFFF0000 : val
2763	}
2764
2765	Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
2766	  if (!noAssert) checkOffset(offset, 4, this.length)
2767
2768	  return (this[offset]) |
2769	    (this[offset + 1] << 8) |
2770	    (this[offset + 2] << 16) |
2771	    (this[offset + 3] << 24)
2772	}
2773
2774	Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
2775	  if (!noAssert) checkOffset(offset, 4, this.length)
2776
2777	  return (this[offset] << 24) |
2778	    (this[offset + 1] << 16) |
2779	    (this[offset + 2] << 8) |
2780	    (this[offset + 3])
2781	}
2782
2783	Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
2784	  if (!noAssert) checkOffset(offset, 4, this.length)
2785	  return ieee754.read(this, offset, true, 23, 4)
2786	}
2787
2788	Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
2789	  if (!noAssert) checkOffset(offset, 4, this.length)
2790	  return ieee754.read(this, offset, false, 23, 4)
2791	}
2792
2793	Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
2794	  if (!noAssert) checkOffset(offset, 8, this.length)
2795	  return ieee754.read(this, offset, true, 52, 8)
2796	}
2797
2798	Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
2799	  if (!noAssert) checkOffset(offset, 8, this.length)
2800	  return ieee754.read(this, offset, false, 52, 8)
2801	}
2802
2803	function checkInt (buf, value, offset, ext, max, min) {
2804	  if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
2805	  if (value > max || value < min) throw new RangeError('value is out of bounds')
2806	  if (offset + ext > buf.length) throw new RangeError('index out of range')
2807	}
2808
2809	Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
2810	  value = +value
2811	  offset = offset | 0
2812	  byteLength = byteLength | 0
2813	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
2814
2815	  var mul = 1
2816	  var i = 0
2817	  this[offset] = value & 0xFF
2818	  while (++i < byteLength && (mul *= 0x100)) {
2819	    this[offset + i] = (value / mul) & 0xFF
2820	  }
2821
2822	  return offset + byteLength
2823	}
2824
2825	Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
2826	  value = +value
2827	  offset = offset | 0
2828	  byteLength = byteLength | 0
2829	  if (!noAssert) checkInt(this, value, offset, byteLength, Math.pow(2, 8 * byteLength), 0)
2830
2831	  var i = byteLength - 1
2832	  var mul = 1
2833	  this[offset + i] = value & 0xFF
2834	  while (--i >= 0 && (mul *= 0x100)) {
2835	    this[offset + i] = (value / mul) & 0xFF
2836	  }
2837
2838	  return offset + byteLength
2839	}
2840
2841	Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
2842	  value = +value
2843	  offset = offset | 0
2844	  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
2845	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
2846	  this[offset] = (value & 0xff)
2847	  return offset + 1
2848	}
2849
2850	function objectWriteUInt16 (buf, value, offset, littleEndian) {
2851	  if (value < 0) value = 0xffff + value + 1
2852	  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
2853	    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
2854	      (littleEndian ? i : 1 - i) * 8
2855	  }
2856	}
2857
2858	Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
2859	  value = +value
2860	  offset = offset | 0
2861	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
2862	  if (Buffer.TYPED_ARRAY_SUPPORT) {
2863	    this[offset] = (value & 0xff)
2864	    this[offset + 1] = (value >>> 8)
2865	  } else {
2866	    objectWriteUInt16(this, value, offset, true)
2867	  }
2868	  return offset + 2
2869	}
2870
2871	Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
2872	  value = +value
2873	  offset = offset | 0
2874	  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
2875	  if (Buffer.TYPED_ARRAY_SUPPORT) {
2876	    this[offset] = (value >>> 8)
2877	    this[offset + 1] = (value & 0xff)
2878	  } else {
2879	    objectWriteUInt16(this, value, offset, false)
2880	  }
2881	  return offset + 2
2882	}
2883
2884	function objectWriteUInt32 (buf, value, offset, littleEndian) {
2885	  if (value < 0) value = 0xffffffff + value + 1
2886	  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
2887	    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
2888	  }
2889	}
2890
2891	Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
2892	  value = +value
2893	  offset = offset | 0
2894	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
2895	  if (Buffer.TYPED_ARRAY_SUPPORT) {
2896	    this[offset + 3] = (value >>> 24)
2897	    this[offset + 2] = (value >>> 16)
2898	    this[offset + 1] = (value >>> 8)
2899	    this[offset] = (value & 0xff)
2900	  } else {
2901	    objectWriteUInt32(this, value, offset, true)
2902	  }
2903	  return offset + 4
2904	}
2905
2906	Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
2907	  value = +value
2908	  offset = offset | 0
2909	  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
2910	  if (Buffer.TYPED_ARRAY_SUPPORT) {
2911	    this[offset] = (value >>> 24)
2912	    this[offset + 1] = (value >>> 16)
2913	    this[offset + 2] = (value >>> 8)
2914	    this[offset + 3] = (value & 0xff)
2915	  } else {
2916	    objectWriteUInt32(this, value, offset, false)
2917	  }
2918	  return offset + 4
2919	}
2920
2921	Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
2922	  value = +value
2923	  offset = offset | 0
2924	  if (!noAssert) {
2925	    var limit = Math.pow(2, 8 * byteLength - 1)
2926
2927	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
2928	  }
2929
2930	  var i = 0
2931	  var mul = 1
2932	  var sub = value < 0 ? 1 : 0
2933	  this[offset] = value & 0xFF
2934	  while (++i < byteLength && (mul *= 0x100)) {
2935	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
2936	  }
2937
2938	  return offset + byteLength
2939	}
2940
2941	Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
2942	  value = +value
2943	  offset = offset | 0
2944	  if (!noAssert) {
2945	    var limit = Math.pow(2, 8 * byteLength - 1)
2946
2947	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
2948	  }
2949
2950	  var i = byteLength - 1
2951	  var mul = 1
2952	  var sub = value < 0 ? 1 : 0
2953	  this[offset + i] = value & 0xFF
2954	  while (--i >= 0 && (mul *= 0x100)) {
2955	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
2956	  }
2957
2958	  return offset + byteLength
2959	}
2960
2961	Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
2962	  value = +value
2963	  offset = offset | 0
2964	  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
2965	  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
2966	  if (value < 0) value = 0xff + value + 1
2967	  this[offset] = (value & 0xff)
2968	  return offset + 1
2969	}
2970