https://jayreddinjr-jr-odysseus-hf.hf.space/static/lib/docx.umd.min.js

207    }
208  });
209  EventEmitter.init = function() {
210    if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
211      this._events = /* @__PURE__ */ Object.create(null);
212      this._eventsCount = 0;
213    }
214    this._maxListeners = this._maxListeners || void 0;
215  };
216  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
217    if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
218      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
219    }
220    this._maxListeners = n;
221    return this;
222  };
223  function _getMaxListeners(that) {
224    if (that._maxListeners === void 0)
225      return EventEmitter.defaultMaxListeners;
226    return that._maxListeners;
227  }
228  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
229    return _getMaxListeners(this);
230  };
231  EventEmitter.prototype.emit = function emit(type) {
232    var args = [];
233    for (var i = 1; i < arguments.length; i++)
234      args.push(arguments[i]);
235    var doError = type === "error";
236    var events2 = this._events;
237    if (events2 !== void 0)
238      doError = doError && events2.error === void 0;
239    else if (!doError)
240      return false;
241    if (doError) {
242      var er;
243      if (args.length > 0)
244        er = args[0];
245      if (er instanceof Error) {
246        throw er;
247      }
248      var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
249      err.context = er;
250      throw err;
251    }
252    var handler = events2[type];
253    if (handler === void 0)
254      return false;
255    if (typeof handler === "function") {
256      ReflectApply(handler, this, args);
257    } else {
258      var len = handler.length;
259      var listeners = arrayClone(handler, len);
260      for (var i = 0; i < len; ++i)
261        ReflectApply(listeners[i], this, args);
262    }
263    return true;
264  };
265  function _addListener(target, type, listener, prepend) {
266    var m;
267    var events2;
268    var existing;
269    checkListener(listener);
270    events2 = target._events;
271    if (events2 === void 0) {
272      events2 = target._events = /* @__PURE__ */ Object.create(null);
273      target._eventsCount = 0;
274    } else {
275      if (events2.newListener !== void 0) {
276        target.emit(
277          "newListener",
278          type,
279          listener.listener ? listener.listener : listener
280        );
281        events2 = target._events;
282      }
283      existing = events2[type];
284    }
285    if (existing === void 0) {
286      existing = events2[type] = listener;
287      ++target._eventsCount;
288    } else {
289      if (typeof existing === "function") {
290        existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
291      } else if (prepend) {
292        existing.unshift(listener);
293      } else {
294        existing.push(listener);
295      }
296      m = _getMaxListeners(target);
297      if (m > 0 && existing.length > m && !existing.warned) {
298        existing.warned = true;
299        var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
300        w.name = "MaxListenersExceededWarning";
301        w.emitter = target;
302        w.type = type;
303        w.count = existing.length;
304        ProcessEmitWarning(w);
305      }
306    }
307    return target;
308  }
309  EventEmitter.prototype.addListener = function addListener(type, listener) {
310    return _addListener(this, type, listener, false);
311  };
312  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
313  EventEmitter.prototype.prependListener = function prependListener(type, listener) {
314    return _addListener(this, type, listener, true);
315  };
316  function onceWrapper() {
317    if (!this.fired) {
318      this.target.removeListener(this.type, this.wrapFn);
319      this.fired = true;
320      if (arguments.length === 0)
321        return this.listener.call(this.target);
322      return this.listener.apply(this.target, arguments);
323    }
324  }
325  function _onceWrap(target, type, listener) {
326    var state2 = { fired: false, wrapFn: void 0, target, type, listener };
327    var wrapped = onceWrapper.bind(state2);
328    wrapped.listener = listener;
329    state2.wrapFn = wrapped;
330    return wrapped;
331  }
332  EventEmitter.prototype.once = function once2(type, listener) {
333    checkListener(listener);
334    this.on(type, _onceWrap(this, type, listener));
335    return this;
336  };
337  EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
338    checkListener(listener);
339    this.prependListener(type, _onceWrap(this, type, listener));
340    return this;
341  };
342  EventEmitter.prototype.removeListener = function removeListener(type, listener) {
343    var list, events2, position, i, originalListener;
344    checkListener(listener);
345    events2 = this._events;
346    if (events2 === void 0)
347      return this;
348    list = events2[type];
349    if (list === void 0)
350      return this;
351    if (list === listener || list.listener === listener) {
352      if (--this._eventsCount === 0)
353        this._events = /* @__PURE__ */ Object.create(null);
354      else {
355        delete events2[type];
356        if (events2.removeListener)
357          this.emit("removeListener", type, list.listener || listener);
358      }
359    } else if (typeof list !== "function") {
360      position = -1;
361      for (i = list.length - 1; i >= 0; i--) {
362        if (list[i] === listener || list[i].listener === listener) {
363          originalListener = list[i].listener;
364          position = i;
365          break;
366        }
367      }
368      if (position < 0)
369        return this;
370      if (position === 0)
371        list.shift();
372      else {
373        spliceOne(list, position);
374      }
375      if (list.length === 1)
376        events2[type] = list[0];
377      if (events2.removeListener !== void 0)
378        this.emit("removeListener", type, originalListener || listener);
379    }
380    return this;
381  };
382  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
383  EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
384    var listeners, events2, i;
385    events2 = this._events;
386    if (events2 === void 0)
387      return this;
388    if (events2.removeListener === void 0) {
389      if (arguments.length === 0) {
390        this._events = /* @__PURE__ */ Object.create(null);
391        this._eventsCount = 0;
392      } else if (events2[type] !== void 0) {
393        if (--this._eventsCount === 0)
394          this._events = /* @__PURE__ */ Object.create(null);
395        else
396          delete events2[type];
397      }
398      return this;
399    }
400    if (arguments.length === 0) {
401      var keys = Object.keys(events2);
402      var key;
403      for (i = 0; i < keys.length; ++i) {
404        key = keys[i];
405        if (key === "removeListener")
406          continue;
407        this.removeAllListeners(key);
408      }
409      this.removeAllListeners("removeListener");
410      this._events = /* @__PURE__ */ Object.create(null);
411      this._eventsCount = 0;
412      return this;
413    }
414    listeners = events2[type];
415    if (typeof listeners === "function") {
416      this.removeListener(type, listeners);
417    } else if (listeners !== void 0) {
418      for (i = listeners.length - 1; i >= 0; i--) {
419        this.removeListener(type, listeners[i]);
420      }
421    }
422    return this;
423  };
424  function _listeners(target, type, unwrap) {
425    var events2 = target._events;
426    if (events2 === void 0)
427      return [];
428    var evlistener = events2[type];
429    if (evlistener === void 0)
430      return [];
431    if (typeof evlistener === "function")
432      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
433    return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
434  }
435  EventEmitter.prototype.listeners = function listeners(type) {
436    return _listeners(this, type, true);
437  };
438  EventEmitter.prototype.rawListeners = function rawListeners(type) {
439    return _listeners(this, type, false);
440  };
441  EventEmitter.listenerCount = function(emitter, type) {
442    if (typeof emitter.listenerCount === "function") {
443      return emitter.listenerCount(type);
444    } else {
445      return listenerCount.call(emitter, type);
446    }
447  };
448  EventEmitter.prototype.listenerCount = listenerCount;
449  function listenerCount(type) {
450    var events2 = this._events;
451    if (events2 !== void 0) {
452      var evlistener = events2[type];
453      if (typeof evlistener === "function") {
454        return 1;
455      } else if (evlistener !== void 0) {
456        return evlistener.length;
457      }
458    }
459    return 0;
460  }
461  EventEmitter.prototype.eventNames = function eventNames() {
462    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
463  };
464  function arrayClone(arr, n) {
465    var copy = new Array(n);
466    for (var i = 0; i < n; ++i)
467      copy[i] = arr[i];
468    return copy;
469  }
470  function spliceOne(list, index) {
471    for (; index + 1 < list.length; index++)
472      list[index] = list[index + 1];
473    list.pop();
474  }
475  function unwrapListeners(arr) {
476    var ret = new Array(arr.length);
477    for (var i = 0; i < ret.length; ++i) {
478      ret[i] = arr[i].listener || arr[i];
479    }
480    return ret;
481  }
482  function once(emitter, name) {
483    return new Promise(function(resolve2, reject) {
484      function errorListener(err) {
485        emitter.removeListener(name, resolver);
486        reject(err);
487      }
488      function resolver() {
489        if (typeof emitter.removeListener === "function") {
490          emitter.removeListener("error", errorListener);
491        }
492        resolve2([].slice.call(arguments));
493      }
494      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
495      if (name !== "error") {
496        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
497      }
498    });
499  }
500  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
501    if (typeof emitter.on === "function") {
502      eventTargetAgnosticAddListener(emitter, "error", handler, flags);
503    }
504  }
505  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
506    if (typeof emitter.on === "function") {
507      if (flags.once) {
508        emitter.once(name, listener);
509      } else {
510        emitter.on(name, listener);
511      }
512    } else if (typeof emitter.addEventListener === "function") {
513      emitter.addEventListener(name, function wrapListener(arg) {
514        if (flags.once) {
515          emitter.removeEventListener(name, wrapListener);
516        }
517        listener(arg);
518      });
519    } else {
520      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
521    }
522  }
523  var eventsExports = events.exports;
524  var inherits_browser = { exports: {} };
525  if (typeof Object.create === "function") {

526    inherits_browser.exports = function inherits2(ctor, superCtor) {
527      if (superCtor) {
528        ctor.super_ = superCtor;
529        ctor.prototype = Object.create(superCtor.prototype, {
530          constructor: {
531            value: ctor,
532            enumerable: false,
533            writable: true,
534            configurable: true
535          }
536        });
537      }
538    };
539  } else {
540    inherits_browser.exports = function inherits2(ctor, superCtor) {
541      if (superCtor) {
542        ctor.super_ = superCtor;
543        var TempCtor = function() {
544        };
545        TempCtor.prototype = superCtor.prototype;
546        ctor.prototype = new TempCtor();
547        ctor.prototype.constructor = ctor;
548      }
549    };
550  }
551  var inherits_browserExports = inherits_browser.exports;
552  function getDefaultExportFromCjs(x) {
553    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
554  }
555  var browser$1 = { exports: {} };
556  var process = browser$1.exports = {};
557  var cachedSetTimeout;
558  var cachedClearTimeout;
559  function defaultSetTimout() {
560    throw new Error("setTimeout has not been defined");
561  }
562  function defaultClearTimeout() {
563    throw new Error("clearTimeout has not been defined");
564  }
565  (function() {
566    try {
567      if (typeof setTimeout === "function") {
568        cachedSetTimeout = setTimeout;
569      } else {
570        cachedSetTimeout = defaultSetTimout;
571      }
572    } catch (e) {
573      cachedSetTimeout = defaultSetTimout;
574    }
575    try {
576      if (typeof clearTimeout === "function") {
577        cachedClearTimeout = clearTimeout;
578      } else {
579        cachedClearTimeout = defaultClearTimeout;
580      }
581    } catch (e) {
582      cachedClearTimeout = defaultClearTimeout;
583    }
584  })();
585  function runTimeout(fun) {
586    if (cachedSetTimeout === setTimeout) {
587      return setTimeout(fun, 0);
588    }
589    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
590      cachedSetTimeout = setTimeout;
591      return setTimeout(fun, 0);
592    }
593    try {
594      return cachedSetTimeout(fun, 0);
595    } catch (e) {
596      try {
597        return cachedSetTimeout.call(null, fun, 0);
598      } catch (e2) {
599        return cachedSetTimeout.call(this, fun, 0);
600      }
601    }
602  }
603  function runClearTimeout(marker) {
604    if (cachedClearTimeout === clearTimeout) {
605      return clearTimeout(marker);
606    }
607    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
608      cachedClearTimeout = clearTimeout;
609      return clearTimeout(marker);
610    }
611    try {
612      return cachedClearTimeout(marker);
613    } catch (e) {
614      try {
615        return cachedClearTimeout.call(null, marker);
616      } catch (e2) {
617        return cachedClearTimeout.call(this, marker);
618      }
619    }
620  }
621  var queue = [];
622  var draining = false;
623  var currentQueue;
624  var queueIndex = -1;
625  function cleanUpNextTick() {
626    if (!draining || !currentQueue) {
627      return;
628    }
629    draining = false;
630    if (currentQueue.length) {
631      queue = currentQueue.concat(queue);
632    } else {
633      queueIndex = -1;
634    }
635    if (queue.length) {
636      drainQueue();
637    }
638  }
639  function drainQueue() {
640    if (draining) {
641      return;
642    }
643    var timeout = runTimeout(cleanUpNextTick);
644    draining = true;
645    var len = queue.length;
646    while (len) {
647      currentQueue = queue;
648      queue = [];
649      while (++queueIndex < len) {
650        if (currentQueue) {
651          currentQueue[queueIndex].run();
652        }
653      }
654      queueIndex = -1;
655      len = queue.length;
656    }
657    currentQueue = null;
658    draining = false;
659    runClearTimeout(timeout);
660  }
661  process.nextTick = function(fun) {
662    var args = new Array(arguments.length - 1);
663    if (arguments.length > 1) {
664      for (var i = 1; i < arguments.length; i++) {
665        args[i - 1] = arguments[i];
666      }
667    }
668    queue.push(new Item(fun, args));
669    if (queue.length === 1 && !draining) {
670      runTimeout(drainQueue);
671    }
672  };
673  function Item(fun, array) {
674    this.fun = fun;
675    this.array = array;
676  }
677  Item.prototype.run = function() {
678    this.fun.apply(null, this.array);
679  };
680  process.title = "browser";
681  process.browser = true;
682  process.env = {};
683  process.argv = [];
684  process.version = "";
685  process.versions = {};
686  function noop() {
687  }
688  process.on = noop;
689  process.addListener = noop;
690  process.once = noop;
691  process.off = noop;
692  process.removeListener = noop;
693  process.removeAllListeners = noop;
694  process.emit = noop;
695  process.prependListener = noop;
696  process.prependOnceListener = noop;
697  process.listeners = function(name) {
698    return [];
699  };
700  process.binding = function(name) {
701    throw new Error("process.binding is not supported");
702  };
703  process.cwd = function() {
704    return "/";
705  };
706  process.chdir = function(dir) {
707    throw new Error("process.chdir is not supported");
708  };
709  process.umask = function() {
710    return 0;
711  };
712  var browserExports = browser$1.exports;
713  const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
714  var streamBrowser;
715  var hasRequiredStreamBrowser;
716  function requireStreamBrowser() {
717    if (hasRequiredStreamBrowser)
718      return streamBrowser;
719    hasRequiredStreamBrowser = 1;
720    streamBrowser = eventsExports.EventEmitter;
721    return streamBrowser;
722  }
723  var buffer = {};
724  var base64Js = {};
725  var hasRequiredBase64Js;
726  function requireBase64Js() {
727    if (hasRequiredBase64Js)
728      return base64Js;
729    hasRequiredBase64Js = 1;
730    base64Js.byteLength = byteLength;
731    base64Js.toByteArray = toByteArray;
732    base64Js.fromByteArray = fromByteArray;
733    var lookup = [];
734    var revLookup = [];
735    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
736    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

736+/";
737    for (var i = 0, len = code.length; i < len; ++i) {
738      lookup[i] = code[i];
739      revLookup[code.charCodeAt(i)] = i;
740    }
741    revLookup["-".charCodeAt(0)] = 62;
742    revLookup["_".charCodeAt(0)] = 63;
743    function getLens(b64) {
744      var len2 = b64.length;
745      if (len2 % 4 > 0) {
746        throw new Error("Invalid string. Length must be a multiple of 4");
747      }
748      var validLen = b64.indexOf("=");
749      if (validLen === -1)
750        validLen = len2;
751      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
752      return [validLen, placeHoldersLen];
753    }
754    function byteLength(b64) {
755      var lens = getLens(b64);
756      var validLen = lens[0];
757      var placeHoldersLen = lens[1];
758      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
759    }
760    function _byteLength(b64, validLen, placeHoldersLen) {
761      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
762    }
763    function toByteArray(b64) {
764      var tmp;
765      var lens = getLens(b64);
766      var validLen = lens[0];
767      var placeHoldersLen = lens[1];
768      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
769      var curByte = 0;
770      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
771      var i2;
772      for (i2 = 0; i2 < len2; i2 += 4) {
773        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
774        arr[curByte++] = tmp >> 16 & 255;
775        arr[curByte++] = tmp >> 8 & 255;
776        arr[curByte++] = tmp & 255;
777      }
778      if (placeHoldersLen === 2) {
779        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
780        arr[curByte++] = tmp & 255;
781      }
782      if (placeHoldersLen === 1) {
783        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
784        arr[curByte++] = tmp >> 8 & 255;
785        arr[curByte++] = tmp & 255;
786      }
787      return arr;
788    }
789    function tripletToBase64(num) {
790      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
791    }
792    function encodeChunk(uint8, start, end) {
793      var tmp;
794      var output = [];
795      for (var i2 = start; i2 < end; i2 += 3) {
796        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
797        output.push(tripletToBase64(tmp));
798      }
799      return output.join("");
800    }
801    function fromByteArray(uint8) {
802      var tmp;
803      var len2 = uint8.length;
804      var extraBytes = len2 % 3;
805      var parts = [];
806      var maxChunkLength = 16383;
807      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
808        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
809      }
810      if (extraBytes === 1) {
811        tmp = uint8[len2 - 1];
812        parts.push(
813          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
814        );
815      } else if (extraBytes === 2) {
816        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
817        parts.push(
818          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
819        );
820      }
821      return parts.join("");
822    }
823    return base64Js;
824  }
825  var ieee754 = {};
826  /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
827  var hasRequiredIeee754;
828  function requireIeee754() {
829    if (hasRequiredIeee754)
830      return ieee754;
831    hasRequiredIeee754 = 1;
832    ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) {
833      var e, m;
834      var eLen = nBytes * 8 - mLen - 1;
835      var eMax = (1 << eLen) - 1;
836      var eBias = eMax >> 1;
837      var nBits = -7;
838      var i = isLE ? nBytes - 1 : 0;
839      var d = isLE ? -1 : 1;
840      var s = buffer2[offset + i];
841      i += d;
842      e = s & (1 << -nBits) - 1;
843      s >>= -nBits;
844      nBits += eLen;
845      for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
846      }
847      m = e & (1 << -nBits) - 1;
848      e >>= -nBits;
849      nBits += mLen;
850      for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
851      }
852      if (e === 0) {
853        e = 1 - eBias;
854      } else if (e === eMax) {
855        return m ? NaN : (s ? -1 : 1) * Infinity;
856      } else {
857        m = m + Math.pow(2, mLen);
858        e = e - eBias;
859      }
860      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
861    };
862    ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
863      var e, m, c;
864      var eLen = nBytes * 8 - mLen - 1;
865      var eMax = (1 << eLen) - 1;
866      var eBias = eMax >> 1;
867      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
868      var i = isLE ? 0 : nBytes - 1;
869      var d = isLE ? 1 : -1;
870      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
871      value = Math.abs(value);
872      if (isNaN(value) || value === Infinity) {
873        m = isNaN(value) ? 1 : 0;
874        e = eMax;
875      } else {
876        e = Math.floor(Math.log(value) / Math.LN2);
877        if (value * (c = Math.pow(2, -e)) < 1) {
878          e--;
879          c *= 2;
880        }
881        if (e + eBias >= 1) {
882          value += rt / c;
883        } else {
884          value += rt * Math.pow(2, 1 - eBias);
885        }
886        if (value * c >= 2) {
887          e++;
888          c /= 2;
889        }
890        if (e + eBias >= eMax) {
891          m = 0;
892          e = eMax;
893        } else if (e + eBias >= 1) {
894          m = (value * c - 1) * Math.pow(2, mLen);
895          e = e + eBias;
896        } else {
897          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
898          e = 0;
899        }
900      }
901      for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
902      }
903      e = e << mLen | m;
904      eLen += mLen;
905      for (; eLen > 0;

905 buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
906      }
907      buffer2[offset + i - d] |= s * 128;
908    };
909    return ieee754;
910  }
911  /*!
912   * The buffer module from node.js, for the browser.
913   *
914   * @author   Feross Aboukhadijeh <https://feross.org>
915   * @license  MIT
916   */
917  var hasRequiredBuffer;
918  function requireBuffer() {
919    if (hasRequiredBuffer)
920      return buffer;
921    hasRequiredBuffer = 1;
922    (function(exports3) {
923      var base64 = requireBase64Js();
924      var ieee7542 = requireIeee754();
925      var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
926      exports3.Buffer = Buffer2;
927      exports3.SlowBuffer = SlowBuffer;
928      exports3.INSPECT_MAX_BYTES = 50;
929      var K_MAX_LENGTH = 2147483647;
930      exports3.kMaxLength = K_MAX_LENGTH;
931      Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
932      if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
933        console.error(
934          "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
935        );
936      }
937      function typedArraySupport() {
938        try {
939          var arr = new Uint8Array(1);
940          var proto = { foo: function() {
941            return 42;
942          } };
943          Object.setPrototypeOf(proto, Uint8Array.prototype);
944          Object.setPrototypeOf(arr, proto);
945          return arr.foo() === 42;
946        } catch (e) {
947          return false;
948        }
949      }
950      Object.defineProperty(Buffer2.prototype, "parent", {
951        enumerable: true,
952        get: function() {
953          if (!Buffer2.isBuffer(this))
954            return void 0;
955          return this.buffer;
956        }
957      });
958      Object.defineProperty(Buffer2.prototype, "offset", {
959        enumerable: true,
960        get: function() {
961          if (!Buffer2.isBuffer(this))
962            return void 0;
963          return this.byteOffset;
964        }
965      });
966      function createBuffer(length) {
967        if (length > K_MAX_LENGTH) {
968          throw new RangeError('The value "' + length + '" is invalid for option "size"');
969        }
970        var buf = new Uint8Array(length);
971        Object.setPrototypeOf(buf, Buffer2.prototype);
972        return buf;
973      }
974      function Buffer2(arg, encodingOrOffset, length) {
975        if (typeof arg === "number") {
976          if (typeof encodingOrOffset === "string") {
977            throw new TypeError(
978              'The "string" argument must be of type string. Received type number'
979            );
980          }
981          return allocUnsafe(arg);
982        }
983        return from(arg, encodingOrOffset, length);
984      }
985      Buffer2.poolSize = 8192;
986      function from(value, encodingOrOffset, length) {
987        if (typeof value === "string") {
988          return fromString(value, encodingOrOffset);
989        }
990        if (ArrayBuffer.isView(value)) {
991          return fromArrayView(value);
992        }
993        if (value == null) {
994          throw new TypeError(
995            "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
996          );
997        }
998        if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
999          return fromArrayBuffer(value, encodingOrOffset, length);
1000        }
1001        if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
1002          return fromArrayBuffer(value, encodingOrOffset, length);
1003        }
1004        if (typeof value === "number") {
1005          throw new TypeError(
1006            'The "value" argument must not be of type number. Received type number'
1007          );
1008        }
1009        var valueOf = value.valueOf && value.valueOf();
1010        if (valueOf != null && valueOf !== value) {
1011          return Buffer2.from(valueOf, encodingOrOffset, length);
1012        }
1013        var b = fromObject(value);
1014        if (b)
1015          return b;
1016        if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
1017          return Buffer2.from(
1018            value[Symbol.toPrimitive]("string"),
1019            encodingOrOffset,
1020            length
1021          );
1022        }
1023        throw new TypeError(
1024          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
1025        );
1026      }
1027      Buffer2.from = function(value, encodingOrOffset, length) {
1028        return from(value, encodingOrOffset, length);
1029      };
1030      Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
1031      Object.setPrototypeOf(Buffer2, Uint8Array);
1032      function assertSize(size) {
1033        if (typeof size !== "number") {
1034          throw new TypeError('"size" argument must be of type number');
1035        } else if (size < 0) {
1036          throw new RangeError('The value "' + size + '" is invalid for option "size"');
1037        }
1038      }
1039      function alloc(size, fill, encoding) {
1040        assertSize(size);
1041        if (size <= 0) {
1042          return createBuffer(size);
1043        }
1044        if (fill !== void 0) {
1045          return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
1046        }
1047        return createBuffer(size);
1048      }
1049      Buffer2.alloc = function(size, fill, encoding) {
1050        return alloc(size, fill, encoding);
1051      };
1052      function allocUnsafe(size) {
1053        assertSize(size);
1054        return createBuffer(size < 0 ? 0 : checked(size) | 0);
1055      }
1056      Buffer2.allocUnsafe = function(size) {
1057        return allocUnsafe(size);
1058      };
1059      Buffer2.allocUnsafeSlow = function(size) {
1060        return allocUnsafe(size);
1061      };
1062      function fromString(string, encoding) {
1063        if (typeof encoding !== "string" || encoding === "") {
1064          encoding = "utf8";
1065        }
1066        if (!Buffer2.isEncoding(encoding)) {
1067          throw new TypeError("Unknown encoding: " + encoding);
1068        }
1069        var length = byteLength(string, encoding) | 0;
1070        var buf = createBuffer(length);
1071        var actual = buf.write(string, encoding);
1072        if (actual !== length) {
1073          buf = buf.slice(0, actual);
1074        }
1075        return buf;
1076      }
1077      function fromArrayLike(array) {
1078        var length = array.length < 0 ? 0 : checked(array.length) | 0;
1079        var buf = createBuffer(length);
1080        for (var i = 0; i < length; i += 1) {
1081          buf[i] = array[i] & 255;
1082        }
1083        return buf;
1084      }
1085      function fromArrayView(arrayView) {
1086        if (isInstance(arrayView, Uint8Array)) {
1087          var copy = new Uint8Array(arrayView);
1088          return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
1089        }
1090        return fromArrayLike(arrayView);
1091      }
1092      function fromArrayBuffer(array, byteOffset, length) {
1093        if (byteOffset < 0 || array.byteLength < byteOffset) {
1094          throw new RangeError('"offset" is outside of buffer bounds');
1095        }
1096        if (array.byteLength < byteOffset + (length || 0)) {
1097          throw new RangeError('"length" is outside of buffer bounds');
1098        }
1099        var buf;
1100        if (byteOffset === void 0 && length === void 0) {
1101          buf = new Uint8Array(array);
1102        } else if (length === void 0) {
1103          buf = new Uint8Array(array, byteOffset);
1104        } else {
1105          buf = new Uint8Array(array, byteOffset, length);
1106        }
1107        Object.setPrototypeOf(buf, Buffer2.prototype);
1108        return buf;
1109      }
1110      function fromObject(obj) {
1111        if (Buffer2.isBuffer(obj)) {
1112          var len = checked(obj.length) | 0;
1113          var buf = createBuffer(len);
1114          if (buf.length === 0) {
1115            return buf;
1116          }
1117          obj.copy(buf, 0, 0, len);
1118          return buf;
1119        }
1120        if (obj.length !== void 0) {
1121          if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
1122            return createBuffer(0);
1123          }
1124          return fromArrayLike(obj);
1125        }
1126        if (obj.type === "Buffer" && Array.isArray(obj.data)) {
1127          return fromArrayLike(obj.data);
1128        }
1129      }
1130      function checked(length) {
1131        if (length >= K_MAX_LENGTH) {
1132          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
1133        }
1134        return length | 0;
1135      }
1136      function SlowBuffer(length) {
1137        if (+length != length) {
1138          length = 0;
1139        }
1140        return Buffer2.alloc(+length);
1141      }
1142      Buffer2.isBuffer = function isBuffer(b) {
1143        return b != null && b._isBuffer === true && b !== Buffer2.prototype;
1144      };
1145      Buffer2.compare = function compare(a, b) {
1146        if (isInstance(a, Uint8Array))
1147          a = Buffer2.from(a, a.offset, a.byteLength);
1148        if (isInstance(b, Uint8Array))
1149          b = Buffer2.from(b, b.offset, b.byteLength);
1150        if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
1151          throw new TypeError(
1152            'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
1153          );
1154        }
1155        if (a === b)
1156          return 0;
1157        var x = a.length;
1158        var y = b.length;
1159        for (var i = 0, len = Math.min(x, y); i < len; ++i) {
1160          if (a[i] !== b[i]) {
1161            x = a[i];
1162            y = b[i];
1163            break;
1164          }
1165        }
1166        if (x < y)
1167          return -1;
1168        if (y < x)
1169          return 1;
1170        return 0;
1171      };
1172      Buffer2.isEncoding = function isEncoding(encoding) {
1173        switch (String(encoding).toLowerCase()) {
1174          case "hex":
1175          case "utf8":
1176          case "utf-8":
1177          case "ascii":
1178          case "latin1":
1179          case "binary":
1180          case "base64":
1181          case "ucs2":
1182          case "ucs-2":
1183          case "utf16le":
1184          case "utf-16le":
1185            return true;
1186          default:
1187            return false;

1188        }
1189      };
1190      Buffer2.concat = function concat(list, length) {
1191        if (!Array.isArray(list)) {
1192          throw new TypeError('"list" argument must be an Array of Buffers');
1193        }
1194        if (list.length === 0) {
1195          return Buffer2.alloc(0);
1196        }
1197        var i;
1198        if (length === void 0) {
1199          length = 0;
1200          for (i = 0; i < list.length; ++i) {
1201            length += list[i].length;
1202          }
1203        }
1204        var buffer2 = Buffer2.allocUnsafe(length);
1205        var pos = 0;
1206        for (i = 0; i < list.length; ++i) {
1207          var buf = list[i];
1208          if (isInstance(buf, Uint8Array)) {
1209            if (pos + buf.length > buffer2.length) {
1210              Buffer2.from(buf).copy(buffer2, pos);
1211            } else {
1212              Uint8Array.prototype.set.call(
1213                buffer2,
1214                buf,
1215                pos
1216              );
1217            }
1218          } else if (!Buffer2.isBuffer(buf)) {
1219            throw new TypeError('"list" argument must be an Array of Buffers');
1220          } else {
1221            buf.copy(buffer2, pos);
1222          }
1223          pos += buf.length;
1224        }
1225        return buffer2;
1226      };
1227      function byteLength(string, encoding) {
1228        if (Buffer2.isBuffer(string)) {
1229          return string.length;
1230        }
1231        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
1232          return string.byteLength;
1233        }
1234        if (typeof string !== "string") {
1235          throw new TypeError(
1236            'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
1237          );
1238        }
1239        var len = string.length;
1240        var mustMatch = arguments.length > 2 && arguments[2] === true;
1241        if (!mustMatch && len === 0)
1242          return 0;
1243        var loweredCase = false;
1244        for (; ; ) {
1245          switch (encoding) {
1246            case "ascii":
1247            case "latin1":
1248            case "binary":
1249              return len;
1250            case "utf8":
1251            case "utf-8":
1252              return utf8ToBytes(string).length;
1253            case "ucs2":
1254            case "ucs-2":
1255            case "utf16le":
1256            case "utf-16le":
1257              return len * 2;
1258            case "hex":
1259              return len >>> 1;
1260            case "base64":
1261              return base64ToBytes(string).length;
1262            default:
1263              if (loweredCase) {
1264                return mustMatch ? -1 : utf8ToBytes(string).length;
1265              }
1266              encoding = ("" + encoding).toLowerCase();
1267              loweredCase = true;
1268          }
1269        }
1270      }
1271      Buffer2.byteLength = byteLength;
1272      function slowToString(encoding, start, end) {
1273        var loweredCase = false;
1274        if (start === void 0 || start < 0) {
1275          start = 0;
1276        }
1277        if (start > this.length) {
1278          return "";
1279        }
1280        if (end === void 0 || end > this.length) {
1281          end = this.length;
1282        }
1283        if (end <= 0) {
1284          return "";
1285        }
1286        end >>>= 0;
1287        start >>>= 0;
1288        if (end <= start) {
1289          return "";
1290        }
1291        if (!encoding)
1292          encoding = "utf8";
1293        while (true) {
1294          switch (encoding) {
1295            case "hex":
1296              return hexSlice(this, start, end);
1297            case "utf8":
1298            case "utf-8":
1299              return utf8Slice(this, start, end);
1300            case "ascii":
1301              return asciiSlice(this, start, end);
1302            case "latin1":
1303            case "binary":
1304              return latin1Slice(this, start, end);
1305            case "base64":
1306              return base64Slice(this, start, end);
1307            case "ucs2":
1308            case "ucs-2":
1309            case "utf16le":
1310            case "utf-16le":
1311              return utf16leSlice(this, start, end);
1312            default:
1313              if (loweredCase)
1314                throw new TypeError("Unknown encoding: " + encoding);
1315              encoding = (encoding + "").toLowerCase();
1316              loweredCase = true;
1317          }
1318        }
1319      }
1320      Buffer2.prototype._isBuffer = true;
1321      function swap(b, n, m) {
1322        var i = b[n];
1323        b[n] = b[m];
1324        b[m] = i;
1325      }
1326      Buffer2.prototype.swap16 = function swap16() {
1327        var len = this.length;
1328        if (len % 2 !== 0) {
1329          throw new RangeError("Buffer size must be a multiple of 16-bits");
1330        }
1331        for (var i = 0; i < len; i += 2) {
1332          swap(this, i, i + 1);
1333        }
1334        return this;
1335      };
1336      Buffer2.prototype.swap32 = function swap32() {
1337        var len = this.length;
1338        if (len % 4 !== 0) {
1339          throw new RangeError("Buffer size must be a multiple of 32-bits");
1340        }
1341        for (var i = 0; i < len; i += 4) {
1342          swap(this, i, i + 3);
1343          swap(this, i + 1, i + 2);
1344        }
1345        return this;
1346      };
1347      Buffer2.prototype.swap64 = function swap64() {
1348        var len = this.length;
1349        if (len % 8 !== 0) {
1350          throw new RangeError("Buffer size must be a multiple of 64-bits");
1351        }
1352        for (var i = 0; i < len; i += 8) {
1353          swap(this, i, i + 7);
1354          swap(this, i + 1, i + 6);
1355          swap(this, i + 2, i + 5);
1356          swap(this, i + 3, i + 4);
1357        }
1358        return this;
1359      };
1360      Buffer2.prototype.toString = function toString() {
1361        var length = this.length;
1362        if (length === 0)
1363          return "";
1364        if (arguments.length === 0)
1365          return utf8Slice(this, 0, length);
1366        return slowToString.apply(this, arguments);
1367      };

