https://minhaescola.app/js/chunk-vendors~f27e6d05.dbbd0d47.js

1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["chunk-vendors~f27e6d05"],{
2
3/***/ "2cf1":
4/***/ (function(module, exports, __webpack_require__) {
5
6"use strict";
7
8var toIntegerOrInfinity = __webpack_require__("c7d2");
9var toString = __webpack_require__("8c12");
10var requireObjectCoercible = __webpack_require__("1875");
11
12var $RangeError = RangeError;
13
14// `String.prototype.repeat` method implementation
15// https://tc39.es/ecma262/#sec-string.prototype.repeat
16module.exports = function repeat(count) {
17  var str = toString(requireObjectCoercible(this));
18  var result = '';
19  var n = toIntegerOrInfinity(count);
20  if (n < 0 || n === Infinity) throw new $RangeError('Wrong number of repetitions');
21  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;
22  return result;
23};
24
25
26/***/ }),
27
28/***/ "83ee":
29/***/ (function(module, exports, __webpack_require__) {
30
31"use strict";
32
33var PROPER_FUNCTION_NAME = __webpack_require__("b302").PROPER;
34var fails = __webpack_require__("06fa");
35var whitespaces = __webpack_require__("81f0");
36
37var non = '\u200B\u0085\u180E';
38
39// check that a method works with the correct list
40// of whitespaces and has a correct name
41module.exports = function (METHOD_NAME) {
42  return fails(function () {
43    return !!whitespaces[METHOD_NAME]()
44      || non[METHOD_NAME]() !== non
45      || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);
46  });
47};
48
49
50/***/ }),
51
52/***/ "8aa9":
53/***/ (function(module, exports, __webpack_require__) {
54
55"use strict";
56
57var shared = __webpack_require__("d659");
58var getBuiltIn = __webpack_require__("9883");
59var uncurryThis = __webpack_require__("ce18");
60var isSymbol = __webpack_require__("c978");
61var wellKnownSymbol = __webpack_require__("0363");
62
63var Symbol = getBuiltIn('Symbol');
64var $isWellKnownSymbol = Symbol.isWellKnownSymbol;
65var getOwnPropertyNames = getBuiltIn('Object', 'getOwnPropertyNames');
66var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf);
67var WellKnownSymbolsStore = shared('wks');
68
69for (var i = 0, symbolKeys = getOwnPropertyNames(Symbol), symbolKeysLength = symbolKeys.length; i < symbolKeysLength; i++) {
70  // some old engines throws on access to some keys like `arguments` or `caller`
71  try {
72    var symbolKey = symbolKeys[i];
73    if (isSymbol(Symbol[symbolKey])) wellKnownSymbol(symbolKey);
74  } catch (error) { /* empty */ }
75}
76
77// `Symbol.isWellKnownSymbol` method
78// https://tc39.es/proposal-symbol-predicates/#sec-symbol-iswellknownsymbol
79// We should patch it for newly added well-known symbols. If it's not required, this module just will not be injected
80module.exports = function isWellKnownSymbol(value) {
81  if ($isWellKnownSymbol && $isWellKnownSymbol(value)) return true;
82  try {
83    var symbol = thisSymbolValue(value);
84    for (var j = 0, keys = getOwnPropertyNames(WellKnownSymbolsStore), keysLength = keys.length; j < keysLength; j++) {
85      // eslint-disable-next-line eqeqeq -- polyfilled symbols case
86      if (WellKnownSymbolsStore[keys[j]] == symbol) return true;
87    }
88  } catch (error) { /* empty */ }
89  return false;
90};
91
92
93/***/ }),
94
95/***/ "8c68":
96/***/ (function(module, exports, __webpack_require__) {
97
98"use strict";
99
100/* eslint-disable es/no-symbol -- required for testing */
101var V8_VERSION = __webpack_require__("4aa6");
102var fails = __webpack_require__("06fa");
103var global = __webpack_require__("3ac6");
104
105var $String = global.String;
106
107// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
108module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
109  var symbol = Symbol('symbol detection');
110  // Chrome 38 Symbol has incorrect toString conversion
111  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
112  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
113  // of course, fail.
114  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
115    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
116    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
117});
118
119
120/***/ }),
121
122/***/ "9691":
123/***/ (function(module, exports, __webpack_require__) {
124
125"use strict";
126
127var getBuiltIn = __webpack_require__("9883");
128var uncurryThis = __webpack_require__("ce18");
129
130var Symbol = getBuiltIn('Symbol');

131var keyFor = Symbol.keyFor;
132var thisSymbolValue = uncurryThis(Symbol.prototype.valueOf);
133
134// `Symbol.isRegisteredSymbol` method
135// https://tc39.es/proposal-symbol-predicates/#sec-symbol-isregisteredsymbol
136module.exports = Symbol.isRegisteredSymbol || function isRegisteredSymbol(value) {
137  try {
138    return keyFor(thisSymbolValue(value)) !== undefined;
139  } catch (error) {
140    return false;
141  }
142};
143
144
145/***/ }),
146
147/***/ "b0ea":
148/***/ (function(module, exports, __webpack_require__) {
149
150"use strict";
151
152var anObject = __webpack_require__("6f8d");
153var aConstructor = __webpack_require__("6783");
154var isNullOrUndefined = __webpack_require__("0b1d");
155var wellKnownSymbol = __webpack_require__("0363");
156
157var SPECIES = wellKnownSymbol('species');
158
159// `SpeciesConstructor` abstract operation
160// https://tc39.es/ecma262/#sec-speciesconstructor
161module.exports = function (O, defaultConstructor) {
162  var C = anObject(O).constructor;
163  var S;
164  return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);
165};
166
167
168/***/ }),
169
170/***/ "b1bc":
171/***/ (function(module, exports, __webpack_require__) {
172
173"use strict";
174
175// https://github.com/tc39/proposal-string-pad-start-end
176var uncurryThis = __webpack_require__("ce18");
177var toLength = __webpack_require__("6725");
178var toString = __webpack_require__("8c12");
179var $repeat = __webpack_require__("2cf1");
180var requireObjectCoercible = __webpack_require__("1875");
181
182var repeat = uncurryThis($repeat);
183var stringSlice = uncurryThis(''.slice);
184var ceil = Math.ceil;
185
186// `String.prototype.{ padStart, padEnd }` methods implementation
187var createMethod = function (IS_END) {
188  return function ($this, maxLength, fillString) {
189    var S = toString(requireObjectCoercible($this));
190    var intMaxLength = toLength(maxLength);
191    var stringLength = S.length;
192    var fillStr = fillString === undefined ? ' ' : toString(fillString);
193    var fillLen, stringFiller;
194    if (intMaxLength <= stringLength || fillStr === '') return S;
195    fillLen = intMaxLength - stringLength;
196    stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
197    if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);
198    return IS_END ? S + stringFiller : stringFiller + S;
199  };
200};
201
202module.exports = {
203  // `String.prototype.padStart` method
204  // https://tc39.es/ecma262/#sec-string.prototype.padstart
205  start: createMethod(false),
206  // `String.prototype.padEnd` method
207  // https://tc39.es/ecma262/#sec-string.prototype.padend
208  end: createMethod(true)
209};
210
211
212/***/ }),
213
214/***/ "bc316":
215/***/ (function(module, exports, __webpack_require__) {
216
217"use strict";
218
219var call = __webpack_require__("7106");
220var getBuiltIn = __webpack_require__("9883");
221var wellKnownSymbol = __webpack_require__("0363");
222var defineBuiltIn = __webpack_require__("fdbe");
223
224module.exports = function () {
225  var Symbol = getBuiltIn('Symbol');
226  var SymbolPrototype = Symbol && Symbol.prototype;
227  var valueOf = SymbolPrototype && SymbolPrototype.valueOf;
228  var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
229
230  if (SymbolPrototype && !SymbolPrototype[TO_PRIMITIVE]) {
231    // `Symbol.prototype[@@toPrimitive]` method
232    // https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
233    // eslint-disable-next-line no-unused-vars -- required for .length
234    defineBuiltIn(SymbolPrototype, TO_PRIMITIVE, function (hint) {
235      return call(valueOf, this);
236    }, { arity: 1 });
237  }
238};
239
240
241/***/ }),
242
243/***/ "cbd0":
244/***/ (function(module, exports, __webpack_require__) {
245
246"use strict";
247
248var uncurryThis = __webpack_require__("ce18");
249var toIntegerOrInfinity = __webpack_require__("c7d2");
250var toString = __webpack_require__("8c12");
251var requireObjectCoercible = __webpack_require__("1875");
252
253var charAt = uncurryThis(''.charAt);
254var charCodeAt = uncurryThis(''.charCodeAt);
255var stringSlice = uncurryThis(''.slice);
256
257var createMethod = function (CONVERT_TO_STRING) {
258  return function ($this, pos) {
259    var S = toString(requireObjectCoercible($this));
260    var position = toIntegerOrInfinity(pos);
261    var size = S.length;
262    var first, second;
263    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
264    first = charCodeAt(S, position);
265    return first < 0xD800 || first > 0xDBFF || position + 1 === size
266      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
267        ? CONVERT_TO_STRING
268          ? charAt(S, position)
269          : first
270        : CONVERT_TO_STRING
271          ? stringSlice(S, position, position + 2)
272          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
273  };
274};
275
276module.exports = {
277  // `String.prototype.codePointAt` method
278  // https://tc39.es/ecma262/#sec-string.prototype.codepointat
279  codeAt: createMethod(false),
280  // `String.prototype.at` method
281  // https://github.com/mathiasbynens/String.prototype.at
282  charAt: createMethod(true)
283};
284
285
286/***/ }),
287
288/***/ "cd24":
289/***/ (function(module, exports, __webpack_require__) {
290
291"use strict";
292
293// https://github.com/zloirock/core-js/issues/280
294var userAgent = __webpack_require__("9717");
295
296module.exports = /Version\/10(?:\.\d+){1,2}(?: [\w./]+)?(?: Mobile\/\w+)? Safari\//.test(userAgent);
297
298
299/***/ }),
300
301/***/ "e0b4":
302/***/ (function(module, exports, __webpack_require__) {
303
304"use strict";
305
306var NATIVE_SYMBOL = __webpack_require__("8c68");
307
308/* eslint-disable es/no-symbol -- safe */
309module.exports = NATIVE_SYMBOL && !!Symbol['for'] && !!Symbol.keyFor;
310
311
312/***/ }),
313
314/***/ "e7f1":
315/***/ (function(module, exports, __webpack_require__) {
316
317"use strict";
318
319// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
320var uncurryThis = __webpack_require__("ce18");
321
322var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
323var base = 36;
324var tMin = 1;
325var tMax = 26;
326var skew = 38;
327var damp = 700;
328var initialBias = 72;
329var initialN = 128; // 0x80
330var delimiter = '-'; // '\x2D'
331var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
332var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
333var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
334var baseMinusTMin = base - tMin;
335
336var $RangeError = RangeError;
337var exec = uncurryThis(regexSeparators.exec);
338var floor = Math.floor;
339var fromCharCode = String.fromCharCode;
340var charCodeAt = uncurryThis(''.charCodeAt);
341var join = uncurryThis([].join);
342var push = uncurryThis([].push);
343var replace = uncurryThis(''.replace);
344var split = uncurryThis(''.split);
345var toLowerCase = uncurryThis(''.toLowerCase);
346
347/**
348 * Creates an array containing the numeric code points of each Unicode
349 * character in the string. While JavaScript uses UCS-2 internally,
350 * this function will convert a pair of surrogate halves (each of which
351 * UCS-2 exposes as separate characters) into a single code point,
352 * matching UTF-16.
353 */
354var ucs2decode = function (string) {
355  var output = [];
356  var counter = 0;
357  var length = string.length;
358  while (counter < length) {
359    var value = charCodeAt(string, counter++);
360    if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
361      // It's a high surrogate, and there is a next character.
362      var extra = charCodeAt(string, counter++);
363      if ((extra & 0xFC00) === 0xDC00) { // Low surrogate.
364        push(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
365      } else {
366        // It's an unmatched surrogate; only append this code unit, in case the
367        // next code unit is the high surrogate of a surrogate pair.
368        push(output, value);
369        counter--;
370      }
371    } else {
372      push(output, value);
373    }
374  }
375  return output;
376};
377
378/**
379 * Converts a digit/integer into a basic code point.
380 */
381var digitToBasic = function (digit) {
382  //  0..25 map to ASCII a..z or A..Z
383  // 26..35 map to ASCII 0..9
384  return digit + 22 + 75 * (digit < 26);
385};
386
387/**
388 * Bias adaptation function as per section 3.4 of RFC 3492.
389 * https://tools.ietf.org/html/rfc3492#section-3.4
390 */
391var adapt = function (delta, numPoints, firstTime) {
392  var k = 0;
393  delta = firstTime ? floor(delta / damp) : delta >> 1;
394  delta += floor(delta / numPoints);
395  while (delta > baseMinusTMin * tMax >> 1) {
396    delta = floor(delta / baseMinusTMin);
397    k += base;
398  }
399  return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
400};
401
402/**
403 * Converts a string of Unicode symbols (e.g. a domain name label) to a
404 * Punycode string of ASCII-only symbols.
405 */
406var encode = function (input) {
407  var output = [];
408
409  // Convert the input in UCS-2 to an array of Unicode code points.
410  input = ucs2decode(input);
411
412  // Cache the length.
413  var inputLength = input.length;
414
415  // Initialize the state.
416  var n = initialN;
417  var delta = 0;
418  var bias = initialBias;
419  var i, currentValue;
420
421  // Handle the basic code points.
422  for (i = 0; i < input.length; i++) {
423    currentValue = input[i];
424    if (currentValue < 0x80) {
425      push(output, fromCharCode(currentValue));
426    }
427  }
428
429  var basicLength = output.length; // number of basic code points.
430  var handledCPCount = basicLength; // number of code points that have been handled;
431
432  // Finish the basic string with a delimiter unless it's empty.
433  if (basicLength) {
434    push(output, delimiter);
435  }
436
437  // Main encoding loop:
438  while (handledCPCount < inputLength) {
439    // All non-basic code points < n have been handled already. Find the next larger one:
440    var m = maxInt;
441    for (i = 0; i < input.length; i++) {
442      currentValue = input[i];
443      if (currentValue >= n && currentValue < m) {
444        m = currentValue;
445      }
446    }
447
448    // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
449    var handledCPCountPlusOne = handledCPCount + 1;
450    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
451      throw new $RangeError(OVERFLOW_ERROR);
452    }
453
454    delta += (m - n) * handledCPCountPlusOne;
455    n = m;
456
457    for (i = 0; i < input.length; i++) {
458      currentValue = input[i];
459      if (currentValue < n && ++delta > maxInt) {
460        throw new $RangeError(OVERFLOW_ERROR);
461      }
462      if (currentValue === n) {
463        // Represent delta as a generalized variable-length integer.
464        var q = delta;
465        var k = base;
466        while (true) {
467          var t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
468          if (q < t) break;
469          var qMinusT = q - t;
470          var baseMinusT = base - t;
471          push(output, fromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
472          q = floor(qMinusT / baseMinusT);
473          k += base;
474        }
475
476        push(output, fromCharCode(digitToBasic(q)));
477        bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
478        delta = 0;
479        handledCPCount++;
480      }
481    }
482
483    delta++;
484    n++;
485  }
486  return join(output, '');
487};
488
489module.exports = function (input) {
490  var encoded = [];
491  var labels = split(replace(toLowerCase(input), regexSeparators, '\u002E'), '.');
492  var i, label;
493  for (i = 0; i < labels.length; i++) {
494    label = labels[i];
495    push(encoded, exec(regexNonASCII, label) ? 'xn--' + encode(label) : label);
496  }
497  return join(encoded, '.');
498};
499
500
501/***/ }),
502
503/***/ "ff96":
504/***/ (function(module, exports, __webpack_require__) {
505
506"use strict";
507
508var uncurryThis = __webpack_require__("ce18");
509var requireObjectCoercible = __webpack_require__("1875");
510var toString = __webpack_require__("8c12");
511var whitespaces = __webpack_require__("81f0");
512
513var replace = uncurryThis(''.replace);
514var ltrim = RegExp('^[' + whitespaces + ']+');
515var rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');
516
517// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
518var createMethod = function (TYPE) {
519  return function ($this) {
520    var string = toString(requireObjectCoercible($this));
521    if (TYPE & 1) string = replace(string, ltrim, '');
522    if (TYPE & 2) string = replace(string, rtrim, '$1');
523    return string;
524  };
525};
526
527module.exports = {
528  // `String.prototype.{ trimLeft, trimStart }` methods
529  // https://tc39.es/ecma262/#sec-string.prototype.trimstart
530  start: createMethod(1),
531  // `String.prototype.{ trimRight, trimEnd }` methods
532  // https://tc39.es/ecma262/#sec-string.prototype.trimend
533  end: createMethod(2),
534  // `String.prototype.trim` method
535  // https://tc39.es/ecma262/#sec-string.prototype.trim
536  trim: createMethod(3)
537};
538
539
540/***/ })
541
542}]);