https://www.pinglighting.com/modules/blockreassurance/views/dist/front.js

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// define getter function for harmony exports
37/******/ 	__webpack_require__.d = function(exports, name, getter) {
38/******/ 		if(!__webpack_require__.o(exports, name)) {
39/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
40/******/ 		}
41/******/ 	};
42/******/
43/******/ 	// define __esModule on exports
44/******/ 	__webpack_require__.r = function(exports) {
45/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
46/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
47/******/ 		}
48/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
49/******/ 	};
50/******/
51/******/ 	// create a fake namespace object
52/******/ 	// mode & 1: value is a module id, require it
53/******/ 	// mode & 2: merge all properties of value into the ns
54/******/ 	// mode & 4: return value when already ns object
55/******/ 	// mode & 8|1: behave like require
56/******/ 	__webpack_require__.t = function(value, mode) {
57/******/ 		if(mode & 1) value = __webpack_require__(value);
58/******/ 		if(mode & 8) return value;
59/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
60/******/ 		var ns = Object.create(null);
61/******/ 		__webpack_require__.r(ns);
62/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
63/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
64/******/ 		return ns;
65/******/ 	};
66/******/
67/******/ 	// getDefaultExport function for compatibility with non-harmony modules
68/******/ 	__webpack_require__.n = function(module) {
69/******/ 		var getter = module && module.__esModule ?
70/******/ 			function getDefault() { return module['default']; } :
71/******/ 			function getModuleExports() { return module; };
72/******/ 		__webpack_require__.d(getter, 'a', getter);
73/******/ 		return getter;
74/******/ 	};
75/******/
76/******/ 	// Object.prototype.hasOwnProperty.call
77/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
78/******/
79/******/ 	// __webpack_public_path__
80/******/ 	__webpack_require__.p = "";
81/******/
82/******/
83/******/ 	// Load entry module and return exports
84/******/ 	return __webpack_require__(__webpack_require__.s = "./_dev/front/index.js");
85/******/ })
86/************************************************************************/
87/******/ ({
88

203/***/ "./node_modules/style-loader/lib/addStyles.js":
204/*!****************************************************!*\
205  !*** ./node_modules/style-loader/lib/addStyles.js ***!
206  \****************************************************/
207/*! no static exports found */
208/***/ (function(module, exports, __webpack_require__) {
209
210/*
211	MIT License http://www.opensource.org/licenses/mit-license.php
212	Author Tobias Koppers @sokra
213*/
214
215var stylesInDom = {};
216
217var	memoize = function (fn) {
218	var memo;
219
220	return function () {
221		if (typeof memo === "undefined") memo = fn.apply(this, arguments);
222		return memo;
223	};
224};
225
226var isOldIE = memoize(function () {
227	// Test for IE <= 9 as proposed by Browserhacks
228	// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
229	// Tests for existence of standard globals is to allow style-loader
230	// to operate correctly into non-standard environments
231	// @see https://github.com/webpack-contrib/style-loader/issues/177
232	return window && document && document.all && !window.atob;
233});
234
235var getTarget = function (target, parent) {
236  if (parent){
237    return parent.querySelector(target);
238  }
239  return document.querySelector(target);
240};
241
242var getElement = (function (fn) {
243	var memo = {};
244
245	return function(target, parent) {
246                // If passing function in options, then use it for resolve "head" element.
247                // Useful for Shadow Root style i.e
248                // {
249                //   insertInto: function () { return document.querySelector("#foo").shadowRoot }
250                // }
251                if (typeof target === 'function') {
252                        return target();
253                }
254                if (typeof memo[target] === "undefined") {
255			var styleTarget = getTarget.call(this, target, parent);
256			// Special case to return head of iframe instead of iframe itself
257			if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
258				try {
259					// This will throw an exception if access to iframe is blocked
260					// due to cross-origin restrictions
261					styleTarget = styleTarget.contentDocument.head;
262				} catch(e) {
263					styleTarget = null;
264				}
265			}
266			memo[target] = styleTarget;
267		}
268		return memo[target]
269	};
270})();
271
272var singleton = null;
273var	singletonCounter = 0;
274var	stylesInsertedAtTop = [];
275
276var	fixUrls = __webpack_require__(/*! ./urls */ "./node_modules/style-loader/lib/urls.js");
277
278module.exports = function(list, options) {
279	if (typeof DEBUG !== "undefined" && DEBUG) {
280		if (typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
281	}
282
283	options = options || {};
284
285	options.attrs = typeof options.attrs === "object" ? options.attrs : {};
286
287	// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
288	// tags it will allow on a page
289	if (!options.singleton && typeof options.singleton !== "boolean") options.singleton = isOldIE();
290
291	// By default, add <style> tags to the <head> element
292        if (!options.insertInto) options.insertInto = "head";
293
294	// By default, add <style> tags to the bottom of the target
295	if (!options.insertAt) options.insertAt = "bottom";
296
297	var styles = listToStyles(list, options);
298
299	addStylesToDom(styles, options);
300
301	return function update (newList) {
302		var mayRemove = [];
303
304		for (var i = 0; i < styles.length; i++) {
305			var item = styles[i];
306			var domStyle = stylesInDom[item.id];
307
308			domStyle.refs--;
309			mayRemove.push(domStyle);
310		}
311
312		if(newList) {
313			var newStyles = listToStyles(newList, options);
314			addStylesToDom(newStyles, options);
315		}
316
317		for (var i = 0; i < mayRemove.length; i++) {
318			var domStyle = mayRemove[i];
319
320			if(domStyle.refs === 0) {
321				for (var j = 0; j < domStyle.parts.length; j++) domStyle.parts[j]();
322
323				delete stylesInDom[domStyle.id];
324			}
325		}
326	};
327};
328
329function addStylesToDom (styles, options) {
330	for (var i = 0; i < styles.length; i++) {
331		var item = styles[i];
332		var domStyle = stylesInDom[item.id];
333
334		if(domStyle) {
335			domStyle.refs++;
336
337			for(var j = 0; j < domStyle.parts.length; j++) {
338				domStyle.parts[j](item.parts[j]);
339			}
340
341			for(; j < item.parts.length; j++) {
342				domStyle.parts.push(addStyle(item.parts[j], options));
343			}
344		} else {
345			var parts = [];
346
347			for(var j = 0; j < item.parts.length; j++) {
348				parts.push(addStyle(item.parts[j], options));
349			}
350
351			stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
352		}
353	}
354}
355
356function listToStyles (list, options) {
357	var styles = [];
358	var newStyles = {};
359
360	for (var i = 0; i < list.length; i++) {
361		var item = list[i];
362		var id = options.base ? item[0] + options.base : item[0];
363		var css = item[1];
364		var media = item[2];
365		var sourceMap = item[3];
366		var part = {css: css, media: media, sourceMap: sourceMap};
367
368		if(!newStyles[id]) styles.push(newStyles[id] = {id: id, parts: [part]});
369		else newStyles[id].parts.push(part);
370	}
371
372	return styles;
373}
374
375function insertStyleElement (options, style) {
376	var target = getElement(options.insertInto)
377
378	if (!target) {
379		throw new Error("Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid.");
380	}
381
382	var lastStyleElementInsertedAtTop = stylesInsertedAtTop[stylesInsertedAtTop.length - 1];
383
384	if (options.insertAt === "top") {
385		if (!lastStyleElementInsertedAtTop) {
386			target.insertBefore(style, target.firstChild);
387		} else if (lastStyleElementInsertedAtTop.nextSibling) {
388			target.insertBefore(style, lastStyleElementInsertedAtTop.nextSibling);
389		} else {
390			target.appendChild(style);
391		}
392		stylesInsertedAtTop.push(style);
393	} else if (options.insertAt === "bottom") {
394		target.appendChild(style);
395	} else if (typeof options.insertAt === "object" && options.insertAt.before) {
396		var nextSibling = getElement(options.insertAt.before, target);
397		target.insertBefore(style, nextSibling);
398	} else {
399		throw new Error("[Style Loader]\n\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\n Must be 'top', 'bottom', or Object.\n (https://github.com/webpack-contrib/style-loader#insertat)\n");
400	}
401}
402
403function removeStyleElement (style) {
404	if (style.parentNode === null) return false;
405	style.parentNode.removeChild(style);
406
407	var idx = stylesInsertedAtTop.indexOf(style);
408	if(idx >= 0) {
409		stylesInsertedAtTop.splice(idx, 1);
410	}
411}
412
413function createStyleElement (options) {
414	var style = document.createElement("style");
415
416	if(options.attrs.type === undefined) {
417		options.attrs.type = "text/css";
418	}
419
420	if(options.attrs.nonce === undefined) {
421		var nonce = getNonce();
422		if (nonce) {
423			options.attrs.nonce = nonce;
424		}
425	}
426
427	addAttrs(style, options.attrs);
428	insertStyleElement(options, style);
429
430	return style;
431}
432
433function createLinkElement (options) {
434	var link = document.createElement("link");
435
436	if(options.attrs.type === undefined) {
437		options.attrs.type = "text/css";
438	}
439	options.attrs.rel = "stylesheet";
440
441	addAttrs(link, options.attrs);
442	insertStyleElement(options, link);
443
444	return link;
445}
446
447function addAttrs (el, attrs) {
448	Object.keys(attrs).forEach(function (key) {
449		el.setAttribute(key, attrs[key]);
450	});
451}
452
453function getNonce() {
454	if (false) {}
455
456	return __webpack_require__.nc;
457}
458
459function addStyle (obj, options) {
460	var style, update, remove, result;
461
462	// If a transform function was defined, run it on the css
463	if (options.transform && obj.css) {
464	    result = typeof options.transform === 'function'
465		 ? options.transform(obj.css) 
466		 : options.transform.default(obj.css);
467
468	    if (result) {
469	    	// If transform returns a value, use that instead of the original css.
470	    	// This allows running runtime transformations on the css.
471	    	obj.css = result;
472	    } else {
473	    	// If the transform function returns a falsy value, don't add this css.
474	    	// This allows conditional loading of css
475	    	return function() {
476	    		// noop
477	    	};
478	    }
479	}
480
481	if (options.singleton) {
482		var styleIndex = singletonCounter++;
483
484		style = singleton || (singleton = createStyleElement(options));
485
486		update = applyToSingletonTag.bind(null, style, styleIndex, false);
487		remove = applyToSingletonTag.bind(null, style, styleIndex, true);
488
489	} else if (
490		obj.sourceMap &&
491		typeof URL === "function" &&
492		typeof URL.createObjectURL === "function" &&
493		typeof URL.revokeObjectURL === "function" &&
494		typeof Blob === "function" &&
495		typeof btoa === "function"
496	) {
497		style = createLinkElement(options);
498		update = updateLink.bind(null, style, options);
499		remove = function () {
500			removeStyleElement(style);
501
502			if(style.href) URL.revokeObjectURL(style.href);
503		};
504	} else {
505		style = createStyleElement(options);
506		update = applyToTag.bind(null, style);
507		remove = function () {
508			removeStyleElement(style);
509		};
510	}
511
512	update(obj);
513
514	return function updateStyle (newObj) {
515		if (newObj) {
516			if (
517				newObj.css === obj.css &&
518				newObj.media === obj.media &&
519				newObj.sourceMap === obj.sourceMap
520			) {
521				return;
522			}
523
524			update(obj = newObj);
525		} else {
526			remove();
527		}
528	};
529}
530
531var replaceText = (function () {
532	var textStore = [];
533
534	return function (index, replacement) {
535		textStore[index] = replacement;
536
537		return textStore.filter(Boolean).join('\n');
538	};
539})();
540
541function applyToSingletonTag (style, index, remove, obj) {
542	var css = remove ? "" : obj.css;
543
544	if (style.styleSheet) {
545		style.styleSheet.cssText = replaceText(index, css);
546	} else {
547		var cssNode = document.createTextNode(css);
548		var childNodes = style.childNodes;
549
550		if (childNodes[index]) style.removeChild(childNodes[index]);
551
552		if (childNodes.length) {
553			style.insertBefore(cssNode, childNodes[index]);
554		} else {
555			style.appendChild(cssNode);
556		}
557	}
558}
559
560function applyToTag (style, obj) {
561	var css = obj.css;
562	var media = obj.media;
563
564	if(media) {
565		style.setAttribute("media", media)
566	}
567
568	if(style.styleSheet) {
569		style.styleSheet.cssText = css;
570	} else {
571		while(style.firstChild) {
572			style.removeChild(style.firstChild);
573		}
574
575		style.appendChild(document.createTextNode(css));
576	}
577}
578
579function updateLink (link, options, obj) {
580	var css = obj.css;
581	var sourceMap = obj.sourceMap;
582
583	/*
584		If convertToAbsoluteUrls isn't defined, but sourcemaps are enabled
585		and there is no publicPath defined then lets turn convertToAbsoluteUrls
586		on by default.  Otherwise default to the convertToAbsoluteUrls option
587		directly
588	*/
589	var autoFixUrls = options.convertToAbsoluteUrls === undefined && sourceMap;
590
591	if (options.convertToAbsoluteUrls || autoFixUrls) {
592		css = fixUrls(css);
593	}
594
595	if (sourceMap) {
596		// http://stackoverflow.com/a/26603875
597		css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
598	}
599
600	var blob = new Blob([css], { type: "text/css" });
601
602	var oldSrc = link.href;
603
604	link.href = URL.createObjectURL(blob);
605
606	if(oldSrc) URL.revokeObjectURL(oldSrc);
607}
608
609
610/***/ }),
611

612/***/ "./node_modules/style-loader/lib/urls.js":
613/*!***********************************************!*\
614  !*** ./node_modules/style-loader/lib/urls.js ***!
615  \***********************************************/
616/*! no static exports found */
617/***/ (function(module, exports) {
618
619
620/**
621 * When source maps are enabled, `style-loader` uses a link element with a data-uri to
622 * embed the css on the page. This breaks all relative urls because now they are relative to a
623 * bundle instead of the current page.
624 *
625 * One solution is to only use full urls, but that may be impossible.
626 *
627 * Instead, this function "fixes" the relative urls to be absolute according to the current page location.
628 *
629 * A rudimentary test suite is located at `test/fixUrls.js` and can be run via the `npm test` command.
630 *
631 */
632
633module.exports = function (css) {
634  // get current location
635  var location = typeof window !== "undefined" && window.location;
636
637  if (!location) {
638    throw new Error("fixUrls requires window.location");
639  }
640
641	// blank or null?
642	if (!css || typeof css !== "string") {
643	  return css;
644  }
645
646  var baseUrl = location.protocol + "//" + location.host;
647  var currentDir = baseUrl + location.pathname.replace(/\/[^\/]*$/, "/");
648
649	// convert each url(...)
650	/*
651	This regular expression is just a way to recursively match brackets within
652	a string.
653
654	 /url\s*\(  = Match on the word "url" with any whitespace after it and then a parens
655	   (  = Start a capturing group
656	     (?:  = Start a non-capturing group
657	         [^)(]  = Match anything that isn't a parentheses
658	         |  = OR
659	         \(  = Match a start parentheses
660	             (?:  = Start another non-capturing groups
661	                 [^)(]+  = Match anything that isn't a parentheses
662	                 |  = OR
663	                 \(  = Match a start parentheses
664	                     [^)(]*  = Match anything that isn't a parentheses
665	                 \)  = Match a end parentheses
666	             )  = End Group
667              *\) = Match anything and then a close parens
668          )  = Close non-capturing group
669          *  = Match anything
670       )  = Close capturing group
671	 \)  = Match a close parens
672
673	 /gi  = Get all matches, not the first.  Be case insensitive.
674	 */
675	var fixedCss = css.replace(/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi, function(fullMatch, origUrl) {
676		// strip quotes (if they exist)
677		var unquotedOrigUrl = origUrl
678			.trim()
679			.replace(/^"(.*)"$/, function(o, $1){ return $1; })
680			.replace(/^'(.*)'$/, function(o, $1){ return $1; });
681
682		// already a full url? no change
683		if (/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/|\s*$)/i.test(unquotedOrigUrl)) {
684		  return fullMatch;
685		}
686
687		// convert the url to a full url
688		var newUrl;
689
690		if (unquotedOrigUrl.indexOf("//") === 0) {
691		  	//TODO: should we add protocol?
692			newUrl = unquotedOrigUrl;
693		} else if (unquotedOrigUrl.indexOf("/") === 0) {
694			// path should be relative to the base url
695			newUrl = baseUrl + unquotedOrigUrl; // already starts with '/'
696		} else {
697			// path should be relative to current directory
698			newUrl = currentDir + unquotedOrigUrl.replace(/^\.\//, ""); // Strip leading './'
699		}
700
701		// send back the fixed url(...)
702		return "url(" + JSON.stringify(newUrl) + ")";
703	});
704
705	// send back the fixed css
706	return fixedCss;
707};
708
709
710/***/ })