1368      Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
1369      Buffer2.prototype.equals = function equals(b) {
1370        if (!Buffer2.isBuffer(b))
1371          throw new TypeError("Argument must be a Buffer");
1372        if (this === b)
1373          return true;
1374        return Buffer2.compare(this, b) === 0;
1375      };
1376      Buffer2.prototype.inspect = function inspect() {
1377        var str = "";
1378        var max = exports3.INSPECT_MAX_BYTES;
1379        str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
1380        if (this.length > max)
1381          str += " ... ";
1382        return "<Buffer " + str + ">";
1383      };
1384      if (customInspectSymbol) {
1385        Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
1386      }
1387      Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
1388        if (isInstance(target, Uint8Array)) {
1389          target = Buffer2.from(target, target.offset, target.byteLength);
1390        }
1391        if (!Buffer2.isBuffer(target)) {
1392          throw new TypeError(
1393            'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
1394          );
1395        }
1396        if (start === void 0) {
1397          start = 0;
1398        }
1399        if (end === void 0) {
1400          end = target ? target.length : 0;
1401        }
1402        if (thisStart === void 0) {
1403          thisStart = 0;
1404        }
1405        if (thisEnd === void 0) {
1406          thisEnd = this.length;
1407        }
1408        if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
1409          throw new RangeError("out of range index");
1410        }
1411        if (thisStart >= thisEnd && start >= end) {
1412          return 0;
1413        }
1414        if (thisStart >= thisEnd) {
1415          return -1;
1416        }
1417        if (start >= end) {
1418          return 1;
1419        }
1420        start >>>= 0;
1421        end >>>= 0;
1422        thisStart >>>= 0;
1423        thisEnd >>>= 0;
1424        if (this === target)
1425          return 0;
1426        var x = thisEnd - thisStart;
1427        var y = end - start;
1428        var len = Math.min(x, y);
1429        var thisCopy = this.slice(thisStart, thisEnd);
1430        var targetCopy = target.slice(start, end);
1431        for (var i = 0; i < len; ++i) {
1432          if (thisCopy[i] !== targetCopy[i]) {
1433            x = thisCopy[i];
1434            y = targetCopy[i];
1435            break;
1436          }
1437        }
1438        if (x < y)
1439          return -1;
1440        if (y < x)
1441          return 1;
1442        return 0;
1443      };
1444      function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
1445        if (buffer2.length === 0)
1446          return -1;
1447        if (typeof byteOffset === "string") {
1448          encoding = byteOffset;
1449          byteOffset = 0;
1450        } else if (byteOffset > 2147483647) {
1451          byteOffset = 2147483647;
1452        } else if (byteOffset < -2147483648) {
1453          byteOffset = -2147483648;
1454        }
1455        byteOffset = +byteOffset;
1456        if (numberIsNaN(byteOffset)) {
1457          byteOffset = dir ? 0 : buffer2.length - 1;
1458        }
1459        if (byteOffset < 0)
1460          byteOffset = buffer2.length + byteOffset;
1461        if (byteOffset >= buffer2.length) {
1462          if (dir)
1463            return -1;
1464          else
1465            byteOffset = buffer2.length - 1;
1466        } else if (byteOffset < 0) {
1467          if (dir)
1468            byteOffset = 0;
1469          else
1470            return -1;
1471        }
1472        if (typeof val === "string") {
1473          val = Buffer2.from(val, encoding);
1474        }
1475        if (Buffer2.isBuffer(val)) {
1476          if (val.length === 0) {
1477            return -1;
1478          }
1479          return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
1480        } else if (typeof val === "number") {
1481          val = val & 255;
1482          if (typeof Uint8Array.prototype.indexOf === "function") {
1483            if (dir) {
1484              return Uint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
1485            } else {
1486              return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
1487            }
1488          }
1489          return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
1490        }
1491        throw new TypeError("val must be string, number or Buffer");
1492      }
1493      function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
1494        var indexSize = 1;
1495        var arrLength = arr.length;
1496        var valLength = val.length;
1497        if (encoding !== void 0) {
1498          encoding = String(encoding).toLowerCase();
1499          if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
1500            if (arr.length < 2 || val.length < 2) {
1501              return -1;
1502            }
1503            indexSize = 2;
1504            arrLength /= 2;
1505            valLength /= 2;
1506            byteOffset /= 2;
1507          }
1508        }
1509        function read(buf, i2) {
1510          if (indexSize === 1) {
1511            return buf[i2];
1512          } else {
1513            return buf.readUInt16BE(i2 * indexSize);
1514          }
1515        }
1516        var i;
1517        if (dir) {
1518          var foundIndex = -1;
1519          for (i = byteOffset; i < arrLength; i++) {
1520            if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
1521              if (foundIndex === -1)
1522                foundIndex = i;
1523              if (i - foundIndex + 1 === valLength)
1524                return foundIndex * indexSize;
1525            } else {
1526              if (foundIndex !== -1)
1527                i -= i - foundIndex;
1528              foundIndex = -1;
1529            }
1530          }
1531        } else {
1532          if (byteOffset + valLength > arrLength)
1533            byteOffset = arrLength - valLength;
1534          for (i = byteOffset; i >= 0; i--) {
1535            var found = true;
1536            for (var j = 0; j < valLength; j++) {
1537              if (read(arr, i + j) !== read(val, j)) {
1538                found = false;
1539                break;
1540              }
1541            }
1542            if (found)
1543              return i;
1544          }
1545        }
1546        return -1;
1547      }
1548      Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
1549        return this.indexOf(val, byteOffset, encoding) !== -1;
1550      };
1551      Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
1552        return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
1553      };
1554      Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
1555        return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
1556      };
1557      function hexWrite(buf, string, offset, length) {
1558        offset = Number(offset) || 0;
1559        var remaining = buf.length - offset;
1560        if (!length) {
1561          length = remaining;
1562        } else {
1563          length = Number(length);
1564          if (length > remaining) {
1565            length = remaining;
1566          }
1567        }
1568        var strLen = string.length;
1569        if (length > strLen / 2) {
1570          length = strLen / 2;
1571        }
1572        for (var i = 0; i < length; ++i) {
1573          var parsed = parseInt(string.substr(i * 2, 2), 16);
1574          if (numberIsNaN(parsed))
1575            return i;
1576          buf[offset + i] = parsed;
1577        }
1578        return i;
1579      }
1580      function utf8Write(buf, string, offset, length) {
1581        return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
1582      }
1583      function asciiWrite(buf, string, offset, length) {
1584        return blitBuffer(asciiToBytes(string), buf, offset, length);
1585      }
1586      function base64Write(buf, string, offset, length) {
1587        return blitBuffer(base64ToBytes(string), buf, offset, length);
1588      }
1589      function ucs2Write(buf, string, offset, length) {
1590        return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
1591      }
1592      Buffer2.prototype.write = function write(string, offset, length, encoding) {
1593        if (offset === void 0) {
1594          encoding = "utf8";
1595          length = this.length;
1596          offset = 0;
1597        } else if (length === void 0 && typeof offset === "string") {
1598          encoding = offset;
1599          length = this.length;
1600          offset = 0;
1601        } else if (isFinite(offset)) {
1602          offset = offset >>> 0;
1603          if (isFinite(length)) {
1604            length = length >>> 0;
1605            if (encoding === void 0)
1606              encoding = "utf8";
1607          } else {
1608            encoding = length;
1609            length = void 0;
1610          }
1611        } else {
1612          throw new Error(
1613            "Buffer.write(string, encoding, offset[, length]) is no longer supported"
1614          );
1615        }
1616        var remaining = this.length - offset;
1617        if (length === void 0 || length > remaining)
1618          length = remaining;
1619        if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
1620          throw new RangeError("Attempt to write outside buffer bounds");
1621        }
1622        if (!encoding)
1623          encoding = "utf8";
1624        var loweredCase = false;
1625        for (; ; ) {
1626          switch (encoding) {
1627            case "hex":
1628              return hexWrite(this, string, offset, length);
1629            case "utf8":
1630            case "utf-8":
1631              return utf8Write(this, string, offset, length);
1632            case "ascii":
1633            case "latin1":
1634            case "binary":
1635              return asciiWrite(this, string, offset, length);
1636            case "base64":
1637              return base64Write(this, string, offset, length);
1638            case "ucs2":
1639            case "ucs-2":
1640            case "utf16le":
1641            case "utf-16le":
1642              return ucs2Write(this, string, offset, length);
1643            default:
1644              if (loweredCase)
1645                throw new TypeError("Unknown encoding: " + encoding);
1646              encoding = ("" + encoding).toLowerCase();
1647              loweredCase = true;
1648          }
1649        }
1650      };
1651      Buffer2.prototype.toJSON = function toJSON() {
1652        return {
1653          type: "Buffer",
1654          data: Array.prototype.slice.call(this._arr || this, 0)
1655        };
1656      };
1657      function base64Slice(buf, start, end) {
1658        if (start === 0 && end === buf.length) {
1659          return base64.fromByteArray(buf);
1660        } else {
1661          return base64.fromByteArray(buf.slice(start, end));
1662        }
1663      }
1664      function utf8Slice(buf, start, end) {
1665        end = Math.min(buf.length, end);
1666        var res = [];
1667        var i = start;
1668        while (i < end) {
1669          var firstByte = buf[i];
1670          var codePoint = null;
1671          var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
1672          if (i + bytesPerSequence <= end) {
1673            var secondByte, thirdByte, fourthByte, tempCodePoint;
1674            switch (bytesPerSequence) {
1675              case 1:
1676                if (firstByte < 128) {
1677                  codePoint = firstByte;
1678                }
1679                break;
1680              case 2:
1681                secondByte = buf[i + 1];
1682                if ((secondByte & 192) === 128) {
1683                  tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
1684                  if (tempCodePoint > 127) {
1685                    codePoint = tempCodePoint;
1686                  }
1687                }
1688                break;
1689              case 3:
1690                secondByte = buf[i + 1];
1691                thirdByte = buf[i + 2];
1692                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
1693                  tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
1694                  if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
1695                    codePoint = tempCodePoint;
1696                  }
1697                }
1698                break;
1699              case 4:
1700                secondByte = buf[i + 1];
1701                thirdByte = buf[i + 2];
1702                fourthByte = buf[i + 3];
1703                if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
1704                  tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
1705                  if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
1706                    codePoint = tempCodePoint;
1707                  }
1708                }
1709            }
1710          }
1711          if (codePoint === null) {
1712            codePoint = 65533;
1713            bytesPerSequence = 1;
1714          } else if (codePoint > 65535) {
1715            codePoint -= 65536;
1716            res.push(codePoint >>> 10 & 1023 | 55296);
1717            codePoint = 56320 | codePoint & 1023;
1718          }
1719          res.push(codePoint);
1720          i += bytesPerSequence;
1721        }
1722        return decodeCodePointsArray(res);
1723      }
1724      var MAX_ARGUMENTS_LENGTH = 4096;
1725      function decodeCodePointsArray(codePoints) {
1726        var len = codePoints.length;
1727        if (len <= MAX_ARGUMENTS_LENGTH) {
1728          return String.fromCharCode.apply(String, codePoints);
1729        }
1730        var res = "";
1731        var i = 0;
1732        while (i < len) {
1733          res += String.fromCharCode.apply(
1734            String,
1735            codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
1736          );
1737        }
1738        return res;
1739      }
1740      function asciiSlice(buf, start, end) {
1741        var ret = "";
1742        end = Math.min(buf.length, end);
1743        for (var i = start; i < end; ++i) {
1744          ret += String.fromCharCode(buf[i] & 127);
1745        }
1746        return ret;
1747      }
1748      function latin1Slice(buf, start, end) {
1749        var ret = "";
1750        end = Math.min(buf.length, end);
1751        for (var i = start; i < end; ++i) {
1752          ret += String.fromCharCode(buf[i]);
1753        }
1754        return ret;
1755      }
1756      function hexSlice(buf, start, end) {
1757        var len = buf.length;
1758        if (!start || start < 0)
1759          start = 0;
1760        if (!end || end < 0 || end > len)
1761          end = len;
1762        var out = "";
1763        for (var i = start; i < end; ++i) {
1764          out += hexSliceLookupTable[buf[i]];
1765        }
1766        return out;
1767      }
1768      function utf16leSlice(buf, start, end) {
1769        var bytes = buf.slice(start, end);
1770        var res = "";
1771        for (var i = 0; i < bytes.length - 1; i += 2) {
1772          res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
1773        }
1774        return res;
1775      }
1776      Buffer2.prototype.slice = function slice(start, end) {
1777        var len = this.length;
1778        start = ~~start;
1779        end = end === void 0 ? len : ~~end;
1780        if (start < 0) {
1781          start += len;
1782          if (start < 0)
1783            start = 0;
1784        } else if (start > len) {
1785          start = len;
1786        }
1787        if (end < 0) {
1788          end += len;
1789          if (end < 0)
1790            end = 0;
1791        } else if (end > len) {
1792          end = len;
1793        }
1794        if (end < start)
1795          end = start;
1796        var newBuf = this.subarray(start, end);
1797        Object.setPrototypeOf(newBuf, Buffer2.prototype);
1798        return newBuf;
1799      };
1800      function checkOffset(offset, ext, length) {
1801        if (offset % 1 !== 0 || offset < 0)
1802          throw new RangeError("offset is not uint");
1803        if (offset + ext > length)
1804          throw new RangeError("Trying to access beyond buffer length");
1805      }
1806      Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
1807        offset = offset >>> 0;
1808        byteLength2 = byteLength2 >>> 0;
1809        if (!noAssert)
1810          checkOffset(offset, byteLength2, this.length);
1811        var val = this[offset];
1812        var mul = 1;
1813        var i = 0;
1814        while (++i < byteLength2 && (mul *= 256)) {
1815          val += this[offset + i] * mul;
1816        }
1817        return val;
1818      };
1819      Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
1820        offset = offset >>> 0;
1821        byteLength2 = byteLength2 >>> 0;
1822        if (!noAssert) {
1823          checkOffset(offset, byteLength2, this.length);
1824        }
1825        var val = this[offset + --byteLength2];
1826        var mul = 1;
1827        while (byteLength2 > 0 && (mul *= 256)) {
1828          val += this[offset + --byteLength2] * mul;
1829        }
1830        return val;
1831      };
1832      Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
1833        offset = offset >>> 0;
1834        if (!noAssert)
1835          checkOffset(offset, 1, this.length);
1836        return this[offset];
1837      };

