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

     1 /******/ (() => { // webpackBootstrap

     4 /***/ 6411:

     4 /***/ 4660:

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

     5 /***/ ((module) => {

     6 

     6 

     7 var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

     7 /* eslint eslint-comments/no-unlimited-disable: 0 */

     8 	autosize 4.0.4

     8 /* eslint-disable */

     9 	license: MIT

     9 /* pako 1.0.10 nodeca/pako */ ( function ( f ) {

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

    10 	if ( true ) {

    11 */

    11 		module.exports = f();

    12 (function (global, factory) {

    12 	} else { var g; }

    13 	if (true) {

    13 } )( function () {

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

    14 	var define, module, exports;

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

    15 	return ( function () {

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

    16 		function r( e, n, t ) {

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

    17 			function o( i, f ) {

    18 	} else { var mod; }

    18 				if ( ! n[ i ] ) {

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

    19 					if ( ! e[ i ] ) {

    20 	'use strict';

    20 						var c = undefined;

    21 

    21 						if ( ! f && c ) return require( i, ! 0 );

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

    22 						if ( u ) return u( i, ! 0 );

    23 		var keys = [];

    23 						var a = new Error( "Cannot find module '" + i + "'" );

    24 		var values = [];

    24 						throw ( ( a.code = 'MODULE_NOT_FOUND' ), a );

    25 

    25 					}

    26 		return {

    26 					var p = ( n[ i ] = { exports: {} } );

    27 			has: function has(key) {

    27 					e[ i ][ 0 ].call(

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

    28 						p.exports,

    29 			},

    29 						function ( r ) {

    30 			get: function get(key) {

    30 							var n = e[ i ][ 1 ][ r ];

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

    31 							return o( n || r );

    32 			},

    32 						},

    33 			set: function set(key, value) {

    33 						p,

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

    34 						p.exports,

    35 					keys.push(key);

    35 						r,

    36 					values.push(value);

    36 						e,

    37 						n,

    38 						t

    39 					);

    38 			},

    41 				return n[ i ].exports;

    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 				}

    46 		};

    43 			for (

    47 	}();

    44 				var u = undefined, i = 0;

    48 

    45 				i < t.length;

    49 	var createEvent = function createEvent(name) {

    46 				i++

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

    47 			)

    51 	};

    48 				o( t[ i ] );

    52 	try {

    49 			return o;

    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();

    91 

    51 		return r;

    92 		function changeOverflow(value) {

    52 	} )()(

    93 			{

    53 		{

    94 				// Chrome/Safari-specific fix:

    54 			1: [

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

    55 				function ( require, module, exports ) {

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

    56 					'use strict';

    97 				var width = ta.style.width;

    57 

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

    58 					var TYPED_OK =

    99 				// Force reflow:

    59 						typeof Uint8Array !== 'undefined' &&

   100 				/* jshint ignore:start */

    60 						typeof Uint16Array !== 'undefined' &&

   101 				ta.offsetWidth;

    61 						typeof Int32Array !== 'undefined';

   102 				/* jshint ignore:end */

    62 

   103 				ta.style.width = width;

    63 					function _has( obj, key ) {

   104 			}

    64 						return Object.prototype.hasOwnProperty.call( obj, key );

   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);

   325 				}

    66 

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

    67 					exports.assign = function (

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

    68 						obj /*from1, from2, from3, ...*/

   328 					for (var key in arg) {

    69 					) {

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

    70 						var sources = Array.prototype.slice.call(

   330 							classes.push(key);

    71 							arguments,

    72 							1

    73 						);

    74 						while ( sources.length ) {

    75 							var source = sources.shift();

    76 							if ( ! source ) {

    77 								continue;

    78 							}

    79 

    80 							if ( typeof source !== 'object' ) {

    81 								throw new TypeError(

    82 									source + 'must be non-object'

    83 								);

    84 							}

    85 

    86 							for ( var p in source ) {

    87 								if ( _has( source, p ) ) {

    88 									obj[ p ] = source[ p ];

    89 								}

    90 							}

    91 						}

    92 

    93 						return obj;

    94 					};

    95 

    96 					// reduce buffer size, avoiding mem copy

    97 					exports.shrinkBuf = function ( buf, size ) {

    98 						if ( buf.length === size ) {

    99 							return buf;

   100 						}

   101 						if ( buf.subarray ) {

   102 							return buf.subarray( 0, size );

   103 						}

   104 						buf.length = size;

   105 						return buf;

   106 					};

   107 

   108 					var fnTyped = {

   109 						arraySet: function (

   110 							dest,

   111 							src,

   112 							src_offs,

   113 							len,

   114 							dest_offs

   115 						) {

   116 							if ( src.subarray && dest.subarray ) {

   117 								dest.set(

   118 									src.subarray( src_offs, src_offs + len ),

   119 									dest_offs

   120 								);

   121 								return;

   122 							}

   123 							// Fallback to ordinary array

   124 							for ( var i = 0; i < len; i++ ) {

   125 								dest[ dest_offs + i ] = src[ src_offs + i ];

   126 							}

   127 						},

   128 						// Join array of chunks to single array.

   129 						flattenChunks: function ( chunks ) {

   130 							var i, l, len, pos, chunk, result;

   131 

   132 							// calculate data length

   133 							len = 0;

   134 							for ( i = 0, l = chunks.length; i < l; i++ ) {

   135 								len += chunks[ i ].length;

   136 							}

   137 

   138 							// join chunks

   139 							result = new Uint8Array( len );

   140 							pos = 0;

   141 							for ( i = 0, l = chunks.length; i < l; i++ ) {

   142 								chunk = chunks[ i ];

   143 								result.set( chunk, pos );

   144 								pos += chunk.length;

   145 							}

   146 

   147 							return result;

   148 						},

   149 					};

   150 

   151 					var fnUntyped = {

   152 						arraySet: function (

   153 							dest,

   154 							src,

   155 							src_offs,

   156 							len,

   157 							dest_offs

   158 						) {

   159 							for ( var i = 0; i < len; i++ ) {

   160 								dest[ dest_offs + i ] = src[ src_offs + i ];

   161 							}

   162 						},

   163 						// Join array of chunks to single array.

   164 						flattenChunks: function ( chunks ) {

   165 							return [].concat.apply( [], chunks );

   166 						},

   167 					};

   168 

   169 					// Enable/Disable typed arrays use, for testing

   170 					//

   171 					exports.setTyped = function ( on ) {

   172 						if ( on ) {

   173 							exports.Buf8 = Uint8Array;

   174 							exports.Buf16 = Uint16Array;

   175 							exports.Buf32 = Int32Array;

   176 							exports.assign( exports, fnTyped );

   177 						} else {

   178 							exports.Buf8 = Array;

   179 							exports.Buf16 = Array;

   180 							exports.Buf32 = Array;

   181 							exports.assign( exports, fnUntyped );

   182 						}

   183 					};

   184 

   185 					exports.setTyped( TYPED_OK );

   186 				},

   187 				{},

   188 			],

   189 			2: [

   190 				function ( require, module, exports ) {

   191 					// String encode/decode helpers

   192 					'use strict';

   193 

   194 					var utils = require( './common' );

   195 

   196 					// Quick check if we can use fast array to bin string conversion

   197 					//

   198 					// - apply(Array) can fail on Android 2.2

   199 					// - apply(Uint8Array) can fail on iOS 5.1 Safari

   200 					//

   201 					var STR_APPLY_OK = true;

   202 					var STR_APPLY_UIA_OK = true;

   203 

   204 					try {

   205 						String.fromCharCode.apply( null, [ 0 ] );

   206 					} catch ( __ ) {

   207 						STR_APPLY_OK = false;

   208 					}

   209 					try {

   210 						String.fromCharCode.apply( null, new Uint8Array( 1 ) );

   211 					} catch ( __ ) {

   212 						STR_APPLY_UIA_OK = false;

   213 					}

   214 

   215 					// Table with utf8 lengths (calculated by first byte of sequence)

   216 					// Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,

   217 					// because max possible codepoint is 0x10ffff

   218 					var _utf8len = new utils.Buf8( 256 );

   219 					for ( var q = 0; q < 256; q++ ) {

   220 						_utf8len[ q ] =

   221 							q >= 252

   222 								? 6

   223 								: q >= 248

   224 								? 5

   225 								: q >= 240

   226 								? 4

   227 								: q >= 224

   228 								? 3

   229 								: q >= 192

   230 								? 2

   231 								: 1;

   232 					}

   233 					_utf8len[ 254 ] = _utf8len[ 254 ] = 1; // Invalid sequence start

   234 

   235 					// convert string to array (typed, when possible)

   236 					exports.string2buf = function ( str ) {

   237 						var buf,

   238 							c,

   239 							c2,

   240 							m_pos,

   241 							i,

   242 							str_len = str.length,

   243 							buf_len = 0;

   244 

   245 						// count binary size

   246 						for ( m_pos = 0; m_pos < str_len; m_pos++ ) {

   247 							c = str.charCodeAt( m_pos );

   248 							if (

   249 								( c & 0xfc00 ) === 0xd800 &&

   250 								m_pos + 1 < str_len

   251 							) {

   252 								c2 = str.charCodeAt( m_pos + 1 );

   253 								if ( ( c2 & 0xfc00 ) === 0xdc00 ) {

   254 									c =

   255 										0x10000 +

   256 										( ( c - 0xd800 ) << 10 ) +

   257 										( c2 - 0xdc00 );

   258 									m_pos++;

   259 								}

   260 							}

   261 							buf_len +=

   262 								c < 0x80

   263 									? 1

   264 									: c < 0x800

   265 									? 2

   266 									: c < 0x10000

   267 									? 3

   268 									: 4;

   269 						}

   270 

   271 						// allocate buffer

   272 						buf = new utils.Buf8( buf_len );

   273 

   274 						// convert

   275 						for ( i = 0, m_pos = 0; i < buf_len; m_pos++ ) {

   276 							c = str.charCodeAt( m_pos );

   277 							if (

   278 								( c & 0xfc00 ) === 0xd800 &&

   279 								m_pos + 1 < str_len

   280 							) {

   281 								c2 = str.charCodeAt( m_pos + 1 );

   282 								if ( ( c2 & 0xfc00 ) === 0xdc00 ) {

   283 									c =

   284 										0x10000 +

   285 										( ( c - 0xd800 ) << 10 ) +

   286 										( c2 - 0xdc00 );

   287 									m_pos++;

   288 								}

   289 							}

   290 							if ( c < 0x80 ) {

   291 								/* one byte */

   292 								buf[ i++ ] = c;

   293 							} else if ( c < 0x800 ) {

   294 								/* two bytes */

   295 								buf[ i++ ] = 0xc0 | ( c >>> 6 );

   296 								buf[ i++ ] = 0x80 | ( c & 0x3f );

   297 							} else if ( c < 0x10000 ) {

   298 								/* three bytes */

   299 								buf[ i++ ] = 0xe0 | ( c >>> 12 );

   300 								buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );

   301 								buf[ i++ ] = 0x80 | ( c & 0x3f );

   302 							} else {

   303 								/* four bytes */

   304 								buf[ i++ ] = 0xf0 | ( c >>> 18 );

   305 								buf[ i++ ] = 0x80 | ( ( c >>> 12 ) & 0x3f );

   306 								buf[ i++ ] = 0x80 | ( ( c >>> 6 ) & 0x3f );

   307 								buf[ i++ ] = 0x80 | ( c & 0x3f );

   308 							}

   309 						}

   310 

   311 						return buf;

   312 					};

   313 

   314 					// Helper (used in 2 places)

   315 					function buf2binstring( buf, len ) {

   316 						// On Chrome, the arguments in a function call that are allowed is `65534`.

   317 						// If the length of the buffer is smaller than that, we can use this optimization,

   318 						// otherwise we will take a slower path.

   319 						if ( len < 65534 ) {

   320 							if (

   321 								( buf.subarray && STR_APPLY_UIA_OK ) ||

   322 								( ! buf.subarray && STR_APPLY_OK )

   323 							) {

   324 								return String.fromCharCode.apply(

   325 									null,

   326 									utils.shrinkBuf( buf, len )

   327 								);

   328 							}

   329 						}

   330 

   331 						var result = '';

   332 						for ( var i = 0; i < len; i++ ) {

   333 							result += String.fromCharCode( buf[ i ] );

   334 						}

   335 						return result;

   336 					}

   337 

   338 					// Convert byte array to binary string

   339 					exports.buf2binstring = function ( buf ) {

   340 						return buf2binstring( buf, buf.length );

   341 					};

   342 

   343 					// Convert binary string (typed, when possible)

   344 					exports.binstring2buf = function ( str ) {

   345 						var buf = new utils.Buf8( str.length );

   346 						for ( var i = 0, len = buf.length; i < len; i++ ) {

   347 							buf[ i ] = str.charCodeAt( i );

   348 						}

   349 						return buf;

   350 					};

   351 

   352 					// convert array to string

   353 					exports.buf2string = function ( buf, max ) {

   354 						var i, out, c, c_len;

   355 						var len = max || buf.length;

   356 

   357 						// Reserve max possible length (2 words per char)

   358 						// NB: by unknown reasons, Array is significantly faster for

   359 						//     String.fromCharCode.apply than Uint16Array.

   360 						var utf16buf = new Array( len * 2 );

   361 

   362 						for ( out = 0, i = 0; i < len;  ) {

   363 							c = buf[ i++ ];

   364 							// quick process ascii

   365 							if ( c < 0x80 ) {

   366 								utf16buf[ out++ ] = c;

   367 								continue;

   368 							}

   369 

   370 							c_len = _utf8len[ c ];

   371 							// skip 5 & 6 byte codes

   372 							if ( c_len > 4 ) {

   373 								utf16buf[ out++ ] = 0xfffd;

   374 								i += c_len - 1;

   375 								continue;

   376 							}

   377 

   378 							// apply mask on first byte

   379 							c &= c_len === 2 ? 0x1f : c_len === 3 ? 0x0f : 0x07;

   380 							// join the rest

   381 							while ( c_len > 1 && i < len ) {

   382 								c = ( c << 6 ) | ( buf[ i++ ] & 0x3f );

   383 								c_len--;

   384 							}

   385 

   386 							// terminated by end of string?

   387 							if ( c_len > 1 ) {

   388 								utf16buf[ out++ ] = 0xfffd;

   389 								continue;

   390 							}

   391 

   392 							if ( c < 0x10000 ) {

   393 								utf16buf[ out++ ] = c;

   394 							} else {

   395 								c -= 0x10000;

   396 								utf16buf[ out++ ] =

   397 									0xd800 | ( ( c >> 10 ) & 0x3ff );

   398 								utf16buf[ out++ ] = 0xdc00 | ( c & 0x3ff );

   399 							}

   400 						}

   401 

   402 						return buf2binstring( utf16buf, out );

   403 					};

   404 

   405 					// Calculate max possible position in utf8 buffer,

   406 					// that will not break sequence. If that's not possible

   407 					// - (very small limits) return max size as is.

   408 					//

   409 					// buf[] - utf8 bytes array

   410 					// max   - length limit (mandatory);

   411 					exports.utf8border = function ( buf, max ) {

   412 						var pos;

   413 

   414 						max = max || buf.length;

   415 						if ( max > buf.length ) {

   416 							max = buf.length;

   417 						}

   418 

   419 						// go back from last position, until start of sequence found

   420 						pos = max - 1;

   421 						while ( pos >= 0 && ( buf[ pos ] & 0xc0 ) === 0x80 ) {

   422 							pos--;

   423 						}

   424 

   425 						// Very small and broken sequence,

   426 						// return max, because we should return something anyway.

   427 						if ( pos < 0 ) {

   428 							return max;

   429 						}

   430 

   431 						// If we came to start of buffer - that means buffer is too small,

   432 						// return max too.

   433 						if ( pos === 0 ) {

   434 							return max;

   435 						}

   436 

   437 						return pos + _utf8len[ buf[ pos ] ] > max ? pos : max;

   438 					};

   439 				},

   440 				{ './common': 1 },

   441 			],

   442 			3: [

   443 				function ( require, module, exports ) {

   444 					'use strict';

   445 

   446 					// Note: adler32 takes 12% for level 0 and 2% for level 6.

   447 					// It isn't worth it to make additional optimizations as in original.

   448 					// Small size is preferable.

   449 

   450 					// (C) 1995-2013 Jean-loup Gailly and Mark Adler

   451 					// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

   452 					//

   453 					// This software is provided 'as-is', without any express or implied

   454 					// warranty. In no event will the authors be held liable for any damages

   455 					// arising from the use of this software.

   456 					//

   457 					// Permission is granted to anyone to use this software for any purpose,

   458 					// including commercial applications, and to alter it and redistribute it

   459 					// freely, subject to the following restrictions:

   460 					//

   461 					// 1. The origin of this software must not be misrepresented; you must not

   462 					//   claim that you wrote the original software. If you use this software

   463 					//   in a product, an acknowledgment in the product documentation would be

   464 					//   appreciated but is not required.

   465 					// 2. Altered source versions must be plainly marked as such, and must not be

   466 					//   misrepresented as being the original software.

   467 					// 3. This notice may not be removed or altered from any source distribution.

   468 

   469 					function adler32( adler, buf, len, pos ) {

   470 						var s1 = ( adler & 0xffff ) | 0,

   471 							s2 = ( ( adler >>> 16 ) & 0xffff ) | 0,

   472 							n = 0;

   473 

   474 						while ( len !== 0 ) {

   475 							// Set limit ~ twice less than 5552, to keep

   476 							// s2 in 31-bits, because we force signed ints.

   477 							// in other case %= will fail.

   478 							n = len > 2000 ? 2000 : len;

   479 							len -= n;

   480 

   481 							do {

   482 								s1 = ( s1 + buf[ pos++ ] ) | 0;

   483 								s2 = ( s2 + s1 ) | 0;

   484 							} while ( --n );

   485 

   486 							s1 %= 65521;

   487 							s2 %= 65521;

   488 						}

   489 

   490 						return s1 | ( s2 << 16 ) | 0;

   491 					}

   492 

   493 					module.exports = adler32;

   494 				},

   495 				{},

   496 			],

   497 			4: [

   498 				function ( require, module, exports ) {

   499 					'use strict';

   500 

   501 					// (C) 1995-2013 Jean-loup Gailly and Mark Adler

   502 					// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

   503 					//

   504 					// This software is provided 'as-is', without any express or implied

   505 					// warranty. In no event will the authors be held liable for any damages

   506 					// arising from the use of this software.

   507 					//

   508 					// Permission is granted to anyone to use this software for any purpose,

   509 					// including commercial applications, and to alter it and redistribute it

   510 					// freely, subject to the following restrictions:

   511 					//

   512 					// 1. The origin of this software must not be misrepresented; you must not

   513 					//   claim that you wrote the original software. If you use this software

   514 					//   in a product, an acknowledgment in the product documentation would be

   515 					//   appreciated but is not required.

   516 					// 2. Altered source versions must be plainly marked as such, and must not be

   517 					//   misrepresented as being the original software.

   518 					// 3. This notice may not be removed or altered from any source distribution.

   519 

   520 					module.exports = {

   521 						/* Allowed flush values; see deflate() and inflate() below for details */

   522 						Z_NO_FLUSH: 0,

   523 						Z_PARTIAL_FLUSH: 1,

   524 						Z_SYNC_FLUSH: 2,

   525 						Z_FULL_FLUSH: 3,

   526 						Z_FINISH: 4,

   527 						Z_BLOCK: 5,

   528 						Z_TREES: 6,

   529 

   530 						/* Return codes for the compression/decompression functions. Negative values

   531 						 * are errors, positive values are used for special but normal events.

   532 						 */

   533 						Z_OK: 0,

   534 						Z_STREAM_END: 1,

   535 						Z_NEED_DICT: 2,

   536 						Z_ERRNO: -1,

   537 						Z_STREAM_ERROR: -2,

   538 						Z_DATA_ERROR: -3,

   539 						//Z_MEM_ERROR:     -4,

   540 						Z_BUF_ERROR: -5,

   541 						//Z_VERSION_ERROR: -6,

   542 

   543 						/* compression levels */

   544 						Z_NO_COMPRESSION: 0,

   545 						Z_BEST_SPEED: 1,

   546 						Z_BEST_COMPRESSION: 9,

   547 						Z_DEFAULT_COMPRESSION: -1,

   548 

   549 						Z_FILTERED: 1,

   550 						Z_HUFFMAN_ONLY: 2,

   551 						Z_RLE: 3,

   552 						Z_FIXED: 4,

   553 						Z_DEFAULT_STRATEGY: 0,

   554 

   555 						/* Possible values of the data_type field (though see inflate()) */

   556 						Z_BINARY: 0,

   557 						Z_TEXT: 1,

   558 						//Z_ASCII:                1, // = Z_TEXT (deprecated)

   559 						Z_UNKNOWN: 2,

   560 

   561 						/* The deflate compression method */

   562 						Z_DEFLATED: 8,

   563 						//Z_NULL:                 null // Use -1 or null inline, depending on var type

   564 					};

   565 				},

   566 				{},

   567 			],

   568 			5: [

   569 				function ( require, module, exports ) {

   570 					'use strict';

   571 

   572 					// Note: we can't get significant speed boost here.

   573 					// So write code to minimize size - no pregenerated tables

   574 					// and array tools dependencies.

   575 

   576 					// (C) 1995-2013 Jean-loup Gailly and Mark Adler

   577 					// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

   578 					//

   579 					// This software is provided 'as-is', without any express or implied

   580 					// warranty. In no event will the authors be held liable for any damages

   581 					// arising from the use of this software.

   582 					//

   583 					// Permission is granted to anyone to use this software for any purpose,

   584 					// including commercial applications, and to alter it and redistribute it

   585 					// freely, subject to the following restrictions:

   586 					//

   587 					// 1. The origin of this software must not be misrepresented; you must not

   588 					//   claim that you wrote the original software. If you use this software

   589 					//   in a product, an acknowledgment in the product documentation would be

   590 					//   appreciated but is not required.

   591 					// 2. Altered source versions must be plainly marked as such, and must not be

   592 					//   misrepresented as being the original software.

   593 					// 3. This notice may not be removed or altered from any source distribution.

   594 

   595 					// Use ordinary array, since untyped makes no boost here

   596 					function makeTable() {

   597 						var c,

   598 							table = [];

   599 

   600 						for ( var n = 0; n < 256; n++ ) {

   601 							c = n;

   602 							for ( var k = 0; k < 8; k++ ) {

   603 								c = c & 1 ? 0xedb88320 ^ ( c >>> 1 ) : c >>> 1;

   604 							}

   605 							table[ n ] = c;

   606 						}

   607 

   608 						return table;

   609 					}

   610 

   611 					// Create table on load. Just 255 signed longs. Not a problem.

   612 					var crcTable = makeTable();

   613 

   614 					function crc32( crc, buf, len, pos ) {

   615 						var t = crcTable,

   616 							end = pos + len;

   617 

   618 						crc ^= -1;

   619 

   620 						for ( var i = pos; i < end; i++ ) {

   621 							crc =

   622 								( crc >>> 8 ) ^ t[ ( crc ^ buf[ i ] ) & 0xff ];

   623 						}

   624 

   625 						return crc ^ -1; // >>> 0;

   626 					}

   627 

   628 					module.exports = crc32;

   629 				},

   630 				{},

   631 			],

   632 			6: [

   633 				function ( require, module, exports ) {

   634 					'use strict';

   635 

   636 					// (C) 1995-2013 Jean-loup Gailly and Mark Adler

   637 					// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

   638 					//

   639 					// This software is provided 'as-is', without any express or implied

   640 					// warranty. In no event will the authors be held liable for any damages

   641 					// arising from the use of this software.

   642 					//

   643 					// Permission is granted to anyone to use this software for any purpose,

   644 					// including commercial applications, and to alter it and redistribute it

   645 					// freely, subject to the following restrictions:

   646 					//

   647 					// 1. The origin of this software must not be misrepresented; you must not

   648 					//   claim that you wrote the original software. If you use this software

   649 					//   in a product, an acknowledgment in the product documentation would be

   650 					//   appreciated but is not required.

   651 					// 2. Altered source versions must be plainly marked as such, and must not be

   652 					//   misrepresented as being the original software.

   653 					// 3. This notice may not be removed or altered from any source distribution.

   654 

   655 					function GZheader() {

   656 						/* true if compressed data believed to be text */

   657 						this.text = 0;

   658 						/* modification time */

   659 						this.time = 0;

   660 						/* extra flags (not used when writing a gzip file) */

   661 						this.xflags = 0;

   662 						/* operating system */

   663 						this.os = 0;

   664 						/* pointer to extra field or Z_NULL if none */

   665 						this.extra = null;

   666 						/* extra field length (valid if extra != Z_NULL) */

   667 						this.extra_len = 0; // Actually, we don't need it in JS,

   668 						// but leave for few code modifications

   669 

   670 						//

   671 						// Setup limits is not necessary because in js we should not preallocate memory

   672 						// for inflate use constant limit in 65536 bytes

   673 						//

   674 

   675 						/* space at extra (only when reading header) */

   676 						// this.extra_max  = 0;

   677 						/* pointer to zero-terminated file name or Z_NULL */

   678 						this.name = '';

   679 						/* space at name (only when reading header) */

   680 						// this.name_max   = 0;

   681 						/* pointer to zero-terminated comment or Z_NULL */

   682 						this.comment = '';

   683 						/* space at comment (only when reading header) */

   684 						// this.comm_max   = 0;

   685 						/* true if there was or will be a header crc */

   686 						this.hcrc = 0;

   687 						/* true when done reading gzip header (not used when writing a gzip file) */

   688 						this.done = false;

   689 					}

   690 

   691 					module.exports = GZheader;

   692 				},

   693 				{},

   694 			],

   695 			7: [

   696 				function ( require, module, exports ) {

   697 					'use strict';

   698 

   699 					// (C) 1995-2013 Jean-loup Gailly and Mark Adler

   700 					// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin

   701 					//

   702 					// This software is provided 'as-is', without any express or implied

   703 					// warranty. In no event will the authors be held liable for any damages

   704 					// arising from the use of this software.

   705 					//

   706 					// Permission is granted to anyone to use this software for any purpose,

   707 					// including commercial applications, and to alter it and redistribute it

   708 					// freely, subject to the following restrictions:

   709 					//

   710 					// 1. The origin of this software must not be misrepresented; you must not

   711 					//   claim that you wrote the original software. If you use this software

   712 					//   in a product, an acknowledgment in the product documentation would be

   713 					//   appreciated but is not required.

   714 					// 2. Altered source versions must be plainly marked as such, and must not be

   715 					//   misrepresented as being the original software.

   716 					// 3. This notice may not be removed or altered from any source distribution.

   717 

   718 					// See state defs from inflate.js

   719 					var BAD = 30; /* got a data error -- remain here until reset */

   720 					var TYPE = 12; /* i: waiting for type bits, including last-flag bit */

   721 

   722 					/*

   723      Decode literal, length, and distance codes and write out the resulting

   724      literal and match bytes until either not enough input or output is

   725      available, an end-of-block is encountered, or a data error is encountered.

   726      When large enough input and output buffers are supplied to inflate(), for

   727      example, a 16K input buffer and a 64K output buffer, more than 95% of the

   728      inflate execution time is spent in this routine.

   729 

   730      Entry assumptions:

   731 

   732           state.mode === LEN

   733           strm.avail_in >= 6

   734           strm.avail_out >= 258

   735           start >= strm.avail_out

   736           state.bits < 8

   737 

   738      On return, state.mode is one of:

   739 

   740           LEN -- ran out of enough output space or enough available input

   741           TYPE -- reached end of block code, inflate() to interpret next block

   742           BAD -- error in block data

   743 

   744      Notes:

   745 

   746       - The maximum input bits used by a length/distance pair is 15 bits for the

   747         length code, 5 bits for the length extra, 15 bits for the distance code,

   748         and 13 bits for the distance extra.  This totals 48 bits, or six bytes.

   749         Therefore if strm.avail_in >= 6, then there is enough input to avoid

   750         checking for available input while decoding.

   751 

   752       - The maximum bytes that a single length/distance pair can output is 258

   753         bytes, which is the maximum length that can be coded.  inflate_fast()

   754         requires strm.avail_out >= 258 for each loop to avoid checking for

   755         output space.

   756    */

   757 					module.exports = function inflate_fast( strm, start ) {

   758 						var state;

   759 						var _in; /* local strm.input */

   760 						var last; /* have enough input while in < last */

   761 						var _out; /* local strm.output */

   762 						var beg; /* inflate()'s initial strm.output */

   763 						var end; /* while out < end, enough space available */

   764 						//#ifdef INFLATE_STRICT

   765 						var dmax; /* maximum distance from zlib header */

   766 						//#endif

   767 						var wsize; /* window size or zero if not using window */

   768 						var whave; /* valid bytes in the window */

   769 						var wnext; /* window write index */

   770 						// Use `s_window` instead `window`, avoid conflict with instrumentation tools

   771 						var s_window; /* allocated sliding window, if wsize != 0 */

   772 						var hold; /* local strm.hold */

   773 						var bits; /* local strm.bits */

   774 						var lcode; /* local strm.lencode */

   775 						var dcode; /* local strm.distcode */

   776 						var lmask; /* mask for first level of length codes */

   777 						var dmask; /* mask for first level of distance codes */

   778 						var here; /* retrieved table entry */

   779 						var op; /* code bits, operation, extra bits, or */

   780 						/*  window position, window bytes to copy */

   781 						var len; /* match length, unused bytes */

   782 						var dist; /* match distance */

   783 						var from; /* where to copy match from */

   784 						var from_source;

   785 

   786 						var input, output; // JS specific, because we have no pointers

   787 

   788 						/* copy state to local variables */

   789 						state = strm.state;

   790 						//here = state.here;

   791 						_in = strm.next_in;

   792 						input = strm.input;

   793 						last = _in + ( strm.avail_in - 5 );

   794 						_out = strm.next_out;

   795 						output = strm.output;

   796 						beg = _out - ( start - strm.avail_out );

   797 						end = _out + ( strm.avail_out - 257 );

   798 						//#ifdef INFLATE_STRICT

   799 						dmax = state.dmax;

   800 						//#endif

   801 						wsize = state.wsize;

   802 						whave = state.whave;

   803 						wnext = state.wnext;

   804 						s_window = state.window;

   805 						hold = state.hold;

   806 						bits = state.bits;

   807 						lcode = state.lencode;

   808 						dcode = state.distcode;

   809 						lmask = ( 1 << state.lenbits ) - 1;

   810 						dmask = ( 1 << state.distbits ) - 1;

   811 

   812 						/* decode literals and length/distances until end-of-block or not enough

   813        input data or output space */

   814 

   815 						top: do {

   816 							if ( bits < 15 ) {

   817 								hold += input[ _in++ ] << bits;

   818 								bits += 8;

   819 								hold += input[ _in++ ] << bits;

   820 								bits += 8;

   821 							}

   822 

   823 							here = lcode[ hold & lmask ];

   824 

   825 							dolen: for (;;) {

   826 								// Goto emulation

   827 								op = here >>> 24 /*here.bits*/;

   828 								hold >>>= op;

   829 								bits -= op;

   830 								op = ( here >>> 16 ) & 0xff /*here.op*/;

   831 								if ( op === 0 ) {

   832 									/* literal */

   833 									//Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?

   834 									//        "inflate:         literal '%c'\n" :

   835 									//        "inflate:         literal 0x%02x\n", here.val));

   836 									output[ _out++ ] =

   837 										here & 0xffff /*here.val*/;

   838 								} else if ( op & 16 ) {

   839 									/* length base */

   840 									len = here & 0xffff /*here.val*/;

   841 									op &= 15; /* number of extra bits */

   842 									if ( op ) {

   843 										if ( bits < op ) {

   844 											hold += input[ _in++ ] << bits;

   845 											bits += 8;

   846 										}

   847 										len += hold & ( ( 1 << op ) - 1 );

   848 										hold >>>= op;

   849 										bits -= op;

   850 									}

   851 									//Tracevv((stderr, "inflate:         length %u\n", len));

   852 									if ( bits < 15 ) {

   853 										hold += input[ _in++ ] << bits;

   854 										bits += 8;

   855 										hold += input[ _in++ ] << bits;

   856 										bits += 8;

   857 									}

   858 									here = dcode[ hold & dmask ];

   859 

   860 									dodist: for (;;) {

   861 										// goto emulation

   862 										op = here >>> 24 /*here.bits*/;

   863 										hold >>>= op;

   864 										bits -= op;

   865 										op = ( here >>> 16 ) & 0xff /*here.op*/;

   866 

   867 										if ( op & 16 ) {

   868 											/* distance base */

   869 											dist = here & 0xffff /*here.val*/;

   870 											op &= 15; /* number of extra bits */

   871 											if ( bits < op ) {

   872 												hold += input[ _in++ ] << bits;