1 /******/ (function() { // webpackBootstrap

     2 /******/ 	var __webpack_modules__ = ({

     3 

     4 /***/ 6411:

     5 /***/ (function(module, exports) {

     6 

     7 var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

     8 	autosize 4.0.4

     9 	license: MIT

    10 	http://www.jacklmoore.com/autosize

    11 */

    12 (function (global, factory) {

    13 	if (true) {

    14 		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),

    15 		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?

    16 		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),

    17 		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

    18 	} else { var mod; }

    19 })(this, function (module, exports) {

    20 	'use strict';

    21 

    22 	var map = typeof Map === "function" ? new Map() : function () {

    23 		var keys = [];

    24 		var values = [];

    25 

    26 		return {

    27 			has: function has(key) {

    28 				return keys.indexOf(key) > -1;

    29 			},

    30 			get: function get(key) {

    31 				return values[keys.indexOf(key)];

    32 			},

    33 			set: function set(key, value) {

    34 				if (keys.indexOf(key) === -1) {

    35 					keys.push(key);

    36 					values.push(value);

    37 				}

    38 			},

    39 			delete: function _delete(key) {

    40 				var index = keys.indexOf(key);

    41 				if (index > -1) {

    42 					keys.splice(index, 1);

    43 					values.splice(index, 1);

    44 				}

    45 			}

    46 		};

    47 	}();

    48 

    49 	var createEvent = function createEvent(name) {

    50 		return new Event(name, { bubbles: true });

    51 	};

    52 	try {

    53 		new Event('test');

    54 	} catch (e) {

    55 		// IE does not support `new Event()`

    56 		createEvent = function createEvent(name) {

    57 			var evt = document.createEvent('Event');

    58 			evt.initEvent(name, true, false);

    59 			return evt;

    60 		};

    61 	}

    62 

    63 	function assign(ta) {

    64 		if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return;

    65 

    66 		var heightOffset = null;

    67 		var clientWidth = null;

    68 		var cachedHeight = null;

    69 

    70 		function init() {

    71 			var style = window.getComputedStyle(ta, null);

    72 

    73 			if (style.resize === 'vertical') {

    74 				ta.style.resize = 'none';

    75 			} else if (style.resize === 'both') {

    76 				ta.style.resize = 'horizontal';

    77 			}

    78 

    79 			if (style.boxSizing === 'content-box') {

    80 				heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));

    81 			} else {

    82 				heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);

    83 			}

    84 			// Fix when a textarea is not on document body and heightOffset is Not a Number

    85 			if (isNaN(heightOffset)) {

    86 				heightOffset = 0;

    87 			}

    88 

    89 			update();

    90 		}

    91 

    92 		function changeOverflow(value) {

    93 			{

    94 				// Chrome/Safari-specific fix:

    95 				// When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space

    96 				// made available by removing the scrollbar. The following forces the necessary text reflow.

    97 				var width = ta.style.width;

    98 				ta.style.width = '0px';

    99 				// Force reflow:

   100 				/* jshint ignore:start */

   101 				ta.offsetWidth;

   102 				/* jshint ignore:end */

   103 				ta.style.width = width;

   104 			}

   105 

   106 			ta.style.overflowY = value;

   107 		}

   108 

   109 		function getParentOverflows(el) {

   110 			var arr = [];

   111 

   112 			while (el && el.parentNode && el.parentNode instanceof Element) {

   113 				if (el.parentNode.scrollTop) {

   114 					arr.push({

   115 						node: el.parentNode,

   116 						scrollTop: el.parentNode.scrollTop

   117 					});

   118 				}

   119 				el = el.parentNode;

   120 			}

   121 

   122 			return arr;

   123 		}

   124 

   125 		function resize() {

   126 			if (ta.scrollHeight === 0) {

   127 				// If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.

   128 				return;

   129 			}

   130 

   131 			var overflows = getParentOverflows(ta);

   132 			var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)

   133 

   134 			ta.style.height = '';

   135 			ta.style.height = ta.scrollHeight + heightOffset + 'px';

   136 

   137 			// used to check if an update is actually necessary on window.resize

   138 			clientWidth = ta.clientWidth;

   139 

   140 			// prevents scroll-position jumping

   141 			overflows.forEach(function (el) {

   142 				el.node.scrollTop = el.scrollTop;

   143 			});

   144 

   145 			if (docTop) {

   146 				document.documentElement.scrollTop = docTop;

   147 			}

   148 		}

   149 

   150 		function update() {

   151 			resize();

   152 

   153 			var styleHeight = Math.round(parseFloat(ta.style.height));

   154 			var computed = window.getComputedStyle(ta, null);

   155 

   156 			// Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box

   157 			var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;

   158 

   159 			// The actual height not matching the style height (set via the resize method) indicates that 

   160 			// the max-height has been exceeded, in which case the overflow should be allowed.

   161 			if (actualHeight < styleHeight) {

   162 				if (computed.overflowY === 'hidden') {

   163 					changeOverflow('scroll');

   164 					resize();

   165 					actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;

   166 				}

   167 			} else {

   168 				// Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.

   169 				if (computed.overflowY !== 'hidden') {

   170 					changeOverflow('hidden');

   171 					resize();

   172 					actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;

   173 				}

   174 			}

   175 

   176 			if (cachedHeight !== actualHeight) {

   177 				cachedHeight = actualHeight;

   178 				var evt = createEvent('autosize:resized');

   179 				try {

   180 					ta.dispatchEvent(evt);

   181 				} catch (err) {

   182 					// Firefox will throw an error on dispatchEvent for a detached element

   183 					// https://bugzilla.mozilla.org/show_bug.cgi?id=889376

   184 				}

   185 			}

   186 		}

   187 

   188 		var pageResize = function pageResize() {

   189 			if (ta.clientWidth !== clientWidth) {

   190 				update();

   191 			}

   192 		};

   193 

   194 		var destroy = function (style) {

   195 			window.removeEventListener('resize', pageResize, false);

   196 			ta.removeEventListener('input', update, false);

   197 			ta.removeEventListener('keyup', update, false);

   198 			ta.removeEventListener('autosize:destroy', destroy, false);

   199 			ta.removeEventListener('autosize:update', update, false);

   200 

   201 			Object.keys(style).forEach(function (key) {

   202 				ta.style[key] = style[key];

   203 			});

   204 

   205 			map.delete(ta);

   206 		}.bind(ta, {

   207 			height: ta.style.height,

   208 			resize: ta.style.resize,

   209 			overflowY: ta.style.overflowY,

   210 			overflowX: ta.style.overflowX,

   211 			wordWrap: ta.style.wordWrap

   212 		});

   213 

   214 		ta.addEventListener('autosize:destroy', destroy, false);

   215 

   216 		// IE9 does not fire onpropertychange or oninput for deletions,

   217 		// so binding to onkeyup to catch most of those events.

   218 		// There is no way that I know of to detect something like 'cut' in IE9.

   219 		if ('onpropertychange' in ta && 'oninput' in ta) {

   220 			ta.addEventListener('keyup', update, false);

   221 		}

   222 

   223 		window.addEventListener('resize', pageResize, false);

   224 		ta.addEventListener('input', update, false);

   225 		ta.addEventListener('autosize:update', update, false);

   226 		ta.style.overflowX = 'hidden';

   227 		ta.style.wordWrap = 'break-word';

   228 

   229 		map.set(ta, {

   230 			destroy: destroy,

   231 			update: update

   232 		});

   233 

   234 		init();

   235 	}

   236 

   237 	function destroy(ta) {

   238 		var methods = map.get(ta);

   239 		if (methods) {

   240 			methods.destroy();

   241 		}

   242 	}

   243 

   244 	function update(ta) {

   245 		var methods = map.get(ta);

   246 		if (methods) {

   247 			methods.update();

   248 		}

   249 	}

   250 

   251 	var autosize = null;

   252 

   253 	// Do nothing in Node.js environment and IE8 (or lower)

   254 	if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {

   255 		autosize = function autosize(el) {

   256 			return el;

   257 		};

   258 		autosize.destroy = function (el) {

   259 			return el;

   260 		};

   261 		autosize.update = function (el) {

   262 			return el;

   263 		};

   264 	} else {

   265 		autosize = function autosize(el, options) {

   266 			if (el) {

   267 				Array.prototype.forEach.call(el.length ? el : [el], function (x) {

   268 					return assign(x, options);

   269 				});

   270 			}

   271 			return el;

   272 		};

   273 		autosize.destroy = function (el) {

   274 			if (el) {

   275 				Array.prototype.forEach.call(el.length ? el : [el], destroy);

   276 			}

   277 			return el;

   278 		};

   279 		autosize.update = function (el) {

   280 			if (el) {

   281 				Array.prototype.forEach.call(el.length ? el : [el], update);

   282 			}

   283 			return el;

   284 		};

   285 	}

   286 

   287 	exports.default = autosize;

   288 	module.exports = exports['default'];

   289 });

   290 

   291 /***/ }),

   292 

   293 /***/ 4403:

   294 /***/ (function(module, exports) {

   295 

   296 var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

   297   Copyright (c) 2018 Jed Watson.

   298   Licensed under the MIT License (MIT), see

   299   http://jedwatson.github.io/classnames

   300 */

   301 /* global define */

   302 

   303 (function () {

   304 	'use strict';

   305 

   306 	var hasOwn = {}.hasOwnProperty;

   307 

   308 	function classNames() {

   309 		var classes = [];

   310 

   311 		for (var i = 0; i < arguments.length; i++) {

   312 			var arg = arguments[i];

   313 			if (!arg) continue;

   314 

   315 			var argType = typeof arg;

   316 

   317 			if (argType === 'string' || argType === 'number') {

   318 				classes.push(arg);

   319 			} else if (Array.isArray(arg)) {

   320 				if (arg.length) {

   321 					var inner = classNames.apply(null, arg);

   322 					if (inner) {

   323 						classes.push(inner);

   324 					}

   325 				}

   326 			} else if (argType === 'object') {

   327 				if (arg.toString === Object.prototype.toString) {

   328 					for (var key in arg) {

   329 						if (hasOwn.call(arg, key) && arg[key]) {

   330 							classes.push(key);

   331 						}

   332 					}

   333 				} else {

   334 					classes.push(arg.toString());

   335 				}

   336 			}

   337 		}

   338 

   339 		return classes.join(' ');

   340 	}

   341 

   342 	if ( true && module.exports) {

   343 		classNames.default = classNames;

   344 		module.exports = classNames;

   345 	} else if (true) {

   346 		// register as 'classnames', consistent with npm package name

   347 		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {

   348 			return classNames;

   349 		}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),

   350 		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

   351 	} else {}

   352 }());

   353 

   354 

   355 /***/ }),

   356 

   357 /***/ 4827:

   358 /***/ (function(module) {

   359 

   360 // This code has been refactored for 140 bytes

   361 // You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js

   362 var computedStyle = function (el, prop, getComputedStyle) {

   363   getComputedStyle = window.getComputedStyle;

   364 

   365   // In one fell swoop

   366   return (

   367     // If we have getComputedStyle

   368     getComputedStyle ?

   369       // Query it

   370       // TODO: From CSS-Query notes, we might need (node, null) for FF

   371       getComputedStyle(el) :

   372 

   373     // Otherwise, we are in IE and use currentStyle

   374       el.currentStyle

   375   )[

   376     // Switch to camelCase for CSSOM

   377     // DEV: Grabbed from jQuery

   378     // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194

   379     // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597

   380     prop.replace(/-(\w)/gi, function (word, letter) {

   381       return letter.toUpperCase();

   382     })

   383   ];

   384 };

   385 

   386 module.exports = computedStyle;

   387 

   388 

   389 /***/ }),

   390 

   391 /***/ 8981:

   392 /***/ (function(module, exports) {

   393 

   394 var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//download.js v4.2, by dandavis; 2008-2016. [MIT] see http://danml.com/download.html for tests/usage

   395 // v1 landed a FF+Chrome compat way of downloading strings to local un-named files, upgraded to use a hidden frame and optional mime

   396 // v2 added named files via a[download], msSaveBlob, IE (10+) support, and window.URL support for larger+faster saves than dataURLs

   397 // v3 added dataURL and Blob Input, bind-toggle arity, and legacy dataURL fallback was improved with force-download mime and base64 support. 3.1 improved safari handling.

   398 // v4 adds AMD/UMD, commonJS, and plain browser support

   399 // v4.1 adds url download capability via solo URL argument (same domain/CORS only)

   400 // v4.2 adds semantic variable names, long (over 2MB) dataURL support, and hidden by default temp anchors

   401 // https://github.com/rndme/download

   402 

   403 (function (root, factory) {

   404 	if (true) {

   405 		// AMD. Register as an anonymous module.

   406 		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),

   407 		__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?

   408 		(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),

   409 		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

   410 	} else {}

   411 }(this, function () {

   412 

   413 	return function download(data, strFileName, strMimeType) {

   414 

   415 		var self = window, // this script is only for browsers anyway...

   416 			defaultMime = "application/octet-stream", // this default mime also triggers iframe downloads

   417 			mimeType = strMimeType || defaultMime,

   418 			payload = data,

   419 			url = !strFileName && !strMimeType && payload,

   420 			anchor = document.createElement("a"),

   421 			toString = function(a){return String(a);},

   422 			myBlob = (self.Blob || self.MozBlob || self.WebKitBlob || toString),

   423 			fileName = strFileName || "download",

   424 			blob,

   425 			reader;

   426 			myBlob= myBlob.call ? myBlob.bind(self) : Blob ;

   427 	  

   428 		if(String(this)==="true"){ //reverse arguments, allowing download.bind(true, "text/xml", "export.xml") to act as a callback

   429 			payload=[payload, mimeType];

   430 			mimeType=payload[0];

   431 			payload=payload[1];

   432 		}

   433 

   434 

   435 		if(url && url.length< 2048){ // if no filename and no mime, assume a url was passed as the only argument

   436 			fileName = url.split("/").pop().split("?")[0];

   437 			anchor.href = url; // assign href prop to temp anchor

   438 		  	if(anchor.href.indexOf(url) !== -1){ // if the browser determines that it's a potentially valid url path:

   439         		var ajax=new XMLHttpRequest();

   440         		ajax.open( "GET", url, true);

   441         		ajax.responseType = 'blob';

   442         		ajax.onload= function(e){ 

   443 				  download(e.target.response, fileName, defaultMime);

   444 				};

   445         		setTimeout(function(){ ajax.send();}, 0); // allows setting custom ajax headers using the return:

   446 			    return ajax;

   447 			} // end if valid url?

   448 		} // end if url?

   449 

   450 

   451 		//go ahead and download dataURLs right away

   452 		if(/^data:([\w+-]+\/[\w+.-]+)?[,;]/.test(payload)){

   453 		

   454 			if(payload.length > (1024*1024*1.999) && myBlob !== toString ){

   455 				payload=dataUrlToBlob(payload);

   456 				mimeType=payload.type || defaultMime;

   457 			}else{			

   458 				return navigator.msSaveBlob ?  // IE10 can't do a[download], only Blobs:

   459 					navigator.msSaveBlob(dataUrlToBlob(payload), fileName) :

   460 					saver(payload) ; // everyone else can save dataURLs un-processed

   461 			}

   462 			

   463 		}else{//not data url, is it a string with special needs?

   464 			if(/([\x80-\xff])/.test(payload)){			  

   465 				var i=0, tempUiArr= new Uint8Array(payload.length), mx=tempUiArr.length;

   466 				for(i;i<mx;++i) tempUiArr[i]= payload.charCodeAt(i);

   467 			 	payload=new myBlob([tempUiArr], {type: mimeType});

   468 			}		  

   469 		}

   470 		blob = payload instanceof myBlob ?

   471 			payload :

   472 			new myBlob([payload], {type: mimeType}) ;

   473 

   474 

   475 		function dataUrlToBlob(strUrl) {

   476 			var parts= strUrl.split(/[:;,]/),

   477 			type= parts[1],

   478 			decoder= parts[2] == "base64" ? atob : decodeURIComponent,

   479 			binData= decoder( parts.pop() ),

   480 			mx= binData.length,

   481 			i= 0,

   482 			uiArr= new Uint8Array(mx);

   483 

   484 			for(i;i<mx;++i) uiArr[i]= binData.charCodeAt(i);

   485 

   486 			return new myBlob([uiArr], {type: type});

   487 		 }

   488 

   489 		function saver(url, winMode){

   490 

   491 			if ('download' in anchor) { //html5 A[download]

   492 				anchor.href = url;

   493 				anchor.setAttribute("download", fileName);

   494 				anchor.className = "download-js-link";

   495 				anchor.innerHTML = "downloading...";

   496 				anchor.style.display = "none";

   497 				document.body.appendChild(anchor);

   498 				setTimeout(function() {

   499 					anchor.click();

   500 					document.body.removeChild(anchor);

   501 					if(winMode===true){setTimeout(function(){ self.URL.revokeObjectURL(anchor.href);}, 250 );}

   502 				}, 66);

   503 				return true;

   504 			}

   505 

   506 			// handle non-a[download] safari as best we can:

   507 			if(/(Version)\/(\d+)\.(\d+)(?:\.(\d+))?.*Safari\//.test(navigator.userAgent)) {

   508 				if(/^data:/.test(url))	url="data:"+url.replace(/^data:([\w\/\-\+]+)/, defaultMime);

   509 				if(!window.open(url)){ // popup blocked, offer direct download:

   510 					if(confirm("Displaying New Document\n\nUse Save As... to download, then click back to return to this page.")){ location.href=url; }

   511 				}

   512 				return true;

   513 			}

   514 

   515 			//do iframe dataURL download (old ch+FF):

   516 			var f = document.createElement("iframe");

   517 			document.body.appendChild(f);

   518 

   519 			if(!winMode && /^data:/.test(url)){ // force a mime that will download:

   520 				url="data:"+url.replace(/^data:([\w\/\-\+]+)/, defaultMime);

   521 			}

   522 			f.src=url;

   523 			setTimeout(function(){ document.body.removeChild(f); }, 333);

   524 

   525 		}//end saver

   526 

   527 

   528 

   529 

   530 		if (navigator.msSaveBlob) { // IE10+ : (has Blob, but not a[download] or URL)

   531 			return navigator.msSaveBlob(blob, fileName);

   532 		}

   533 

   534 		if(self.URL){ // simple fast and modern way using Blob and URL:

   535 			saver(self.URL.createObjectURL(blob), true);

   536 		}else{

   537 			// handle non-Blob()+non-URL browsers:

   538 			if(typeof blob === "string" || blob.constructor===toString ){

   539 				try{

   540 					return saver( "data:" +  mimeType   + ";base64,"  +  self.btoa(blob)  );

   541 				}catch(y){

   542 					return saver( "data:" +  mimeType   + "," + encodeURIComponent(blob)  );

   543 				}

   544 			}

   545 

   546 			// Blob but not URL support:

   547 			reader=new FileReader();

   548 			reader.onload=function(e){

   549 				saver(this.result);

   550 			};

   551 			reader.readAsDataURL(blob);

   552 		}

   553 		return true;

   554 	}; /* end download() */

   555 }));

   556 

   557 

   558 /***/ }),

   559 

   560 /***/ 9894:

   561 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {

   562 

   563 // Load in dependencies

   564 var computedStyle = __webpack_require__(4827);

   565 

   566 /**

   567  * Calculate the `line-height` of a given node

   568  * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM.

   569  * @returns {Number} `line-height` of the element in pixels

   570  */

   571 function lineHeight(node) {

   572   // Grab the line-height via style

   573   var lnHeightStr = computedStyle(node, 'line-height');

   574   var lnHeight = parseFloat(lnHeightStr, 10);

   575 

   576   // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em')

   577   if (lnHeightStr === lnHeight + '') {

   578     // Save the old lineHeight style and update the em unit to the element

   579     var _lnHeightStyle = node.style.lineHeight;

   580     node.style.lineHeight = lnHeightStr + 'em';

   581 

   582     // Calculate the em based height

   583     lnHeightStr = computedStyle(node, 'line-height');

   584     lnHeight = parseFloat(lnHeightStr, 10);

   585 

   586     // Revert the lineHeight style

   587     if (_lnHeightStyle) {

   588       node.style.lineHeight = _lnHeightStyle;

   589     } else {

   590       delete node.style.lineHeight;

   591     }

   592   }

   593 

   594   // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt)

   595   // DEV: `em` units are converted to `pt` in IE6

   596   // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length

   597   if (lnHeightStr.indexOf('pt') !== -1) {

   598     lnHeight *= 4;

   599     lnHeight /= 3;

   600   // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm)

   601   } else if (lnHeightStr.indexOf('mm') !== -1) {

   602     lnHeight *= 96;

   603     lnHeight /= 25.4;

   604   // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm)

   605   } else if (lnHeightStr.indexOf('cm') !== -1) {

   606     lnHeight *= 96;

   607     lnHeight /= 2.54;

   608   // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in)

   609   } else if (lnHeightStr.indexOf('in') !== -1) {

   610     lnHeight *= 96;

   611   // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc)

   612   } else if (lnHeightStr.indexOf('pc') !== -1) {

   613     lnHeight *= 16;

   614   }

   615 

   616   // Continue our computation

   617   lnHeight = Math.round(lnHeight);

   618 

   619   // If the line-height is "normal", calculate by font-size

   620   if (lnHeightStr === 'normal') {

   621     // Create a temporary node

   622     var nodeName = node.nodeName;

   623     var _node = document.createElement(nodeName);

   624     _node.innerHTML = ' ';

   625 

   626     // If we have a text area, reset it to only 1 row

   627     // https://github.com/twolfson/line-height/issues/4

   628     if (nodeName.toUpperCase() === 'TEXTAREA') {

   629       _node.setAttribute('rows', '1');

   630     }

   631 

   632     // Set the font-size of the element

   633     var fontSizeStr = computedStyle(node, 'font-size');

   634     _node.style.fontSize = fontSizeStr;

   635 

   636     // Remove default padding/border which can affect offset height

   637     // https://github.com/twolfson/line-height/issues/4

   638     // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight

   639     _node.style.padding = '0px';

   640     _node.style.border = '0px';

   641 

   642     // Append it to the body

   643     var body = document.body;

   644     body.appendChild(_node);

   645 

   646     // Assume the line height of the element is the height

   647     var height = _node.offsetHeight;

   648     lnHeight = height;

   649 

   650     // Remove our child from the DOM

   651     body.removeChild(_node);

   652   }

   653 

   654   // Return the calculated height

   655   return lnHeight;

   656 }

   657 

   658 // Export lineHeight

   659 module.exports = lineHeight;

   660 

   661 

   662 /***/ }),

   663 

   664 /***/ 5372:

   665 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {

   666 

   667 "use strict";

   668 /**

   669  * Copyright (c) 2013-present, Facebook, Inc.

   670  *

   671  * This source code is licensed under the MIT license found in the

   672  * LICENSE file in the root directory of this source tree.

   673  */

   674 

   675 

   676 

   677 var ReactPropTypesSecret = __webpack_require__(9567);

   678 

   679 function emptyFunction() {}

   680 function emptyFunctionWithReset() {}

   681 emptyFunctionWithReset.resetWarningCache = emptyFunction;

   682 

   683 module.exports = function() {

   684   function shim(props, propName, componentName, location, propFullName, secret) {

   685     if (secret === ReactPropTypesSecret) {

   686       // It is still safe when called from React.

   687       return;

   688     }

   689     var err = new Error(

   690       'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +

   691       'Use PropTypes.checkPropTypes() to call them. ' +

   692       'Read more at http://fb.me/use-check-prop-types'

   693     );

   694     err.name = 'Invariant Violation';

   695     throw err;

   696   };

   697   shim.isRequired = shim;

   698   function getShim() {

   699     return shim;

   700   };

   701   // Important!

   702   // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.

   703   var ReactPropTypes = {

   704     array: shim,

   705     bigint: shim,

   706     bool: shim,

   707     func: shim,

   708     number: shim,

   709     object: shim,

   710     string: shim,

   711     symbol: shim,

   712 

   713     any: shim,

   714     arrayOf: getShim,

   715     element: shim,

   716     elementType: shim,

   717     instanceOf: getShim,

   718     node: shim,

   719     objectOf: getShim,

   720     oneOf: getShim,

   721     oneOfType: getShim,

   722     shape: getShim,

   723     exact: getShim,

   724 

   725     checkPropTypes: emptyFunctionWithReset,

   726     resetWarningCache: emptyFunction

   727   };

   728 

   729   ReactPropTypes.PropTypes = ReactPropTypes;

   730 

   731   return ReactPropTypes;

   732 };

   733 

   734 

   735 /***/ }),

   736 

   737 /***/ 2652:

   738 /***/ (function(module, __unused_webpack_exports, __webpack_require__) {

   739 

   740 /**

   741  * Copyright (c) 2013-present, Facebook, Inc.

   742  *

   743  * This source code is licensed under the MIT license found in the

   744  * LICENSE file in the root directory of this source tree.

   745  */

   746 

   747 if (false) { var throwOnDirectAccess, ReactIs; } else {

   748   // By explicitly using `prop-types` you are opting into new production behavior.

   749   // http://fb.me/prop-types-in-prod

   750   module.exports = __webpack_require__(5372)();

   751 }

   752 

   753 

   754 /***/ }),

   755 

   756 /***/ 9567:

   757 /***/ (function(module) {

   758 

   759 "use strict";

   760 /**

   761  * Copyright (c) 2013-present, Facebook, Inc.

   762  *

   763  * This source code is licensed under the MIT license found in the

   764  * LICENSE file in the root directory of this source tree.

   765  */

   766 

   767 

   768 

   769 var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

   770 

   771 module.exports = ReactPropTypesSecret;

   772 

   773 

   774 /***/ }),

   775 

   776 /***/ 5438:

   777 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {

   778 

   779 "use strict";

   780 

   781 var __extends = (this && this.__extends) || (function () {

   782     var extendStatics = Object.setPrototypeOf ||

   783         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||

   784         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

   785     return function (d, b) {

   786         extendStatics(d, b);

   787         function __() { this.constructor = d; }

   788         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

   789     };

   790 })();

   791 var __assign = (this && this.__assign) || Object.assign || function(t) {

   792     for (var s, i = 1, n = arguments.length; i < n; i++) {

   793         s = arguments[i];

   794         for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))

   795             t[p] = s[p];

   796     }

   797     return t;

   798 };

   799 var __rest = (this && this.__rest) || function (s, e) {

   800     var t = {};

   801     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)

   802         t[p] = s[p];

   803     if (s != null && typeof Object.getOwnPropertySymbols === "function")

   804         for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)

   805             t[p[i]] = s[p[i]];

   806     return t;

   807 };

   808 exports.__esModule = true;

   809 var React = __webpack_require__(9196);

   810 var PropTypes = __webpack_require__(2652);

   811 var autosize = __webpack_require__(6411);

   812 var _getLineHeight = __webpack_require__(9894);

   813 var getLineHeight = _getLineHeight;

   814 var RESIZED = "autosize:resized";

   815 /**

   816  * A light replacement for built-in textarea component

   817  * which automaticaly adjusts its height to match the content

   818  */

   819 var TextareaAutosizeClass = /** @class */ (function (_super) {

   820     __extends(TextareaAutosizeClass, _super);

   821     function TextareaAutosizeClass() {

   822         var _this = _super !== null && _super.apply(this, arguments) || this;

   823         _this.state = {

   824             lineHeight: null

   825         };

   826         _this.textarea = null;

   827         _this.onResize = function (e) {

   828             if (_this.props.onResize) {

   829                 _this.props.onResize(e);

   830             }

   831         };

   832         _this.updateLineHeight = function () {

   833             if (_this.textarea) {

   834                 _this.setState({

   835                     lineHeight: getLineHeight(_this.textarea)

   836                 });

   837             }

   838         };

   839         _this.onChange = function (e) {

   840             var onChange = _this.props.onChange;

   841             _this.currentValue = e.currentTarget.value;

   842             onChange && onChange(e);

   843         };

   844         return _this;

   845     }

   846     TextareaAutosizeClass.prototype.componentDidMount = function () {

   847         var _this = this;

   848         var _a = this.props, maxRows = _a.maxRows, async = _a.async;

   849         if (typeof maxRows === "number") {

   850             this.updateLineHeight();

   851         }

   852         if (typeof maxRows === "number" || async) {

   853             /*

   854               the defer is needed to:

   855                 - force "autosize" to activate the scrollbar when this.props.maxRows is passed

   856                 - support StyledComponents (see #71)

   857             */

   858             setTimeout(function () { return _this.textarea && autosize(_this.textarea); });

   859         }

   860         else {

   861             this.textarea && autosize(this.textarea);

   862         }

   863         if (this.textarea) {

   864             this.textarea.addEventListener(RESIZED, this.onResize);

   865         }

   866     };

   867     TextareaAutosizeClass.prototype.componentWillUnmount = function () {

   868         if (this.textarea) {

   869             this.textarea.removeEventListener(RESIZED, this.onResize);

   870             autosize.destroy(this.textarea);

   871         }

   872     };

   873     TextareaAutosizeClass.prototype.render = function () {

   874         var _this = this;

   875         var _a = this, _b = _a.props, onResize = _b.onResize, maxRows = _b.maxRows, onChange = _b.onChange, style = _b.style, innerRef = _b.innerRef, children = _b.children, props = __rest(_b, ["onResize", "maxRows", "onChange", "style", "innerRef", "children"]), lineHeight = _a.state.lineHeight;

   876         var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null;

   877         return (React.createElement("textarea", __assign({}, props, { onChange: this.onChange, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, ref: function (element) {

   878                 _this.textarea = element;

   879                 if (typeof _this.props.innerRef === 'function') {

   880                     _this.props.innerRef(element);

   881                 }

   882                 else if (_this.props.innerRef) {

   883                     _this.props.innerRef.current = element;

   884                 }

   885             } }), children));

   886     };

   887     TextareaAutosizeClass.prototype.componentDidUpdate = function () {

   888         this.textarea && autosize.update(this.textarea);

   889     };

   890     TextareaAutosizeClass.defaultProps = {

   891         rows: 1,

   892         async: false

   893     };

   894     TextareaAutosizeClass.propTypes = {

   895         rows: PropTypes.number,

   896         maxRows: PropTypes.number,

   897         onResize: PropTypes.func,

   898         innerRef: PropTypes.any,

   899         async: PropTypes.bool

   900     };

   901     return TextareaAutosizeClass;

   902 }(React.Component));

   903 exports.TextareaAutosize = React.forwardRef(function (props, ref) {

   904     return React.createElement(TextareaAutosizeClass, __assign({}, props, { innerRef: ref }));

   905 });

   906 

   907 

   908 /***/ }),

   909 

   910 /***/ 773:

   911 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {

   912 

   913 "use strict";

   914 var __webpack_unused_export__;

   915 

   916 __webpack_unused_export__ = true;

   917 var TextareaAutosize_1 = __webpack_require__(5438);

   918 exports.Z = TextareaAutosize_1.TextareaAutosize;

   919 

   920 

   921 /***/ }),

   922 

   923 /***/ 9196:

   924 /***/ (function(module) {

   925 

   926 "use strict";

   927 module.exports = window["React"];

   928 

   929 /***/ })

   930 

   931 /******/ 	});

   932 /************************************************************************/

   933 /******/ 	// The module cache

   934 /******/ 	var __webpack_module_cache__ = {};

   935 /******/ 	

   936 /******/ 	// The require function

   937 /******/ 	function __webpack_require__(moduleId) {

   938 /******/ 		// Check if module is in cache

   939 /******/ 		var cachedModule = __webpack_module_cache__[moduleId];

   940 /******/ 		if (cachedModule !== undefined) {

   941 /******/ 			return cachedModule.exports;

   942 /******/ 		}

   943 /******/ 		// Create a new module (and put it into the cache)

   944 /******/ 		var module = __webpack_module_cache__[moduleId] = {

   945 /******/ 			// no module.id needed

   946 /******/ 			// no module.loaded needed

   947 /******/ 			exports: {}

   948 /******/ 		};

   949 /******/ 	

   950 /******/ 		// Execute the module function

   951 /******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);

   952 /******/ 	

   953 /******/ 		// Return the exports of the module

   954 /******/ 		return module.exports;

   955 /******/ 	}

   956 /******/ 	

   957 /************************************************************************/

   958 /******/ 	/* webpack/runtime/compat get default export */

   959 /******/ 	!function() {

   960 /******/ 		// getDefaultExport function for compatibility with non-harmony modules

   961 /******/ 		__webpack_require__.n = function(module) {

   962 /******/ 			var getter = module && module.__esModule ?

   963 /******/ 				function() { return module['default']; } :

   964 /******/ 				function() { return module; };

   965 /******/ 			__webpack_require__.d(getter, { a: getter });

   966 /******/ 			return getter;

   967 /******/ 		};

   968 /******/ 	}();

   969 /******/ 	

   970 /******/ 	/* webpack/runtime/define property getters */

   971 /******/ 	!function() {

   972 /******/ 		// define getter functions for harmony exports

   973 /******/ 		__webpack_require__.d = function(exports, definition) {

   974 /******/ 			for(var key in definition) {

   975 /******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {

   976 /******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });

   977 /******/ 				}

   978 /******/ 			}

   979 /******/ 		};

   980 /******/ 	}();

   981 /******/ 	

   982 /******/ 	/* webpack/runtime/hasOwnProperty shorthand */

   983 /******/ 	!function() {

   984 /******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }

   985 /******/ 	}();

   986 /******/ 	

   987 /******/ 	/* webpack/runtime/make namespace object */

   988 /******/ 	!function() {

   989 /******/ 		// define __esModule on exports

   990 /******/ 		__webpack_require__.r = function(exports) {

   991 /******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

   992 /******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

   993 /******/ 			}

   994 /******/ 			Object.defineProperty(exports, '__esModule', { value: true });

   995 /******/ 		};

   996 /******/ 	}();

   997 /******/ 	

   998 /************************************************************************/

   999 var __webpack_exports__ = {};

  1000 // This entry need to be wrapped in an IIFE because it need to be in strict mode.

  1001 !function() {

  1002 "use strict";

  1003 // ESM COMPAT FLAG

  1004 __webpack_require__.r(__webpack_exports__);

  1005 

  1006 // EXPORTS

  1007 __webpack_require__.d(__webpack_exports__, {

  1008   "PluginMoreMenuItem": function() { return /* reexport */ plugin_more_menu_item; },

  1009   "PluginSidebar": function() { return /* reexport */ PluginSidebarEditSite; },

  1010   "PluginSidebarMoreMenuItem": function() { return /* reexport */ PluginSidebarMoreMenuItem; },

  1011   "__experimentalMainDashboardButton": function() { return /* reexport */ main_dashboard_button; },

  1012   "__experimentalNavigationToggle": function() { return /* reexport */ navigation_toggle; },

  1013   "initializeEditor": function() { return /* binding */ initializeEditor; },

  1014   "reinitializeEditor": function() { return /* binding */ reinitializeEditor; }

  1015 });

  1016 

  1017 // NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/actions.js

  1018 var actions_namespaceObject = {};

  1019 __webpack_require__.r(actions_namespaceObject);

  1020 __webpack_require__.d(actions_namespaceObject, {

  1021   "disableComplementaryArea": function() { return disableComplementaryArea; },

  1022   "enableComplementaryArea": function() { return enableComplementaryArea; },

  1023   "pinItem": function() { return pinItem; },

  1024   "setFeatureDefaults": function() { return setFeatureDefaults; },

  1025   "setFeatureValue": function() { return setFeatureValue; },

  1026   "toggleFeature": function() { return toggleFeature; },

  1027   "unpinItem": function() { return unpinItem; }

  1028 });

  1029 

  1030 // NAMESPACE OBJECT: ./node_modules/@wordpress/interface/build-module/store/selectors.js

  1031 var selectors_namespaceObject = {};

  1032 __webpack_require__.r(selectors_namespaceObject);

  1033 __webpack_require__.d(selectors_namespaceObject, {

  1034   "getActiveComplementaryArea": function() { return getActiveComplementaryArea; },

  1035   "isFeatureActive": function() { return isFeatureActive; },

  1036   "isItemPinned": function() { return isItemPinned; }

  1037 });

  1038 

  1039 // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/actions.js

  1040 var store_actions_namespaceObject = {};

  1041 __webpack_require__.r(store_actions_namespaceObject);

  1042 __webpack_require__.d(store_actions_namespaceObject, {

  1043   "__experimentalSetPreviewDeviceType": function() { return __experimentalSetPreviewDeviceType; },

  1044   "addTemplate": function() { return addTemplate; },

  1045   "closeGeneralSidebar": function() { return closeGeneralSidebar; },

  1046   "openGeneralSidebar": function() { return openGeneralSidebar; },

  1047   "openNavigationPanelToMenu": function() { return openNavigationPanelToMenu; },

  1048   "removeTemplate": function() { return removeTemplate; },

  1049   "revertTemplate": function() { return revertTemplate; },

  1050   "setHomeTemplateId": function() { return setHomeTemplateId; },

  1051   "setIsInserterOpened": function() { return setIsInserterOpened; },

  1052   "setIsListViewOpened": function() { return setIsListViewOpened; },

  1053   "setIsNavigationPanelOpened": function() { return setIsNavigationPanelOpened; },

  1054   "setNavigationPanelActiveMenu": function() { return setNavigationPanelActiveMenu; },

  1055   "setPage": function() { return setPage; },

  1056   "setTemplate": function() { return setTemplate; },

  1057   "setTemplatePart": function() { return setTemplatePart; },

  1058   "switchEditorMode": function() { return switchEditorMode; },

  1059   "toggleFeature": function() { return actions_toggleFeature; },

  1060   "updateSettings": function() { return updateSettings; }

  1061 });

  1062 

  1063 // NAMESPACE OBJECT: ./node_modules/@wordpress/edit-site/build-module/store/selectors.js

  1064 var store_selectors_namespaceObject = {};

  1065 __webpack_require__.r(store_selectors_namespaceObject);

  1066 __webpack_require__.d(store_selectors_namespaceObject, {

  1067   "__experimentalGetInsertionPoint": function() { return __experimentalGetInsertionPoint; },

  1068   "__experimentalGetPreviewDeviceType": function() { return __experimentalGetPreviewDeviceType; },

  1069   "__unstableGetPreference": function() { return __unstableGetPreference; },

  1070   "getCanUserCreateMedia": function() { return getCanUserCreateMedia; },

  1071   "getCurrentTemplateNavigationPanelSubMenu": function() { return getCurrentTemplateNavigationPanelSubMenu; },

  1072   "getCurrentTemplateTemplateParts": function() { return getCurrentTemplateTemplateParts; },

  1073   "getEditedPostId": function() { return getEditedPostId; },

  1074   "getEditedPostType": function() { return getEditedPostType; },

  1075   "getEditorMode": function() { return getEditorMode; },

  1076   "getHomeTemplateId": function() { return getHomeTemplateId; },

  1077   "getNavigationPanelActiveMenu": function() { return getNavigationPanelActiveMenu; },

  1078   "getPage": function() { return getPage; },

  1079   "getReusableBlocks": function() { return getReusableBlocks; },

  1080   "getSettings": function() { return getSettings; },

  1081   "isFeatureActive": function() { return selectors_isFeatureActive; },

  1082   "isInserterOpened": function() { return isInserterOpened; },

  1083   "isListViewOpened": function() { return isListViewOpened; },

  1084   "isNavigationOpened": function() { return isNavigationOpened; }

  1085 });

  1086 

  1087 ;// CONCATENATED MODULE: external ["wp","element"]

  1088 var external_wp_element_namespaceObject = window["wp"]["element"];

  1089 ;// CONCATENATED MODULE: external ["wp","blocks"]

  1090 var external_wp_blocks_namespaceObject = window["wp"]["blocks"];

  1091 ;// CONCATENATED MODULE: external ["wp","blockLibrary"]

  1092 var external_wp_blockLibrary_namespaceObject = window["wp"]["blockLibrary"];

  1093 ;// CONCATENATED MODULE: external ["wp","data"]

  1094 var external_wp_data_namespaceObject = window["wp"]["data"];

  1095 ;// CONCATENATED MODULE: external ["wp","coreData"]

  1096 var external_wp_coreData_namespaceObject = window["wp"]["coreData"];

  1097 ;// CONCATENATED MODULE: external ["wp","editor"]

  1098 var external_wp_editor_namespaceObject = window["wp"]["editor"];

  1099 ;// CONCATENATED MODULE: external ["wp","preferences"]

  1100 var external_wp_preferences_namespaceObject = window["wp"]["preferences"];

  1101 ;// CONCATENATED MODULE: external ["wp","i18n"]

  1102 var external_wp_i18n_namespaceObject = window["wp"]["i18n"];

  1103 ;// CONCATENATED MODULE: external ["wp","viewport"]

  1104 var external_wp_viewport_namespaceObject = window["wp"]["viewport"];

  1105 ;// CONCATENATED MODULE: external ["wp","url"]

  1106 var external_wp_url_namespaceObject = window["wp"]["url"];

  1107 ;// CONCATENATED MODULE: external ["wp","hooks"]

  1108 var external_wp_hooks_namespaceObject = window["wp"]["hooks"];

  1109 ;// CONCATENATED MODULE: external ["wp","mediaUtils"]

  1110 var external_wp_mediaUtils_namespaceObject = window["wp"]["mediaUtils"];

  1111 ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/hooks/components.js

  1112 /**

  1113  * WordPress dependencies

  1114  */

  1115 

  1116 

  1117 (0,external_wp_hooks_namespaceObject.addFilter)('editor.MediaUpload', 'core/edit-site/components/media-upload', () => external_wp_mediaUtils_namespaceObject.MediaUpload);

  1118 

  1119 ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/hooks/index.js

  1120 /**

  1121  * Internal dependencies

  1122  */

  1123 

  1124 

  1125 ;// CONCATENATED MODULE: ./node_modules/@wordpress/edit-site/build-module/store/constants.js

  1126 /**

  1127  * The identifier for the data store.

  1128  *

  1129  * @type {string}

  1130  */

  1131 const STORE_NAME = 'core/edit-site';

  1132 const TEMPLATE_PART_AREA_HEADER = 'header';

  1133 const TEMPLATE_PART_AREA_FOOTER = 'footer';

  1134 const TEMPLATE_PART_AREA_SIDEBAR = 'sidebar';

  1135 const TEMPLATE_PART_AREA_GENERAL = 'uncategorized';