1838      Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
1839        offset = offset >>> 0;
1840        if (!noAssert)
1841          checkOffset(offset, 2, this.length);
1842        return this[offset] | this[offset + 1] << 8;
1843      };
1844      Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
1845        offset = offset >>> 0;
1846        if (!noAssert)
1847          checkOffset(offset, 2, this.length);
1848        return this[offset] << 8 | this[offset + 1];
1849      };
1850      Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
1851        offset = offset >>> 0;
1852        if (!noAssert)
1853          checkOffset(offset, 4, this.length);
1854        return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
1855      };
1856      Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
1857        offset = offset >>> 0;
1858        if (!noAssert)
1859          checkOffset(offset, 4, this.length);
1860        return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
1861      };
1862      Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
1863        offset = offset >>> 0;
1864        byteLength2 = byteLength2 >>> 0;
1865        if (!noAssert)
1866          checkOffset(offset, byteLength2, this.length);
1867        var val = this[offset];
1868        var mul = 1;
1869        var i = 0;
1870        while (++i < byteLength2 && (mul *= 256)) {
1871          val += this[offset + i] * mul;
1872        }
1873        mul *= 128;
1874        if (val >= mul)
1875          val -= Math.pow(2, 8 * byteLength2);
1876        return val;
1877      };
1878      Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
1879        offset = offset >>> 0;
1880        byteLength2 = byteLength2 >>> 0;
1881        if (!noAssert)
1882          checkOffset(offset, byteLength2, this.length);
1883        var i = byteLength2;
1884        var mul = 1;
1885        var val = this[offset + --i];
1886        while (i > 0 && (mul *= 256)) {
1887          val += this[offset + --i] * mul;
1888        }
1889        mul *= 128;
1890        if (val >= mul)
1891          val -= Math.pow(2, 8 * byteLength2);
1892        return val;
1893      };
1894      Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
1895        offset = offset >>> 0;
1896        if (!noAssert)
1897          checkOffset(offset, 1, this.length);
1898        if (!(this[offset] & 128))
1899          return this[offset];
1900        return (255 - this[offset] + 1) * -1;
1901      };
1902      Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
1903        offset = offset >>> 0;
1904        if (!noAssert)
1905          checkOffset(offset, 2, this.length);
1906        var val = this[offset] | this[offset + 1] << 8;
1907        return val & 32768 ? val | 4294901760 : val;
1908      };
1909      Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
1910        offset = offset >>> 0;
1911        if (!noAssert)
1912          checkOffset(offset, 2, this.length);
1913        var val = this[offset + 1] | this[offset] << 8;
1914        return val & 32768 ? val | 4294901760 : val;
1915      };
1916      Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
1917        offset = offset >>> 0;
1918        if (!noAssert)
1919          checkOffset(offset, 4, this.length);
1920        return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
1921      };
1922      Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
1923        offset = offset >>> 0;
1924        if (!noAssert)
1925          checkOffset(offset, 4, this.length);
1926        return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
1927      };
1928      Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
1929        offset = offset >>> 0;
1930        if (!noAssert)
1931          checkOffset(offset, 4, this.length);
1932        return ieee7542.read(this, offset, true, 23, 4);
1933      };
1934      Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
1935        offset = offset >>> 0;
1936        if (!noAssert)
1937          checkOffset(offset, 4, this.length);
1938        return ieee7542.read(this, offset, false, 23, 4);
1939      };
1940      Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
1941        offset = offset >>> 0;
1942        if (!noAssert)
1943          checkOffset(offset, 8, this.length);
1944        return ieee7542.read(this, offset, true, 52, 8);
1945      };
1946      Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
1947        offset = offset >>> 0;
1948        if (!noAssert)
1949          checkOffset(offset, 8, this.length);
1950        return ieee7542.read(this, offset, false, 52, 8);
1951      };
1952      function checkInt(buf, value, offset, ext, max, min) {
1953        if (!Buffer2.isBuffer(buf))
1954          throw new TypeError('"buffer" argument must be a Buffer instance');
1955        if (value > max || value < min)
1956          throw new RangeError('"value" argument is out of bounds');
1957        if (offset + ext > buf.length)
1958          throw new RangeError("Index out of range");
1959      }
1960      Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
1961        value = +value;
1962        offset = offset >>> 0;
1963        byteLength2 = byteLength2 >>> 0;
1964        if (!noAssert) {
1965          var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
1966          checkInt(this, value, offset, byteLength2, maxBytes, 0);
1967        }
1968        var mul = 1;
1969        var i = 0;
1970        this[offset] = value & 255;
1971        while (++i < byteLength2 && (mul *= 256)) {
1972          this[offset + i] = value / mul & 255;
1973        }
1974        return offset + byteLength2;
1975      };
1976      Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
1977        value = +value;
1978        offset = offset >>> 0;
1979        byteLength2 = byteLength2 >>> 0;
1980        if (!noAssert) {
1981          var maxBytes = Math.pow(2, 8 * byteLength2) - 1;
1982          checkInt(this, value, offset, byteLength2, maxBytes, 0);
1983        }
1984        var i = byteLength2 - 1;
1985        var mul = 1;
1986        this[offset + i] = value & 255;
1987        while (--i >= 0 && (mul *= 256)) {
1988          this[offset + i] = value / mul & 255;
1989        }
1990        return offset + byteLength2;
1991      };
1992      Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
1993        value = +value;
1994        offset = offset >>> 0;
1995        if (!noAssert)
1996          checkInt(this, value, offset, 1, 255, 0);
1997        this[offset] = value & 255;
1998        return offset + 1;
1999      };
2000      Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
2001        value = +value;
2002        offset = offset >>> 0;
2003        if (!noAssert)
2004          checkInt(this, value, offset, 2, 65535, 0);
2005        this[offset] = value & 255;
2006        this[offset + 1] = value >>> 8;
2007        return offset + 2;
2008      };
2009      Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
2010        value = +value;
2011        offset = offset >>> 0;
2012        if (!noAssert)
2013          checkInt(this, value, offset, 2, 65535, 0);
2014        this[offset] = value >>> 8;
2015        this[offset + 1] = value & 255;
2016        return offset + 2;
2017      };
2018      Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
2019        value = +value;
2020        offset = offset >>> 0;
2021        if (!noAssert)
2022          checkInt(this, value, offset, 4, 4294967295, 0);
2023        this[offset + 3] = value >>> 24;
2024        this[offset + 2] = value >>> 16;
2025        this[offset + 1] = value >>> 8;
2026        this[offset] = value & 255;
2027        return offset + 4;
2028      };
2029      Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
2030        value = +value;
2031        offset = offset >>> 0;
2032        if (!noAssert)
2033          checkInt(this, value, offset, 4, 4294967295, 0);
2034        this[offset] = value >>> 24;
2035        this[offset + 1] = value >>> 16;
2036        this[offset + 2] = value >>> 8;
2037        this[offset + 3] = value & 255;
2038        return offset + 4;
2039      };
2040      Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
2041        value = +value;
2042        offset = offset >>> 0;
2043        if (!noAssert) {
2044          var limit = Math.pow(2, 8 * byteLength2 - 1);
2045          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
2046        }
2047        var i = 0;
2048        var mul = 1;
2049        var sub = 0;
2050        this[offset] = value & 255;
2051        while (++i < byteLength2 && (mul *= 256)) {
2052          if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
2053            sub = 1;
2054          }
2055          this[offset + i] = (value / mul >> 0) - sub & 255;
2056        }
2057        return offset + byteLength2;
2058      };
2059      Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
2060        value = +value;
2061        offset = offset >>> 0;
2062        if (!noAssert) {
2063          var limit = Math.pow(2, 8 * byteLength2 - 1);
2064          checkInt(this, value, offset, byteLength2, limit - 1, -limit);
2065        }
2066        var i = byteLength2 - 1;
2067        var mul = 1;
2068        var sub = 0;
2069        this[offset + i] = value & 255;
2070        while (--i >= 0 && (mul *= 256)) {
2071          if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
2072            sub = 1;
2073          }
2074          this[offset + i] = (value / mul >> 0) - sub & 255;
2075        }
2076        return offset + byteLength2;
2077      };
2078      Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
2079        value = +value;
2080        offset = offset >>> 0;
2081        if (!noAssert)
2082          checkInt(this, value, offset, 1, 127, -128);
2083        if (value < 0)
2084          value = 255 + value + 1;
2085        this[offset] = value & 255;
2086        return offset + 1;
2087      };
2088      Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
2089        value = +value;
2090        offset = offset >>> 0;
2091        if (!noAssert)
2092          checkInt(this, value, offset, 2, 32767, -32768);
2093        this[offset] = value & 255;
2094        this[offset + 1] = value >>> 8;
2095        return offset + 2;
2096      };
2097      Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
2098        value = +value;
2099        offset = offset >>> 0;
2100        if (!noAssert)
2101          checkInt(this, value, offset, 2, 32767, -32768);
2102        this[offset] = value >>> 8;
2103        this[offset + 1] = value & 255;
2104        return offset + 2;
2105      };
2106      Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
2107        value = +value;
2108        offset = offset >>> 0;
2109        if (!noAssert)
2110          checkInt(this, value, offset, 4, 2147483647, -2147483648);
2111        this[offset] = value & 255;
2112        this[offset + 1] = value >>> 8;
2113        this[offset + 2] = value >>> 16;
2114        this[offset + 3] = value >>> 24;
2115        return offset + 4;
2116      };
2117      Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
2118        value = +value;
2119        offset = offset >>> 0;
2120        if (!noAssert)
2121          checkInt(this, value, offset, 4, 2147483647, -2147483648);
2122        if (value < 0)
2123          value = 4294967295 + value + 1;
2124        this[offset] = value >>> 24;
2125        this[offset + 1] = value >>> 16;
2126        this[offset + 2] = value >>> 8;
2127        this[offset + 3] = value & 255;
2128        return offset + 4;
2129      };
2130      function checkIEEE754(buf, value, offset, ext, max, min) {
2131        if (offset + ext > buf.length)
2132          throw new RangeError("Index out of range");
2133        if (offset < 0)
2134          throw new RangeError("Index out of range");
2135      }
2136      function writeFloat(buf, value, offset, littleEndian, noAssert) {
2137        value = +value;
2138        offset = offset >>> 0;
2139        if (!noAssert) {
2140          checkIEEE754(buf, value, offset, 4);
2141        }
2142        ieee7542.write(buf, value, offset, littleEndian, 23, 4);
2143        return offset + 4;
2144      }
2145      Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
2146        return writeFloat(this, value, offset, true, noAssert);
2147      };
2148      Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
2149        return writeFloat(this, value, offset, false, noAssert);
2150      };
2151      function writeDouble(buf, value, offset, littleEndian, noAssert) {
2152        value = +value;
2153        offset = offset >>> 0;
2154        if (!noAssert) {
2155          checkIEEE754(buf, value, offset, 8);
2156        }
2157        ieee7542.write(buf, value, offset, littleEndian, 52, 8);
2158        return offset + 8;
2159      }
2160      Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
2161        return writeDouble(this, value, offset, true, noAssert);
2162      };
2163      Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
2164        return writeDouble(this, value, offset, false, noAssert);
2165      };
2166      Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
2167        if (!Buffer2.isBuffer(target))
2168          throw new TypeError("argument should be a Buffer");
2169        if (!start)
2170          start = 0;
2171        if (!end && end !== 0)
2172          end = this.length;
2173        if (targetStart >= target.length)
2174          targetStart = target.length;
2175        if (!targetStart)
2176          targetStart = 0;
2177        if (end > 0 && end < start)
2178          end = start;
2179        if (end === start)
2180          return 0;
2181        if (target.length === 0 || this.length === 0)
2182          return 0;
2183        if (targetStart < 0) {
2184          throw new RangeError("targetStart out of bounds");
2185        }
2186        if (start < 0 || start >= this.length)
2187          throw new RangeError("Index out of range");
2188        if (end < 0)
2189          throw new RangeError("sourceEnd out of bounds");
2190        if (end > this.length)
2191          end = this.length;
2192        if (target.length - targetStart < end - start) {
2193          end = target.length - targetStart + start;
2194        }
2195        var len = end - start;
2196        if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
2197          this.copyWithin(targetStart, start, end);
2198        } else {
2199          Uint8Array.prototype.set.call(
2200            target,
2201            this.subarray(start, end),
2202            targetStart
2203          );
2204        }
2205        return len;
2206      };
2207      Buffer2.prototype.fill = function fill(val, start, end, encoding) {
2208        if (typeof val === "string") {
2209          if (typeof start === "string") {
2210            encoding = start;
2211            start = 0;
2212            end = this.length;
2213          } else if (typeof end === "string") {
2214            encoding = end;
2215            end = this.length;
2216          }
2217          if (encoding !== void 0 && typeof encoding !== "string") {
2218            throw new TypeError("encoding must be a string");
2219          }
2220          if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
2221            throw new TypeError("Unknown encoding: " + encoding);
2222          }
2223          if (val.length === 1) {
2224            var code = val.charCodeAt(0);
2225            if (encoding === "utf8" && code < 128 || encoding === "latin1") {
2226              val = code;
2227            }
2228          }
2229        } else if (typeof val === "number") {
2230          val = val & 255;
2231        } else if (typeof val === "boolean") {
2232          val = Number(val);
2233        }
2234        if (start < 0 || this.length < start || this.length < end) {
2235          throw new RangeError("Out of range index");
2236        }
2237        if (end <= start) {
2238          return this;
2239        }
2240        start = start >>> 0;
2241        end = end === void 0 ? this.length : end >>> 0;
2242        if (!val)
2243          val = 0;
2244        var i;
2245        if (typeof val === "number") {
2246          for (i = start; i < end; ++i) {
2247            this[i] = val;
2248          }
2249        } else {
2250          var bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
2251          var len = bytes.length;
2252          if (len === 0) {
2253            throw new TypeError('The value "' + val + '" is invalid for argument "value"');
2254          }
2255          for (i = 0; i < end - start; ++i) {
2256            this[i + start] = bytes[i % len];
2257          }
2258        }
2259        return this;
2260      };
2261      var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
2262      function base64clean(str) {
2263        str = str.split("=")[0];
2264        str = str.trim().replace(INVALID_BASE64_RE, "");
2265        if (str.length < 2)
2266          return "";
2267        while (str.length % 4 !== 0) {
2268          str = str + "=";
2269        }
2270        return str;
2271      }
2272      function utf8ToBytes(string, units) {
2273        units = units || Infinity;
2274        var codePoint;
2275        var length = string.length;
2276        var leadSurrogate = null;
2277        var bytes = [];
2278        for (var i = 0; i < length; ++i) {
2279          codePoint = string.charCodeAt(i);
2280          if (codePoint > 55295 && codePoint < 57344) {
2281            if (!leadSurrogate) {
2282              if (codePoint > 56319) {
2283                if ((units -= 3) > -1)
2284                  bytes.push(239, 191, 189);
2285                continue;
2286              } else if (i + 1 === length) {
2287                if ((units -= 3) > -1)
2288                  bytes.push(239, 191, 189);
2289                continue;
2290              }
2291              leadSurrogate = codePoint;
2292              continue;
2293            }
2294            if (codePoint < 56320) {
2295              if ((units -= 3) > -1)
2296                bytes.push(239, 191, 189);
2297              leadSurrogate = codePoint;
2298              continue;
2299            }
2300            codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
2301          } else if (leadSurrogate) {
2302            if ((units -= 3) > -1)
2303              bytes.push(239, 191, 189);
2304          }
2305          leadSurrogate = null;
2306          if (codePoint < 128) {
2307            if ((units -= 1) < 0)
2308              break;
2309            bytes.push(codePoint);
2310          } else if (codePoint < 2048) {
2311            if ((units -= 2) < 0)
2312              break;
2313            bytes.push(
2314              codePoint >> 6 | 192,
2315              codePoint & 63 | 128
2316            );
2317          } else if (codePoint < 65536) {
2318            if ((units -= 3) < 0)
2319              break;
2320            bytes.push(
2321              codePoint >> 12 | 224,
2322              codePoint >> 6 & 63 | 128,
2323              codePoint & 63 | 128
2324            );
2325          } else if (codePoint < 1114112) {
2326            if ((units -= 4) < 0)
2327              break;
2328            bytes.push(
2329              codePoint >> 18 | 240,
2330              codePoint >> 12 & 63 | 128,
2331              codePoint >> 6 & 63 | 128,
2332              codePoint & 63 | 128
2333            );
2334          } else {
2335            throw new Error("Invalid code point");
2336          }
2337        }
2338        return bytes;
2339      }
2340      function asciiToBytes(str) {
2341        var byteArray = [];
2342        for (var i = 0; i < str.length; ++i) {
2343          byteArray.push(str.charCodeAt(i) & 255);
2344        }
2345        return byteArray;
2346      }
2347      function utf16leToBytes(str, units) {
2348        var c, hi, lo;
2349        var byteArray = [];
2350        for (var i = 0; i < str.length; ++i) {
2351          if ((units -= 2) < 0)
2352            break;
2353          c = str.charCodeAt(i);
2354          hi = c >> 8;
2355          lo = c % 256;
2356          byteArray.push(lo);
2357          byteArray.push(hi);
2358        }
2359        return byteArray;
2360      }
2361      function base64ToBytes(str) {
2362        return base64.toByteArray(base64clean(str));
2363      }
2364      function blitBuffer(src, dst, offset, length) {
2365        for (var i = 0; i < length; ++i) {
2366          if (i + offset >= dst.length || i >= src.length)
2367            break;
2368          dst[i + offset] = src[i];
2369        }
2370        return i;
2371      }
2372      function isInstance(obj, type) {
2373        return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
2374      }
2375      function numberIsNaN(obj) {
2376        return obj !== obj;
2377      }
2378      var hexSliceLookupTable = function() {
2379        var alphabet = "0123456789abcdef";
2380        var table = new Array(256);
2381        for (var i = 0; i < 16; ++i) {
2382          var i16 = i * 16;
2383          for (var j = 0; j < 16; ++j) {

2384            table[i16 + j] = alphabet[i] + alphabet[j];
2385          }
2386        }
2387        return table;
2388      }();
2389    })(buffer);
2390    return buffer;
2391  }
2392  var util = {};
2393  var types = {};
2394  var shams$1;
2395  var hasRequiredShams$1;
2396  function requireShams$1() {
2397    if (hasRequiredShams$1)
2398      return shams$1;
2399    hasRequiredShams$1 = 1;
2400    shams$1 = function hasSymbols2() {
2401      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
2402        return false;
2403      }
2404      if (typeof Symbol.iterator === "symbol") {
2405        return true;
2406      }
2407      var obj = {};
2408      var sym = Symbol("test");
2409      var symObj = Object(sym);
2410      if (typeof sym === "string") {
2411        return false;
2412      }
2413      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
2414        return false;
2415      }
2416      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
2417        return false;
2418      }
2419      var symVal = 42;
2420      obj[sym] = symVal;
2421      for (sym in obj) {
2422        return false;
2423      }
2424      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
2425        return false;
2426      }
2427      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
2428        return false;
2429      }
2430      var syms = Object.getOwnPropertySymbols(obj);
2431      if (syms.length !== 1 || syms[0] !== sym) {
2432        return false;
2433      }
2434      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
2435        return false;
2436      }
2437      if (typeof Object.getOwnPropertyDescriptor === "function") {
2438        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
2439        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
2440          return false;
2441        }
2442      }
2443      return true;
2444    };
2445    return shams$1;
2446  }
2447  var shams;
2448  var hasRequiredShams;
2449  function requireShams() {
2450    if (hasRequiredShams)
2451      return shams;
2452    hasRequiredShams = 1;
2453    var hasSymbols2 = requireShams$1();
2454    shams = function hasToStringTagShams() {
2455      return hasSymbols2() && !!Symbol.toStringTag;
2456    };
2457    return shams;
2458  }
2459  var hasSymbols;
2460  var hasRequiredHasSymbols;
2461  function requireHasSymbols() {
2462    if (hasRequiredHasSymbols)
2463      return hasSymbols;
2464    hasRequiredHasSymbols = 1;
2465    var origSymbol = typeof Symbol !== "undefined" && Symbol;
2466    var hasSymbolSham = requireShams$1();
2467    hasSymbols = function hasNativeSymbols() {
2468      if (typeof origSymbol !== "function") {
2469        return false;
2470      }
2471      if (typeof Symbol !== "function") {
2472        return false;
2473      }
2474      if (typeof origSymbol("foo") !== "symbol") {
2475        return false;
2476      }
2477      if (typeof Symbol("bar") !== "symbol") {
2478        return false;
2479      }
2480      return hasSymbolSham();
2481    };
2482    return hasSymbols;
2483  }
2484  var hasProto;
2485  var hasRequiredHasProto;
2486  function requireHasProto() {
2487    if (hasRequiredHasProto)
2488      return hasProto;
2489    hasRequiredHasProto = 1;
2490    var test = {
2491      foo: {}
2492    };
2493    var $Object = Object;
2494    hasProto = function hasProto2() {
2495      return { __proto__: test }.foo === test.foo && !({ __proto__: null } instanceof $Object);
2496    };
2497    return hasProto;
2498  }
2499  var implementation;
2500  var hasRequiredImplementation;
2501  function requireImplementation() {
2502    if (hasRequiredImplementation)
2503      return implementation;
2504    hasRequiredImplementation = 1;
2505    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
2506    var toStr = Object.prototype.toString;
2507    var max = Math.max;
2508    var funcType = "[object Function]";
2509    var concatty = function concatty2(a, b) {
2510      var arr = [];
2511      for (var i = 0; i < a.length; i += 1) {
2512        arr[i] = a[i];
2513      }
2514      for (var j = 0; j < b.length; j += 1) {
2515        arr[j + a.length] = b[j];
2516      }
2517      return arr;
2518    };
2519    var slicy = function slicy2(arrLike, offset) {
2520      var arr = [];
2521      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
2522        arr[j] = arrLike[i];
2523      }
2524      return arr;
2525    };
2526    var joiny = function(arr, joiner) {
2527      var str = "";
2528      for (var i = 0; i < arr.length; i += 1) {
2529        str += arr[i];
2530        if (i + 1 < arr.length) {
2531          str += joiner;
2532        }
2533      }
2534      return str;
2535    };
2536    implementation = function bind(that) {
2537      var target = this;
2538      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
2539        throw new TypeError(ERROR_MESSAGE + target);
2540      }
2541      var args = slicy(arguments, 1);
2542      var bound;
2543      var binder = function() {
2544        if (this instanceof bound) {
2545          var result = target.apply(
2546            this,
2547            concatty(args, arguments)
2548          );
2549          if (Object(result) === result) {
2550            return result;
2551          }
2552          return this;
2553        }
2554        return target.apply(
2555          that,
2556          concatty(args, arguments)
2557        );
2558      };
2559      var boundLength = max(0, target.length - args.length);
2560      var boundArgs = [];
2561      for (var i = 0; i < boundLength; i++) {
2562        boundArgs[i] = "$" + i;
2563      }
2564      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
2565      if (target.prototype) {
2566        var Empty = function Empty2() {
2567        };
2568        Empty.prototype = target.prototype;
2569        bound.prototype = new Empty();
2570        Empty.prototype = null;
2571      }
2572      return bound;
2573    };
2574    return implementation;
2575  }
2576  var functionBind;
2577  var hasRequiredFunctionBind;
2578  function requireFunctionBind() {
2579    if (hasRequiredFunctionBind)
2580      return functionBind;
2581    hasRequiredFunctionBind = 1;
2582    var implementation2 = requireImplementation();
2583    functionBind = Function.prototype.bind || implementation2;
2584    return functionBind;
2585  }
2586  var hasown;
2587  var hasRequiredHasown;
2588  function requireHasown() {
2589    if (hasRequiredHasown)
2590      return hasown;
2591    hasRequiredHasown = 1;
2592    var call = Function.prototype.call;
2593    var $hasOwn = Object.prototype.hasOwnProperty;
2594    var bind = requireFunctionBind();
2595    hasown = bind.call(call, $hasOwn);
2596    return hasown;
2597  }
2598  var getIntrinsic;
2599  var hasRequiredGetIntrinsic;
2600  function requireGetIntrinsic() {
2601    if (hasRequiredGetIntrinsic)
2602      return getIntrinsic;
2603    hasRequiredGetIntrinsic = 1;
2604    var undefined$1;
2605    var $SyntaxError = SyntaxError;
2606    var $Function = Function;
2607    var $TypeError = TypeError;
2608    var getEvalledConstructor = function(expressionSyntax) {

2609      try {
2610        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
2611      } catch (e) {
2612      }
2613    };
2614    var $gOPD = Object.getOwnPropertyDescriptor;
2615    if ($gOPD) {
2616      try {
2617        $gOPD({}, "");
2618      } catch (e) {
2619        $gOPD = null;
2620      }
2621    }
2622    var throwTypeError = function() {
2623      throw new $TypeError();
2624    };
2625    var ThrowTypeError = $gOPD ? function() {
2626      try {
2627        arguments.callee;
2628        return throwTypeError;
2629      } catch (calleeThrows) {
2630        try {
2631          return $gOPD(arguments, "callee").get;
2632        } catch (gOPDthrows) {
2633          return throwTypeError;
2634        }
2635      }
2636    }() : throwTypeError;
2637    var hasSymbols2 = requireHasSymbols()();
2638    var hasProto2 = requireHasProto()();
2639    var getProto = Object.getPrototypeOf || (hasProto2 ? function(x) {
2640      return x.__proto__;
2641    } : null);
2642    var needsEval = {};
2643    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined$1 : getProto(Uint8Array);
2644    var INTRINSICS = {
2645      "%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError,
2646      "%Array%": Array,
2647      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer,
2648      "%ArrayIteratorPrototype%": hasSymbols2 && getProto ? getProto([][Symbol.iterator]()) : undefined$1,
2649      "%AsyncFromSyncIteratorPrototype%": undefined$1,
2650      "%AsyncFunction%": needsEval,
2651      "%AsyncGenerator%": needsEval,
2652      "%AsyncGeneratorFunction%": needsEval,
2653      "%AsyncIteratorPrototype%": needsEval,
2654      "%Atomics%": typeof Atomics === "undefined" ? undefined$1 : Atomics,
2655      "%BigInt%": typeof BigInt === "undefined" ? undefined$1 : BigInt,
2656      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined$1 : BigInt64Array,
2657      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined$1 : BigUint64Array,
2658      "%Boolean%": Boolean,
2659      "%DataView%": typeof DataView === "undefined" ? undefined$1 : DataView,
2660      "%Date%": Date,
2661      "%decodeURI%": decodeURI,
2662      "%decodeURIComponent%": decodeURIComponent,
2663      "%encodeURI%": encodeURI,
2664      "%encodeURIComponent%": encodeURIComponent,
2665      "%Error%": Error,
2666      "%eval%": eval,
2667      // eslint-disable-line no-eval
2668      "%EvalError%": EvalError,
2669      "%Float32Array%": typeof Float32Array === "undefined" ? undefined$1 : Float32Array,
2670      "%Float64Array%": typeof Float64Array === "undefined" ? undefined$1 : Float64Array,
2671      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined$1 : FinalizationRegistry,
2672      "%Function%": $Function,
2673      "%GeneratorFunction%": needsEval,
2674      "%Int8Array%": typeof Int8Array === "undefined" ? undefined$1 : Int8Array,
2675      "%Int16Array%": typeof Int16Array === "undefined" ? undefined$1 : Int16Array,
2676      "%Int32Array%": typeof Int32Array === "undefined" ? undefined$1 : Int32Array,
2677      "%isFinite%": isFinite,
2678      "%isNaN%": isNaN,
2679      "%IteratorPrototype%": hasSymbols2 && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
2680      "%JSON%": typeof JSON === "object" ? JSON : undefined$1,
2681      "%Map%": typeof Map === "undefined" ? undefined$1 : Map,
2682      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols2 || !getProto ? undefined$1 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
2683      "%Math%": Math,
2684      "%Number%": Number,
2685      "%Object%": Object,
2686      "%parseFloat%": parseFloat,
2687      "%parseInt%": parseInt,
2688      "%Promise%": typeof Promise === "undefined" ? undefined$1 : Promise,
2689      "%Proxy%": typeof Proxy === "undefined" ? undefined$1 : Proxy,
2690      "%RangeError%": RangeError,
2691      "%ReferenceError%": ReferenceError,
2692      "%Reflect%": typeof Reflect === "undefined" ? undefined$1 : Reflect,
2693      "%RegExp%": RegExp,
2694      "%Set%": typeof Set === "undefined" ? undefined$1 : Set,
2695      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols2 || !getProto ? undefined$1 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
2696      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer,
2697      "%String%": String,
2698      "%StringIteratorPrototype%": hasSymbols2 && getProto ? getProto(""[Symbol.iterator]()) : undefined$1,
2699      "%Symbol%": hasSymbols2 ? Symbol : undefined$1,
2700      "%SyntaxError%": $SyntaxError,
2701      "%ThrowTypeError%": ThrowTypeError,
2702      "%TypedArray%": TypedArray,
2703      "%TypeError%": $TypeError,
2704      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array,
2705      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray,
2706      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array,
2707      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined$1 : Uint32Array,
2708      "%URIError%": URIError,
2709      "%WeakMap%": typeof WeakMap === "undefined" ? undefined$1 : WeakMap,
2710      "%WeakRef%": typeof WeakRef === "undefined" ? undefined$1 : WeakRef,
2711      "%WeakSet%": typeof WeakSet === "undefined" ? undefined$1 : WeakSet
2712    };
2713    if (getProto) {
2714      try {
2715        null.error;
2716      } catch (e) {
2717        var errorProto = getProto(getProto(e));
2718        INTRINSICS["%Error.prototype%"] = errorProto;
2719      }
2720    }
2721    var doEval = function doEval2(name) {
2722      var value;
2723      if (name === "%AsyncFunction%") {
2724        value = getEvalledConstructor("async function () {}");
2725      } else if (name === "%GeneratorFunction%") {
2726        value = getEvalledConstructor("function* () {}");
2727      } else if (name === "%AsyncGeneratorFunction%") {
2728        value = getEvalledConstructor("async function* () {}");
2729      } else if (name === "%AsyncGenerator%") {
2730        var fn = doEval2("%AsyncGeneratorFunction%");
2731        if (fn) {
2732          value = fn.prototype;
2733        }
2734      } else if (name === "%AsyncIteratorPrototype%") {
2735        var gen = doEval2("%AsyncGenerator%");
2736        if (gen && getProto) {
2737          value = getProto(gen.prototype);
2738        }
2739      }
2740      INTRINSICS[name] = value;
2741      return value;
2742    };
2743    var LEGACY_ALIASES = {
2744      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
2745      "%ArrayPrototype%": ["Array", "prototype"],
2746      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
2747      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
2748      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
2749      "%ArrayProto_values%": ["Array", "prototype", "values"],
2750      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
2751      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
2752      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
2753      "%BooleanPrototype%": ["Boolean", "prototype"],
2754      "%DataViewPrototype%": ["DataView", "prototype"],
2755      "%DatePrototype%": ["Date", "prototype"],
2756      "%ErrorPrototype%": ["Error", "prototype"],
2757      "%EvalErrorPrototype%": ["EvalError", "prototype"],
2758      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
2759      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
2760      "%FunctionPrototype%": ["Function", "prototype"],
2761      "%Generator%": ["GeneratorFunction", "prototype"],
2762      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
2763      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
2764      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
2765      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
2766      "%JSONParse%": ["JSON", "parse"],
2767      "%JSONStringify%": ["JSON", "stringify"],
2768      "%MapPrototype%": ["Map", "prototype"],
2769      "%NumberPrototype%": ["Number", "prototype"],
2770      "%ObjectPrototype%": ["Object", "prototype"],
2771      "%ObjProto_toString%": ["Object", "prototype", "toString"],
2772      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
2773      "%PromisePrototype%": ["Promise", "prototype"],
2774      "%PromiseProto_then%": ["Promise", "prototype", "then"],
2775      "%Promise_all%": ["Promise", "all"],
2776      "%Promise_reject%": ["Promise", "reject"],
2777      "%Promise_resolve%": ["Promise", "resolve"],
2778      "%RangeErrorPrototype%": ["RangeError", "prototype"],
2779      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
2780      "%RegExpPrototype%": ["RegExp", "prototype"],
2781      "%SetPrototype%": ["Set", "prototype"],
2782      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
2783      "%StringPrototype%": ["String", "prototype"],
2784      "%SymbolPrototype%": ["Symbol", "prototype"],
2785      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
2786      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
2787      "%TypeErrorPrototype%": ["TypeError", "prototype"],
2788      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
2789      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
2790      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
2791      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
2792      "%URIErrorPrototype%": ["URIError", "prototype"],
2793      "%WeakMapPrototype%": ["WeakMap", "prototype"],
2794      "%WeakSetPrototype%": ["WeakSet", "prototype"]
2795    };
2796    var bind = requireFunctionBind();
2797    var hasOwn = requireHasown();
2798    var $concat = bind.call(Function.call, Array.prototype.concat);
2799    var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
2800    var $replace = bind.call(Function.call, String.prototype.replace);
2801    var $strSlice = bind.call(Function.call, String.prototype.slice);
2802    var $exec = bind.call(Function.call, RegExp.prototype.exec);
2803    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
2804    var reEscapeChar = /\\(\\)?/g;
2805    var stringToPath = function stringToPath2(string) {
2806      var first = $strSlice(string, 0, 1);
2807      var last = $strSlice(string, -1);
2808      if (first === "%" && last !== "%") {
2809        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
2810      } else if (last === "%" && first !== "%") {
2811        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
2812      }
2813      var result = [];
2814      $replace(string, rePropName, function(match, number, quote, subString) {
2815        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
2816      });
2817      return result;
2818    };
2819    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
2820      var intrinsicName = name;
2821      var alias;
2822      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
2823        alias = LEGACY_ALIASES[intrinsicName];
2824        intrinsicName = "%" + alias[0] + "%";
2825      }
2826      if (hasOwn(INTRINSICS, intrinsicName)) {
2827        var value = INTRINSICS[intrinsicName];
2828        if (value === needsEval) {
2829          value = doEval(intrinsicName);
2830        }
2831        if (typeof value === "undefined" && !allowMissing) {
2832          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
2833        }
2834        return {
2835          alias,
2836          name: intrinsicName,
2837          value
2838        };
2839      }
2840      throw new $SyntaxError("intrinsic " + name + " does not exist!");
2841    };
2842    getIntrinsic = function GetIntrinsic(name, allowMissing) {
2843      if (typeof name !== "string" || name.length === 0) {
2844        throw new $TypeError("intrinsic name must be a non-empty string");
2845      }
2846      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
2847        throw new $TypeError('"allowMissing" argument must be a boolean');
2848      }
2849      if ($exec(/^%?[^%]*%?$/, name) === null) {
2850        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
2851      }
2852      var parts = stringToPath(name);
2853      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
2854      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
2855      var intrinsicRealName = intrinsic.name;
2856      var value = intrinsic.value;
2857      var skipFurtherCaching = false;