https://minhaescola.app/js/chunk-vendors~79ccc924.3ed9805e.js

1(window["webpackJsonp"] = window["webpackJsonp"] || []).push([["chunk-vendors~79ccc924"],{
2
3/***/ "0d25":
4/***/ (function(module, exports, __webpack_require__) {
5
6"use strict";
7
8
9/** @type {import('./type')} */
10module.exports = TypeError;
11
12
13/***/ }),
14
15/***/ "1409":
16/***/ (function(module, exports, __webpack_require__) {
17
18"use strict";
19
20
21/** @type {import('./ref')} */
22module.exports = ReferenceError;
23
24
25/***/ }),
26
27/***/ "417f":
28/***/ (function(module, exports, __webpack_require__) {
29
30"use strict";
31
32
33/** @type {import('./eval')} */
34module.exports = EvalError;
35
36
37/***/ }),
38
39/***/ "67d9":
40/***/ (function(module, exports, __webpack_require__) {
41
42"use strict";
43
44
45/** @type {import('./uri')} */
46module.exports = URIError;
47
48
49/***/ }),
50
51/***/ "67ee":
52/***/ (function(module, exports, __webpack_require__) {
53
54"use strict";
55
56
57/** @type {import('./syntax')} */
58module.exports = SyntaxError;
59
60
61/***/ }),
62
63/***/ "a645":
64/***/ (function(module, exports, __webpack_require__) {
65
66"use strict";
67
68
69/** @type {import('.')} */
70module.exports = Error;
71
72
73/***/ }),
74
75/***/ "ae84":
76/***/ (function(module, exports, __webpack_require__) {
77
78var Buffer = __webpack_require__("8707").Buffer
79var MD5 = __webpack_require__("f576")
80
81/* eslint-disable camelcase */
82function EVP_BytesToKey (password, salt, keyBits, ivLen) {
83  if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')
84  if (salt) {
85    if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')
86    if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length')
87  }
88
89  var keyLen = keyBits / 8
90  var key = Buffer.alloc(keyLen)
91  var iv = Buffer.alloc(ivLen || 0)
92  var tmp = Buffer.alloc(0)
93
94  while (keyLen > 0 || ivLen > 0) {
95    var hash = new MD5()
96    hash.update(tmp)
97    hash.update(password)
98    if (salt) hash.update(salt)
99    tmp = hash.digest()
100
101    var used = 0
102
103    if (keyLen > 0) {
104      var keyStart = key.length - keyLen
105      used = Math.min(keyLen, tmp.length)
106      tmp.copy(key, keyStart, 0, used)
107      keyLen -= used
108    }
109
110    if (used < tmp.length && ivLen > 0) {
111      var ivStart = iv.length - ivLen
112      var length = Math.min(ivLen, tmp.length - used)
113      tmp.copy(iv, ivStart, used, used + length)
114      ivLen -= length
115    }
116  }
117
118  tmp.fill(0)
119  return { key: key, iv: iv }
120}
121
122module.exports = EVP_BytesToKey
123
124
125/***/ }),
126
127/***/ "dc99":
128/***/ (function(module, exports, __webpack_require__) {
129
130"use strict";
131
132
133/** @type {import('./range')} */
134module.exports = RangeError;
135
136
137/***/ }),
138
139/***/ "faa1":
140/***/ (function(module, exports, __webpack_require__

140) {
141
142"use strict";
143// Copyright Joyent, Inc. and other Node contributors.
144//
145// Permission is hereby granted, free of charge, to any person obtaining a
146// copy of this software and associated documentation files (the
147// "Software"), to deal in the Software without restriction, including
148// without limitation the rights to use, copy, modify, merge, publish,
149// distribute, sublicense, and/or sell copies of the Software, and to permit
150// persons to whom the Software is furnished to do so, subject to the
151// following conditions:
152//
153// The above copyright notice and this permission notice shall be included
154// in all copies or substantial portions of the Software.
155//
156// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
157// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
158// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
159// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
160// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
161// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
162// USE OR OTHER DEALINGS IN THE SOFTWARE.
163
164
165
166var R = typeof Reflect === 'object' ? Reflect : null
167var ReflectApply = R && typeof R.apply === 'function'
168  ? R.apply
169  : function ReflectApply(target, receiver, args) {
170    return Function.prototype.apply.call(target, receiver, args);
171  }
172
173var ReflectOwnKeys
174if (R && typeof R.ownKeys === 'function') {
175  ReflectOwnKeys = R.ownKeys
176} else if (Object.getOwnPropertySymbols) {
177  ReflectOwnKeys = function ReflectOwnKeys(target) {
178    return Object.getOwnPropertyNames(target)
179      .concat(Object.getOwnPropertySymbols(target));
180  };
181} else {
182  ReflectOwnKeys = function ReflectOwnKeys(target) {
183    return Object.getOwnPropertyNames(target);
184  };
185}
186
187function ProcessEmitWarning(warning) {
188  if (console && console.warn) console.warn(warning);
189}
190
191var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
192  return value !== value;
193}
194
195function EventEmitter() {
196  EventEmitter.init.call(this);
197}
198module.exports = EventEmitter;
199module.exports.once = once;
200
201// Backwards-compat with node 0.10.x
202EventEmitter.EventEmitter = EventEmitter;
203
204EventEmitter.prototype._events = undefined;
205EventEmitter.prototype._eventsCount = 0;
206EventEmitter.prototype._maxListeners = undefined;
207
208// By default EventEmitters will print a warning if more than 10 listeners are
209// added to it. This is a useful default which helps finding memory leaks.
210var defaultMaxListeners = 10;
211
212function checkListener(listener) {
213  if (typeof listener !== 'function') {
214    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
215  }
216}
217
218Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
219  enumerable: true,
220  get: function() {
221    return defaultMaxListeners;
222  },
223  set: function(arg) {
224    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
225      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
226    }
227    defaultMaxListeners = arg;
228  }
229});
230
231EventEmitter.init = function() {
232
233  if (this._events === undefined ||
234      this._events === Object.getPrototypeOf(this)._events) {
235    this._events = Object.create(null);
236    this._eventsCount = 0;
237  }
238
239  this._maxListeners = this._maxListeners || undefined;
240};
241
242// Obviously not all Emitters should be limited to 10. This function allows
243// that to be increased. Set to zero for unlimited.
244EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
245  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
246    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
247  }
248  this._maxListeners = n;
249  return this;
250};
251
252function _getMaxListeners(that) {
253  if (that._maxListeners === undefined)
254    return EventEmitter.defaultMaxListeners;
255  return that._maxListeners;
256}
257
258EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
259  return _getMaxListeners(this);
260};
261
262EventEmitter.prototype.emit = function emit(type) {
263  var args = [];
264  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
265  var doError = (type === 'error');
266
267  var events = this._events;
268  if (events !== undefined)
269    doError = (doError && events.error === undefined);
270  else if (!doError)
271    return false;

272
273  // If there is no 'error' event listener then throw.
274  if (doError) {
275    var er;
276    if (args.length > 0)
277      er = args[0];
278    if (er instanceof Error) {
279      // Note: The comments on the `throw` lines are intentional, they show
280      // up in Node's output if this results in an unhandled exception.
281      throw er; // Unhandled 'error' event
282    }
283    // At least give some kind of context to the user
284    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
285    err.context = er;
286    throw err; // Unhandled 'error' event
287  }
288
289  var handler = events[type];
290
291  if (handler === undefined)
292    return false;
293
294  if (typeof handler === 'function') {
295    ReflectApply(handler, this, args);
296  } else {
297    var len = handler.length;
298    var listeners = arrayClone(handler, len);
299    for (var i = 0; i < len; ++i)
300      ReflectApply(listeners[i], this, args);
301  }
302
303  return true;
304};
305
306function _addListener(target, type, listener, prepend) {
307  var m;
308  var events;
309  var existing;
310
311  checkListener(listener);
312
313  events = target._events;
314  if (events === undefined) {
315    events = target._events = Object.create(null);
316    target._eventsCount = 0;
317  } else {
318    // To avoid recursion in the case that type === "newListener"! Before
319    // adding it to the listeners, first emit "newListener".
320    if (events.newListener !== undefined) {
321      target.emit('newListener', type,
322                  listener.listener ? listener.listener : listener);
323
324      // Re-assign `events` because a newListener handler could have caused the
325      // this._events to be assigned to a new object
326      events = target._events;
327    }
328    existing = events[type];
329  }
330
331  if (existing === undefined) {
332    // Optimize the case of one listener. Don't need the extra array object.
333    existing = events[type] = listener;
334    ++target._eventsCount;
335  } else {
336    if (typeof existing === 'function') {
337      // Adding the second element, need to change to array.
338      existing = events[type] =
339        prepend ? [listener, existing] : [existing, listener];
340      // If we've already got an array, just append.
341    } else if (prepend) {
342      existing.unshift(listener);
343    } else {
344      existing.push(listener);
345    }
346
347    // Check for listener leak
348    m = _getMaxListeners(target);
349    if (m > 0 && existing.length > m && !existing.warned) {
350      existing.warned = true;
351      // No error code for this since it is a Warning
352      // eslint-disable-next-line no-restricted-syntax
353      var w = new Error('Possible EventEmitter memory leak detected. ' +
354                          existing.length + ' ' + String(type) + ' listeners ' +
355                          'added. Use emitter.setMaxListeners() to ' +
356                          'increase limit');
357      w.name = 'MaxListenersExceededWarning';
358      w.emitter = target;
359      w.type = type;
360      w.count = existing.length;
361      ProcessEmitWarning(w);
362    }
363  }
364
365  return target;
366}
367
368EventEmitter.prototype.addListener = function addListener(type, listener) {
369  return _addListener(this, type, listener, false);
370};
371
372EventEmitter.prototype.on = EventEmitter.prototype.addListener;
373
374EventEmitter.prototype.prependListener =
375    function prependListener(type, listener) {
376      return _addListener(this, type, listener, true);
377    };
378
379function onceWrapper() {
380  if (!this.fired) {
381    this.target.removeListener(this.type, this.wrapFn);
382    this.fired = true;
383    if (arguments.length === 0)
384      return this.listener.call(this.target);
385    return this.listener.apply(this.target, arguments);
386  }
387}
388
389function _onceWrap(target, type, listener) {
390  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
391  var wrapped = onceWrapper.bind(state);
392  wrapped.listener = listener;
393  state.wrapFn = wrapped;
394  return wrapped;
395}
396
397EventEmitter.prototype.once = function once(type, listener) {
398  checkListener(listener);
399  this.on(type, _onceWrap(this, type, listener));
400  return this;
401};
402
403EventEmitter.prototype.prependOnceListener =
404    function prependOnceListener(type, listener) {
405      checkListener(listener);
406      this.prependListener(type, _onceWrap(this, type, listener));
407      return this;
408    };
409
410// Emits a 'removeListener' event if and only if the listener was removed.
411EventEmitter.prototype.removeListener =
412    function removeListener(type, listener) {
413      var list, events, position, i, originalListener;
414
415      checkListener(listener);
416
417      events = this._events;
418      if (events === undefined)
419        return this;
420
421      list = events[type];
422      if (list === undefined)
423        return this;
424
425      if (list === listener || list.listener === listener) {
426        if (--this._eventsCount === 0)
427          this._events = Object.create(null);
428        else {
429          delete events[type];
430          if (events.removeListener)
431            this.emit('removeListener', type, list.listener || listener);
432        }
433      } else if (typeof list !== 'function') {
434        position = -1;
435
436        for (i = list.length - 1; i >= 0; i--) {
437          if (list[i] === listener || list[i].listener === listener) {
438            originalListener = list[i].listener;
439            position = i;
440            break;
441          }
442        }
443
444        if (position < 0)
445          return this;
446
447        if (position === 0)
448          list.shift();
449        else {
450          spliceOne(list, position);
451        }
452
453        if (list.length === 1)
454          events[type] = list[0];
455
456        if (events.removeListener !== undefined)
457          this.emit('removeListener', type, originalListener || listener);
458      }
459
460      return this;
461    };
462
463EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
464
465EventEmitter.prototype.removeAllListeners =
466    function removeAllListeners(type) {
467      var listeners, events, i;
468
469      events = this._events;
470      if (events === undefined)
471        return this;
472
473      // not listening for removeListener, no need to emit
474      if (events.removeListener === undefined) {
475        if (arguments.length === 0) {
476          this._events = Object.create(null);
477          this._eventsCount = 0;
478        } else if (events[type] !== undefined) {
479          if (--this._eventsCount === 0)
480            this._events = Object.create(null);
481          else
482            delete events[type];
483        }
484        return this;
485      }
486
487      // emit removeListener for all listeners on all events
488      if (arguments.length === 0) {
489        var keys = Object.keys(events);
490        var key;
491        for (i = 0; i < keys.length; ++i) {
492          key = keys[i];
493          if (key === 'removeListener') continue;
494          this.removeAllListeners(key);
495        }
496        this.removeAllListeners('removeListener');
497        this._events = Object.create(null);
498        this._eventsCount = 0;
499        return this;
500      }
501
502      listeners = events[type];
503
504      if (typeof listeners === 'function') {
505        this.removeListener(type, listeners);
506      } else if (listeners !== undefined) {
507        // LIFO order
508        for (i = listeners.length - 1; i >= 0; i--) {
509          this.removeListener(type, listeners[i]);
510        }
511      }
512
513      return this;
514    };
515
516function _listeners(target, type, unwrap) {
517  var events = target._events;
518
519  if (events === undefined)
520    return [];
521
522  var evlistener = events[type];
523  if (evlistener === undefined)
524    return [];
525
526  if (typeof evlistener === 'function')
527    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
528
529  return unwrap ?
530    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
531}
532
533EventEmitter.prototype.listeners = function listeners(type) {
534  return _listeners(this, type, true);
535};
536
537EventEmitter.prototype.rawListeners = function rawListeners(type) {
538  return _listeners(this, type, false);
539};
540
541EventEmitter.listenerCount = function(emitter, type) {
542  if (typeof emitter.listenerCount === 'function') {
543    return emitter.listenerCount(type);
544  } else {
545    return listenerCount.call(emitter, type);
546  }
547};
548
549EventEmitter.prototype.listenerCount = listenerCount;
550function listenerCount(type) {
551  var events = this._events;
552
553  if (events !== undefined) {
554    var evlistener = events[type];
555
556    if (typeof evlistener === 'function') {
557      return 1;
558    } else if (evlistener !== undefined) {
559      return evlistener.length;
560    }
561  }
562
563  return 0;
564}
565
566EventEmitter.prototype.eventNames = function eventNames() {
567  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
568};
569
570function arrayClone(arr, n) {
571  var copy = new Array(n);
572  for (var i = 0; i < n; ++i)
573    copy[i] = arr[i];
574  return copy;
575}
576
577function spliceOne(list, index) {
578  for (; index + 1 < list.length; index++)
579    list[index] = list[index + 1];
580  list.pop();
581}
582
583function unwrapListeners(arr) {
584  var ret = new Array(arr.length);
585  for (var i = 0; i < ret.length; ++i) {
586    ret[i] = arr[i].listener || arr[i];
587  }
588  return ret;
589}
590
591function once(emitter, name) {
592  return new Promise(function (resolve, reject) {
593    function errorListener(err) {
594      emitter.removeListener(name, resolver);
595      reject(err);
596    }
597
598    function resolver() {
599      if (typeof emitter.removeListener === 'function') {
600        emitter.removeListener('error', errorListener);
601      }
602      resolve([].slice.call(arguments));
603    };
604
605    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
606    if (name !== 'error') {
607      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
608    }
609  });
610}
611
612function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
613  if (typeof emitter.on === 'function') {
614    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
615  }
616}
617
618function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
619  if (typeof emitter.on === 'function') {
620    if (flags.once) {
621      emitter.once(name, listener);
622    } else {
623      emitter.on(name, listener);
624    }
625  } else if (typeof emitter.addEventListener === 'function') {
626    // EventTarget does not have `error` event semantics like Node
627    // EventEmitters, we do not listen for `error` events here.
628    emitter.addEventListener(name, function wrapListener(arg) {
629      // IE does not have builtin `{ once: true }` support so we
630      // have to do it manually.
631      if (flags.once) {
632        emitter.removeEventListener(name, wrapListener);
633      }
634      listener(arg);
635    });
636  } else {
637    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
638  }
639}
640
641
642/***/ })