https://minhaescola.app/js/chunk-vendors~9c5b28f6.fac79094.js

1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["chunk-vendors~9c5b28f6"],{
2
3/***/ "1468":
4/***/ (function(module, exports) {
5
6/**
7 * Helpers.
8 */
9
10var s = 1000;
11var m = s * 60;
12var h = m * 60;
13var d = h * 24;
14var w = d * 7;
15var y = d * 365.25;
16
17/**
18 * Parse or format the given `val`.
19 *
20 * Options:
21 *
22 *  - `long` verbose formatting [false]
23 *
24 * @param {String|Number} val
25 * @param {Object} [options]
26 * @throws {Error} throw an error if val is not a non-empty string or a number
27 * @return {String|Number}
28 * @api public
29 */
30
31module.exports = function(val, options) {
32  options = options || {};
33  var type = typeof val;
34  if (type === 'string' && val.length > 0) {
35    return parse(val);
36  } else if (type === 'number' && isFinite(val)) {
37    return options.long ? fmtLong(val) : fmtShort(val);
38  }
39  throw new Error(
40    'val is not a non-empty string or a valid number. val=' +
41      JSON.stringify(val)
42  );
43};
44
45/**
46 * Parse the given `str` and return milliseconds.
47 *
48 * @param {String} str
49 * @return {Number}
50 * @api private
51 */
52
53function parse(str) {
54  str = String(str);
55  if (str.length > 100) {
56    return;
57  }
58  var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
59    str
60  );
61  if (!match) {
62    return;
63  }
64  var n = parseFloat(match[1]);
65  var type = (match[2] || 'ms').toLowerCase();
66  switch (type) {
67    case 'years':
68    case 'year':
69    case 'yrs':
70    case 'yr':
71    case 'y':
72      return n * y;
73    case 'weeks':
74    case 'week':
75    case 'w':
76      return n * w;
77    case 'days':
78    case 'day':
79    case 'd':
80      return n * d;
81    case 'hours':
82    case 'hour':
83    case 'hrs':
84    case 'hr':
85    case 'h':
86      return n * h;
87    case 'minutes':
88    case 'minute':
89    case 'mins':
90    case 'min':
91    case 'm':
92      return n * m;
93    case 'seconds':
94    case 'second':
95    case 'secs':
96    case 'sec':
97    case 's':
98      return n * s;
99    case 'milliseconds':
100    case 'millisecond':
101    case 'msecs':
102    case 'msec':
103    case 'ms':
104      return n;
105    default:
106      return undefined;
107  }
108}
109
110/**
111 * Short format for `ms`.
112 *
113 * @param {Number} ms
114 * @return {String}
115 * @api private
116 */
117
118function fmtShort(ms) {
119  var msAbs = Math.abs(ms);
120  if (msAbs >= d) {
121    return Math.round(ms / d) + 'd';
122  }
123  if (msAbs >= h) {
124    return Math.round(ms / h) + 'h';
125  }
126  if (msAbs >= m) {
127    return Math.round(ms / m) + 'm';
128  }
129  if (msAbs >= s) {
130    return Math.round(ms / s) + 's';
131  }
132  return ms + 'ms';
133}
134
135/**
136 * Long format for `ms`.
137 *
138 * @param {Number} ms
139 * @return {String}
140 * @api private
141 */
142
143function fmtLong(ms) {
144  var msAbs = Math.abs(ms);
145  if (msAbs >= d) {
146    return plural(ms, msAbs, d, 'day');
147  }
148  if (msAbs >= h) {
149    return plural(ms, msAbs, h, 'hour');
150  }
151  if (msAbs >= m) {
152    return plural(ms, msAbs, m, 'minute');
153  }
154  if (msAbs >= s) {
155    return plural(ms, msAbs, s, 'second');
156  }
157  return ms + ' ms';
158}
159
160/**
161 * Pluralization helper.
162 */
163
164function plural(ms, msAbs, n, name) {
165  var isPlural = msAbs >= n * 1.5;
166  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
167}
168
169
170/***/ }),
171
172/***/ "1985":
173/***/ (function(module, exports, __webpack_require__) {
174
175/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.4.1 by @mathias */
176;(function(root) {
177
178	/** Detect free variables */
179	var freeExports =  true && exports &&
180		!exports.nodeType && exports;
181	var freeModule =  true

181 && module &&
182		!module.nodeType && module;
183	var freeGlobal = typeof global == 'object' && global;
184	if (
185		freeGlobal.global === freeGlobal ||
186		freeGlobal.window === freeGlobal ||
187		freeGlobal.self === freeGlobal
188	) {
189		root = freeGlobal;
190	}
191
192	/**
193	 * The `punycode` object.
194	 * @name punycode
195	 * @type Object
196	 */
197	var punycode,
198
199	/** Highest positive signed 32-bit float value */
200	maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
201
202	/** Bootstring parameters */
203	base = 36,
204	tMin = 1,
205	tMax = 26,
206	skew = 38,
207	damp = 700,
208	initialBias = 72,
209	initialN = 128, // 0x80
210	delimiter = '-', // '\x2D'
211
212	/** Regular expressions */
213	regexPunycode = /^xn--/,
214	regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
215	regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
216
217	/** Error messages */
218	errors = {
219		'overflow': 'Overflow: input needs wider integers to process',
220		'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
221		'invalid-input': 'Invalid input'
222	},
223
224	/** Convenience shortcuts */
225	baseMinusTMin = base - tMin,
226	floor = Math.floor,
227	stringFromCharCode = String.fromCharCode,
228
229	/** Temporary variable */
230	key;
231
232	/*--------------------------------------------------------------------------*/
233
234	/**
235	 * A generic error utility function.
236	 * @private
237	 * @param {String} type The error type.
238	 * @returns {Error} Throws a `RangeError` with the applicable error message.
239	 */
240	function error(type) {
241		throw new RangeError(errors[type]);
242	}
243
244	/**
245	 * A generic `Array#map` utility function.
246	 * @private
247	 * @param {Array} array The array to iterate over.
248	 * @param {Function} callback The function that gets called for every array
249	 * item.
250	 * @returns {Array} A new array of values returned by the callback function.
251	 */
252	function map(array, fn) {
253		var length = array.length;
254		var result = [];
255		while (length--) {
256			result[length] = fn(array[length]);
257		}
258		return result;
259	}
260
261	/**
262	 * A simple `Array#map`-like wrapper to work with domain name strings or email
263	 * addresses.
264	 * @private
265	 * @param {String} domain The domain name or email address.
266	 * @param {Function} callback The function that gets called for every
267	 * character.
268	 * @returns {Array} A new string of characters returned by the callback
269	 * function.
270	 */
271	function mapDomain(string, fn) {
272		var parts = string.split('@');
273		var result = '';
274		if (parts.length > 1) {
275			// In email addresses, only the domain name should be punycoded. Leave
276			// the local part (i.e. everything up to `@`) intact.
277			result = parts[0] + '@';
278			string = parts[1];
279		}
280		// Avoid `split(regex)` for IE8 compatibility. See #17.
281		string = string.replace(regexSeparators, '\x2E');
282		var labels = string.split('.');
283		var encoded = map(labels, fn).join('.');
284		return result + encoded;
285	}
286
287	/**
288	 * Creates an array containing the numeric code points of each Unicode
289	 * character in the string. While JavaScript uses UCS-2 internally,
290	 * this function will convert a pair of surrogate halves (each of which
291	 * UCS-2 exposes as separate characters) into a single code point,
292	 * matching UTF-16.
293	 * @see `punycode.ucs2.encode`
294	 * @see <https://mathiasbynens.be/notes/javascript-encoding>
295	 * @memberOf punycode.ucs2
296	 * @name decode
297	 * @param {String} string The Unicode input string (UCS-2).
298	 * @returns {Array} The new array of code points.
299	 */
300	function ucs2decode(string) {
301		var output = [],
302		    counter = 0,
303		    length = string.length,
304		    value,
305		    extra;
306		while (counter < length) {
307			value = string.charCodeAt(counter++);
308			if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
309				// high surrogate, and there is a next character
310				extra = string.charCodeAt(counter++);
311				if ((extra & 0xFC00) == 0xDC00) { // low surrogate
312					output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
313				} else {
314					// unmatched surrogate; only append this code unit, in case the next
315					// code unit is the high surrogate of a surrogate pair
316					output.push(value);
317					counter--;
318				}
319			} else {
320				output.push(value);
321			}
322		}
323		return output;
324	}
325
326	/**
327	 * Creates a string based on an array of numeric code points.
328	 * @see `punycode.ucs2.decode`
329	 * @memberOf punycode.ucs2
330	 * @name encode
331	 * @param {Array} codePoints The array of numeric code points.
332	 * @returns {String} The new Unicode string (UCS-2).
333	 */
334	function ucs2encode(array) {
335		return map(array, function(value) {
336			var output = '';
337			if (value > 0xFFFF) {
338				value -= 0x10000;
339				output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
340				value = 0xDC00 | value & 0x3FF;
341			}
342			output += stringFromCharCode(value);
343			return output;
344		}).join('');
345	}
346
347	/**
348	 * Converts a basic code point into a digit/integer.
349	 * @see `digitToBasic()`
350	 * @private
351	 * @param {Number} codePoint The basic numeric code point value.
352	 * @returns {Number} The numeric value of a basic code point (for use in
353	 * representing integers) in the range `0` to `base - 1`, or `base` if
354	 * the code point does not represent a value.
355	 */
356	function basicToDigit(codePoint) {
357		if (codePoint - 48 < 10) {
358			return codePoint - 22;
359		}
360		if (codePoint - 65 < 26) {
361			return codePoint - 65;
362		}
363		if (codePoint - 97 < 26) {
364			return codePoint - 97;
365		}
366		return base;
367	}
368
369	/**
370	 * Converts a digit/integer into a basic code point.
371	 * @see `basicToDigit()`
372	 * @private
373	 * @param {Number} digit The numeric value of a basic code point.
374	 * @returns {Number} The basic code point whose value (when used for
375	 * representing integers) is `digit`, which needs to be in the range
376	 * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
377	 * used; else, the lowercase form is used. The behavior is undefined
378	 * if `flag` is non-zero and `digit` has no uppercase form.
379	 */
380	function digitToBasic(digit, flag) {
381		//  0..25 map to ASCII a..z or A..Z
382		// 26..35 map to ASCII 0..9
383		return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
384	}
385
386	/**
387	 * Bias adaptation function as per section 3.4 of RFC 3492.
388	 * https://tools.ietf.org/html/rfc3492#section-3.4
389	 * @private
390	 */
391	function adapt(delta, numPoints, firstTime) {
392		var k = 0;
393		delta = firstTime ? floor(delta / damp) : delta >> 1;
394		delta += floor(delta / numPoints);
395		for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
396			delta = floor(delta / baseMinusTMin);
397		}
398		return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
399	}
400
401	/**
402	 * Converts a Punycode string of ASCII-only symbols to a string of Unicode
403	 * symbols.
404	 * @memberOf punycode
405	 * @param {String} input The Punycode string of ASCII-only symbols.
406	 * @returns {String} The resulting string of Unicode symbols.
407	 */
408	function decode(input) {
409		// Don't use UCS-2
410		var output = [],
411		    inputLength = input.length,
412		    out,
413		    i = 0,
414		    n = initialN,
415		    bias = initialBias,
416		    basic,
417		    j,
418		    index,
419		    oldi,
420		    w,
421		    k,
422		    digit,
423		    t,
424		    /** Cached calculation results */
425		    baseMinusT;
426
427		// Handle the basic code points: let `basic` be the number of input code
428		// points before the last delimiter, or `0` if there is none, then copy
429		// the first basic code points to the output.
430
431		basic = input.lastIndexOf(delimiter);
432		if (basic < 0) {
433			basic = 0;
434		}
435
436		for (j = 0; j < basic; ++j) {
437			// if it's not a basic code point
438			if (input.charCodeAt(j) >= 0x80) {
439				error('not-basic');
440			}
441			output.push(input.charCodeAt(j));
442		}
443
444		// Main decoding loop: start just after the last delimiter if any basic code
445		// points were copied; start at the beginning otherwise.
446
447		for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
448
449			// `index` is the index of the next character to be consumed.
450			// Decode a generalized variable-length integer into `delta`,
451			// which gets added to `i`. The overflow checking is easier
452			// if we increase `i` as we go, then subtract off its starting
453			// value at the end to obtain `delta`.
454			for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
455
456				if (index >= inputLength) {
457					error('invalid-input');
458				}
459
460				digit = basicToDigit(input.charCodeAt(index++));
461
462				if (digit >= base || digit > floor((maxInt - i) / w)) {
463					error('overflow');
464				}
465
466				i += digit * w;
467				t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
468
469				if (digit < t) {
470					break;
471				}
472
473				baseMinusT = base - t;
474				if (w > floor(maxInt / baseMinusT)) {
475					error('overflow');
476				}
477
478				w *= baseMinusT;
479
480			}
481
482			out = output.length + 1;
483			bias = adapt(i - oldi, out, oldi == 0);
484
485			// `i` was supposed to wrap around from `out` to `0`,
486			// incrementing `n` each time, so we'll fix that now:
487			if (floor(i / out) > maxInt - n) {
488				error('overflow');
489			}
490
491			n += floor(i / out);
492			i %= out;
493
494			// Insert `n` at position `i` of the output
495			output.splice(i++, 0, n);
496
497		}
498
499		return ucs2encode(output);
500	}
501
502	/**
503	 * Converts a string of Unicode symbols (e.g. a domain name label) to a
504	 * Punycode string of ASCII-only symbols.
505	 * @memberOf punycode
506	 * @param {String} input The string of Unicode symbols.
507	 * @returns {String} The resulting Punycode string of ASCII-only symbols.
508	 */
509	function encode(input) {
510		var n,
511		    delta,
512		    handledCPCount,
513		    basicLength,
514		    bias,
515		    j,
516		    m,
517		    q,
518		    k,
519		    t,
520		    currentValue,
521		    output = [],
522		    /** `inputLength` will hold the number of code points in `input`. */
523		    inputLength,
524		    /** Cached calculation results */
525		    handledCPCountPlusOne,
526		    baseMinusT,
527		    qMinusT;
528
529		// Convert the input in UCS-2 to Unicode
530		input = ucs2decode(input);
531
532		// Cache the length
533		inputLength = input.length;
534
535		// Initialize the state
536		n = initialN;
537		delta = 0;
538		bias = initialBias;
539
540		// Handle the basic code points
541		for (j = 0; j < inputLength; ++j) {
542			currentValue = input[j];
543			if (currentValue < 0x80) {
544				output.push(stringFromCharCode(currentValue));
545			}
546		}
547
548		handledCPCount = basicLength = output.length;
549
550		// `handledCPCount` is the number of code points that have been handled;
551		// `basicLength` is the number of basic code points.
552
553		// Finish the basic string - if it is not empty - with a delimiter
554		if (basicLength) {
555			output.push(delimiter);
556		}
557
558		// Main encoding loop:
559		while (handledCPCount < inputLength) {
560
561			// All non-basic code points < n have been handled already. Find the next
562			// larger one:
563			for (m = maxInt, j = 0; j < inputLength; ++j) {
564				currentValue = input[j];
565				if (currentValue >= n && currentValue < m) {
566					m = currentValue;
567				}
568			}
569
570			// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
571			// but guard against overflow
572			handledCPCountPlusOne = handledCPCount + 1;
573			if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
574				error('overflow');
575			}
576
577			delta += (m - n) * handledCPCountPlusOne;
578			n = m;
579
580			for (j = 0; j < inputLength; ++j) {
581				currentValue = input[j];
582
583				if (currentValue < n && ++delta > maxInt) {
584					error('overflow');
585				}
586
587				if (currentValue == n) {
588					// Represent delta as a generalized variable-length integer
589					for (q = delta, k = base; /* no condition */; k += base) {
590						t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
591						if (q < t) {
592							break;
593						}
594						qMinusT = q - t;
595						baseMinusT = base - t;
596						output.push(
597							stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
598						);
599						q = floor(qMinusT / baseMinusT);
600					}
601
602					output.push(stringFromCharCode(digitToBasic(q, 0)));
603					bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
604					delta = 0;
605					++handledCPCount;
606				}
607			}
608
609			++delta;
610			++n;
611
612		}
613		return output.join('');
614	}
615
616	/**
617	 * Converts a Punycode string representing a domain name or an email address
618	 * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
619	 * it doesn't matter if you call it on a string that has already been
620	 * converted to Unicode.
621	 * @memberOf punycode
622	 * @param {String} input The Punycoded domain name or email address to
623	 * convert to Unicode.
624	 * @returns {String} The Unicode representation of the given Punycode
625	 * string.
626	 */
627	function toUnicode(input) {
628		return mapDomain(input, function(string) {
629			return regexPunycode.test(string)
630				? decode(string.slice(4).toLowerCase())
631				: string;
632		});
633	}
634
635	/**
636	 * Converts a Unicode string representing a domain name or an email address to
637	 * Punycode. Only the non-ASCII parts of the domain name will be converted,
638	 * i.e. it doesn't matter if you call it with a domain that's already in
639	 * ASCII.
640	 * @memberOf punycode
641	 * @param {String} input The domain name or email address to convert, as a
642	 * Unicode string.
643	 * @returns {String} The Punycode representation of the given domain name or
644	 * email address.
645	 */
646	function toASCII(input) {
647		return mapDomain(input, function(string) {
648			return regexNonASCII.test(string)
649				? 'xn--' + encode(string)
650				: string;
651		});
652	}
653
654	/*--------------------------------------------------------------------------*/
655
656	/** Define the public API */
657	punycode = {
658		/**
659		 * A string representing the current Punycode.js version number.
660		 * @memberOf punycode
661		 * @type String
662		 */
663		'version': '1.4.1',
664		/**
665		 * An object of methods to convert from JavaScript's internal character
666		 * representation (UCS-2) to Unicode code points, and back.
667		 * @see <https://mathiasbynens.be/notes/javascript-encoding>
668		 * @memberOf punycode
669		 * @type Object
670		 */
671		'ucs2': {
672			'decode': ucs2decode,
673			'encode': ucs2encode
674		},
675		'decode': decode,
676		'encode': encode,
677		'toASCII': toASCII,
678		'toUnicode': toUnicode
679	};
680
681	/** Expose `punycode` */
682	// Some AMD build optimizers, like r.js, check for specific condition patterns
683	// like the following:
684	if (
685		t