bundle.js?ver=1.2.7

js alexhotel.com.au collected 2026-09-29 17:45:08 UTC 2,513,614 bytes, 63,920 lines download raw bytes

1var __defProp = Object.defineProperty;
2var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
3var __publicField = (obj, key2, value) => __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
4(function() {
5  "use strict";
6  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
7  function getDefaultExportFromCjs$1(x) {
8    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
9  }
10  var jsxRuntime = { exports: {} };
11  var reactJsxRuntime_production = {};
12  /**
13  * @license React
14  * react-jsx-runtime.production.js
15  *
16  * Copyright (c) Meta Platforms, Inc. and affiliates.
17  *
18  * This source code is licensed under the MIT license found in the
19  * LICENSE file in the root directory of this source tree.
20  */
21  var hasRequiredReactJsxRuntime_production;
22  function requireReactJsxRuntime_production() {
23    if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
24    hasRequiredReactJsxRuntime_production = 1;
25    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
26    function jsxProd(type2, config, maybeKey) {
27      var key2 = null;
28      void 0 !== maybeKey && (key2 = "" + maybeKey);
29      void 0 !== config.key && (key2 = "" + config.key);
30      if ("key" in config) {
31        maybeKey = {};
32        for (var propName in config)
33          "key" !== propName && (maybeKey[propName] = config[propName]);
34      } else maybeKey = config;
35      config = maybeKey.ref;
36      return {
37        $$typeof: REACT_ELEMENT_TYPE,
38        type: type2,
39        key: key2,
40        ref: void 0 !== config ? config : null,
41        props: maybeKey
42      };
43    }
44    reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
45    reactJsxRuntime_production.jsx = jsxProd;
46    reactJsxRuntime_production.jsxs = jsxProd;
47    return reactJsxRuntime_production;
48  }
49  var hasRequiredJsxRuntime;
50  function requireJsxRuntime() {
51    if (hasRequiredJsxRuntime) return jsxRuntime.exports;
52    hasRequiredJsxRuntime = 1;
53    {
54      jsxRuntime.exports = requireReactJsxRuntime_production();
55    }
56    return jsxRuntime.exports;
57  }
58  var jsxRuntimeExports = requireJsxRuntime();
59  var client = { exports: {} };
60  function getDefaultExportFromCjs(x) {
61    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
62  }
63  var browser$4 = { exports: {} };
64  var process = browser$4.exports = {};
65  var cachedSetTimeout;
66  var cachedClearTimeout;
67  function defaultSetTimout() {
68    throw new Error("setTimeout has not been defined");
69  }
70  function defaultClearTimeout() {
71    throw new Error("clearTimeout has not been defined");
72  }
73  (function() {
74    try {
75      if (typeof setTimeout === "function") {
76        cachedSetTimeout = setTimeout;
77      } else {
78        cachedSetTimeout = defaultSetTimout;
79      }
80    } catch (e) {
81      cachedSetTimeout = defaultSetTimout;
82    }
83    try {
84      if (typeof clearTimeout === "function") {
85        cachedClearTimeout = clearTimeout;
86      } else {
87        cachedClearTimeout = defaultClearTimeout;
88      }
89    } catch (e) {
90      cachedClearTimeout = defaultClearTimeout;
91    }
92  })();
93  function runTimeout(fun) {
94    if (cachedSetTimeout === setTimeout) {
95      return setTimeout(fun, 0);
96    }
97    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
98      cachedSetTimeout = setTimeout;
99      return setTimeout(fun, 0);
100    }
101    try {
102      return cachedSetTimeout(fun, 0);
103    } catch (e) {
104      try {
105        return cachedSetTimeout.call(null, fun, 0);
106      } catch (e2) {
107        return cachedSetTimeout.call(this, fun, 0);
108      }
109    }
110  }
111  function runClearTimeout(marker) {
112    if (cachedClearTimeout === clearTimeout) {
113      return clearTimeout(marker);
114    }
115    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
116      cachedClearTimeout = clearTimeout;
117      return clearTimeout(marker);
118    }
119    try {
120      return cachedClearTimeout(marker);
121    } catch (e) {

vendor: 5,846 bytes, lines 122-295

122      try {
123        return cachedClearTimeout.call(null, marker);
124      } catch (e2) {
125        return cachedClearTimeout.call(this, marker);
126      }
127    }
128  }
129  var queue = [];
130  var draining = false;
131  var currentQueue;
132  var queueIndex = -1;
133  function cleanUpNextTick() {
134    if (!draining || !currentQueue) {
135      return;
136    }
137    draining = false;
138    if (currentQueue.length) {
139      queue = currentQueue.concat(queue);
140    } else {
141      queueIndex = -1;
142    }
143    if (queue.length) {
144      drainQueue();
145    }
146  }
147  function drainQueue() {
148    if (draining) {
149      return;
150    }
151    var timeout = runTimeout(cleanUpNextTick);
152    draining = true;
153    var len2 = queue.length;
154    while (len2) {
155      currentQueue = queue;
156      queue = [];
157      while (++queueIndex < len2) {
158        if (currentQueue) {
159          currentQueue[queueIndex].run();
160        }
161      }
162      queueIndex = -1;
163      len2 = queue.length;
164    }
165    currentQueue = null;
166    draining = false;
167    runClearTimeout(timeout);
168  }
169  process.nextTick = function(fun) {
170    var args = new Array(arguments.length - 1);
171    if (arguments.length > 1) {
172      for (var i2 = 1; i2 < arguments.length; i2++) {
173        args[i2 - 1] = arguments[i2];
174      }
175    }
176    queue.push(new Item(fun, args));
177    if (queue.length === 1 && !draining) {
178      runTimeout(drainQueue);
179    }
180  };
181  function Item(fun, array) {
182    this.fun = fun;
183    this.array = array;
184  }
185  Item.prototype.run = function() {
186    this.fun.apply(null, this.array);
187  };
188  process.title = "browser";
189  process.browser = true;
190  process.env = {};
191  process.argv = [];
192  process.version = "";
193  process.versions = {};
194  function noop$1() {
195  }
196  process.on = noop$1;
197  process.addListener = noop$1;
198  process.once = noop$1;
199  process.off = noop$1;
200  process.removeListener = noop$1;
201  process.removeAllListeners = noop$1;
202  process.emit = noop$1;
203  process.prependListener = noop$1;
204  process.prependOnceListener = noop$1;
205  process.listeners = function(name) {
206    return [];
207  };
208  process.binding = function(name) {
209    throw new Error("process.binding is not supported");
210  };
211  process.cwd = function() {
212    return "/";
213  };
214  process.chdir = function(dir) {
215    throw new Error("process.chdir is not supported");
216  };
217  process.umask = function() {
218    return 0;
219  };
220  var browserExports = browser$4.exports;
221  const process$1 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
222  var reactDomClient_production = {};
223  var scheduler = { exports: {} };
224  var scheduler_production = {};
225  /**
226  * @license React
227  * scheduler.production.js
228  *
229  * Copyright (c) Meta Platforms, Inc. and affiliates.
230  *
231  * This source code is licensed under the MIT license found in the
232  * LICENSE file in the root directory of this source tree.
233  */
234  var hasRequiredScheduler_production;
235  function requireScheduler_production() {
236    if (hasRequiredScheduler_production) return scheduler_production;
237    hasRequiredScheduler_production = 1;
238    (function(exports$12) {
239      function push(heap, node2) {
240        var index = heap.length;
241        heap.push(node2);
242        a: for (; 0 < index; ) {
243          var parentIndex = index - 1 >>> 1, parent = heap[parentIndex];
244          if (0 < compare(parent, node2))
245            heap[parentIndex] = node2, heap[index] = parent, index = parentIndex;
246          else break a;
247        }
248      }
249      function peek(heap) {
250        return 0 === heap.length ? null : heap[0];
251      }
252      function pop(heap) {
253        if (0 === heap.length) return null;
254        var first = heap[0], last = heap.pop();
255        if (last !== first) {
256          heap[0] = last;
257          a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength; ) {
258            var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
259            if (0 > compare(left, last))
260              rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);
261            else if (rightIndex < length && 0 > compare(right, last))
262              heap[index] = right, heap[rightIndex] = last, index = rightIndex;
263            else break a;
264          }
265        }
266        return first;
267      }
268      function compare(a, b) {
269        var diff = a.sortIndex - b.sortIndex;
270        return 0 !== diff ? diff : a.id - b.id;
271      }
272      exports$12.unstable_now = void 0;
273      if ("object" === typeof performance && "function" === typeof performance.now) {
274        var localPerformance = performance;
275        exports$12.unstable_now = function() {
276          return localPerformance.now();
277        };
278      } else {
279        var localDate = Date, initialTime = localDate.now();
280        exports$12.unstable_now = function() {
281          return localDate.now() - initialTime;
282        };
283      }
284      var taskQueue = [], timerQueue = [], taskIdCounter = 1, currentTask = null, currentPriorityLevel = 3, isPerformingWork = false, isHostCallbackScheduled = false, isHostTimeoutScheduled = false, needsPaint = false, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
285      function advanceTimers(currentTime) {
286        for (var timer = peek(timerQueue); null !== timer; ) {
287          if (null === timer.callback) pop(timerQueue);
288          else if (timer.startTime <= currentTime)
289            pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);
290          else break;
291          timer = peek(timerQueue);
292        }
293      }
294      function handleTimeout(currentTime) {
295        isHostTimeoutScheduled = false;

vendor: 9,665 bytes, lines 296-512

296        advanceTimers(currentTime);
297        if (!isHostCallbackScheduled)
298          if (null !== peek(taskQueue))
299            isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline());
300          else {
301            var firstTimer = peek(timerQueue);
302            null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
303          }
304      }
305      var isMessageLoopRunning = false, taskTimeoutID = -1, frameInterval = 5, startTime = -1;
306      function shouldYieldToHost() {
307        return needsPaint ? true : exports$12.unstable_now() - startTime < frameInterval ? false : true;
308      }
309      function performWorkUntilDeadline() {
310        needsPaint = false;
311        if (isMessageLoopRunning) {
312          var currentTime = exports$12.unstable_now();
313          startTime = currentTime;
314          var hasMoreWork = true;
315          try {
316            a: {
317              isHostCallbackScheduled = false;
318              isHostTimeoutScheduled && (isHostTimeoutScheduled = false, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
319              isPerformingWork = true;
320              var previousPriorityLevel = currentPriorityLevel;
321              try {
322                b: {
323                  advanceTimers(currentTime);
324                  for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost()); ) {
325                    var callback = currentTask.callback;
326                    if ("function" === typeof callback) {
327                      currentTask.callback = null;
328                      currentPriorityLevel = currentTask.priorityLevel;
329                      var continuationCallback = callback(
330                        currentTask.expirationTime <= currentTime
331                      );
332                      currentTime = exports$12.unstable_now();
333                      if ("function" === typeof continuationCallback) {
334                        currentTask.callback = continuationCallback;
335                        advanceTimers(currentTime);
336                        hasMoreWork = true;
337                        break b;
338                      }
339                      currentTask === peek(taskQueue) && pop(taskQueue);
340                      advanceTimers(currentTime);
341                    } else pop(taskQueue);
342                    currentTask = peek(taskQueue);
343                  }
344                  if (null !== currentTask) hasMoreWork = true;
345                  else {
346                    var firstTimer = peek(timerQueue);
347                    null !== firstTimer && requestHostTimeout(
348                      handleTimeout,
349                      firstTimer.startTime - currentTime
350                    );
351                    hasMoreWork = false;
352                  }
353                }
354                break a;
355              } finally {
356                currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = false;
357              }
358              hasMoreWork = void 0;
359            }
360          } finally {
361            hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = false;
362          }
363        }
364      }
365      var schedulePerformWorkUntilDeadline;
366      if ("function" === typeof localSetImmediate)
367        schedulePerformWorkUntilDeadline = function() {
368          localSetImmediate(performWorkUntilDeadline);
369        };
370      else if ("undefined" !== typeof MessageChannel) {
371        var channel = new MessageChannel(), port = channel.port2;
372        channel.port1.onmessage = performWorkUntilDeadline;
373        schedulePerformWorkUntilDeadline = function() {
374          port.postMessage(null);
375        };
376      } else
377        schedulePerformWorkUntilDeadline = function() {
378          localSetTimeout(performWorkUntilDeadline, 0);
379        };
380      function requestHostTimeout(callback, ms2) {
381        taskTimeoutID = localSetTimeout(function() {
382          callback(exports$12.unstable_now());
383        }, ms2);
384      }
385      exports$12.unstable_IdlePriority = 5;
386      exports$12.unstable_ImmediatePriority = 1;
387      exports$12.unstable_LowPriority = 4;
388      exports$12.unstable_NormalPriority = 3;
389      exports$12.unstable_Profiling = null;
390      exports$12.unstable_UserBlockingPriority = 2;
391      exports$12.unstable_cancelCallback = function(task) {
392        task.callback = null;
393      };
394      exports$12.unstable_forceFrameRate = function(fps) {
395        0 > fps || 125 < fps ? console.error(
396          "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
397        ) : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5;
398      };
399      exports$12.unstable_getCurrentPriorityLevel = function() {
400        return currentPriorityLevel;
401      };
402      exports$12.unstable_next = function(eventHandler) {
403        switch (currentPriorityLevel) {
404          case 1:
405          case 2:
406          case 3:
407            var priorityLevel = 3;
408            break;
409          default:
410            priorityLevel = currentPriorityLevel;
411        }
412        var previousPriorityLevel = currentPriorityLevel;
413        currentPriorityLevel = priorityLevel;
414        try {
415          return eventHandler();
416        } finally {
417          currentPriorityLevel = previousPriorityLevel;
418        }
419      };
420      exports$12.unstable_requestPaint = function() {
421        needsPaint = true;
422      };
423      exports$12.unstable_runWithPriority = function(priorityLevel, eventHandler) {
424        switch (priorityLevel) {
425          case 1:
426          case 2:
427          case 3:
428          case 4:
429          case 5:
430            break;
431          default:
432            priorityLevel = 3;
433        }
434        var previousPriorityLevel = currentPriorityLevel;
435        currentPriorityLevel = priorityLevel;
436        try {
437          return eventHandler();
438        } finally {
439          currentPriorityLevel = previousPriorityLevel;
440        }
441      };
442      exports$12.unstable_scheduleCallback = function(priorityLevel, callback, options) {
443        var currentTime = exports$12.unstable_now();
444        "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
445        switch (priorityLevel) {
446          case 1:
447            var timeout = -1;
448            break;
449          case 2:
450            timeout = 250;
451            break;
452          case 5:
453            timeout = 1073741823;
454            break;
455          case 4:
456            timeout = 1e4;
457            break;
458          default:
459            timeout = 5e3;
460        }
461        timeout = options + timeout;
462        priorityLevel = {
463          id: taskIdCounter++,
464          callback,
465          priorityLevel,
466          startTime: options,
467          expirationTime: timeout,
468          sortIndex: -1
469        };
470        options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = true, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline())));
471        return priorityLevel;
472      };
473      exports$12.unstable_shouldYield = shouldYieldToHost;
474      exports$12.unstable_wrapCallback = function(callback) {
475        var parentPriorityLevel = currentPriorityLevel;
476        return function() {
477          var previousPriorityLevel = currentPriorityLevel;
478          currentPriorityLevel = parentPriorityLevel;
479          try {
480            return callback.apply(this, arguments);
481          } finally {
482            currentPriorityLevel = previousPriorityLevel;
483          }
484        };
485      };
486    })(scheduler_production);
487    return scheduler_production;
488  }
489  var hasRequiredScheduler;
490  function requireScheduler() {
491    if (hasRequiredScheduler) return scheduler.exports;
492    hasRequiredScheduler = 1;
493    {
494      scheduler.exports = requireScheduler_production();
495    }
496    return scheduler.exports;
497  }
498  var react = { exports: {} };
499  var react_production = {};
500  var hasRequiredReact_production;
501  function requireReact_production() {
502    if (hasRequiredReact_production) return react_production;
503    hasRequiredReact_production = 1;
504    var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
505    function getIteratorFn(maybeIterable) {
506      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
507      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
508      return "function" === typeof maybeIterable ? maybeIterable : null;
509    }
510    var ReactNoopUpdateQueue = {
511      isMounted: function() {
512        return false;

vendor: 13,324 bytes, lines 513-847

513      },
514      enqueueForceUpdate: function() {
515      },
516      enqueueReplaceState: function() {
517      },
518      enqueueSetState: function() {
519      }
520    }, assign = Object.assign, emptyObject = {};
521    function Component(props, context, updater) {
522      this.props = props;
523      this.context = context;
524      this.refs = emptyObject;
525      this.updater = updater || ReactNoopUpdateQueue;
526    }
527    Component.prototype.isReactComponent = {};
528    Component.prototype.setState = function(partialState, callback) {
529      if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
530        throw Error(
531          "takes an object of state variables to update or a function which returns an object of state variables."
532        );
533      this.updater.enqueueSetState(this, partialState, callback, "setState");
534    };
535    Component.prototype.forceUpdate = function(callback) {
536      this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
537    };
538    function ComponentDummy() {
539    }
540    ComponentDummy.prototype = Component.prototype;
541    function PureComponent(props, context, updater) {
542      this.props = props;
543      this.context = context;
544      this.refs = emptyObject;
545      this.updater = updater || ReactNoopUpdateQueue;
546    }
547    var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
548    pureComponentPrototype.constructor = PureComponent;
549    assign(pureComponentPrototype, Component.prototype);
550    pureComponentPrototype.isPureReactComponent = true;
551    var isArrayImpl = Array.isArray;
552    function noop2() {
553    }
554    var ReactSharedInternals = { H: null, A: null, T: null, S: null }, hasOwnProperty2 = Object.prototype.hasOwnProperty;
555    function ReactElement(type2, key2, props) {
556      var refProp = props.ref;
557      return {
558        $$typeof: REACT_ELEMENT_TYPE,
559        type: type2,
560        key: key2,
561        ref: void 0 !== refProp ? refProp : null,
562        props
563      };
564    }
565    function cloneAndReplaceKey(oldElement, newKey) {
566      return ReactElement(oldElement.type, newKey, oldElement.props);
567    }
568    function isValidElement(object) {
569      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
570    }
571    function escape2(key2) {
572      var escaperLookup = { "=": "=0", ":": "=2" };
573      return "$" + key2.replace(/[=:]/g, function(match) {
574        return escaperLookup[match];
575      });
576    }
577    var userProvidedKeyEscapeRegex = /\/+/g;
578    function getElementKey(element, index) {
579      return "object" === typeof element && null !== element && null != element.key ? escape2("" + element.key) : index.toString(36);
580    }
581    function resolveThenable(thenable) {
582      switch (thenable.status) {
583        case "fulfilled":
584          return thenable.value;
585        case "rejected":
586          throw thenable.reason;
587        default:
588          switch ("string" === typeof thenable.status ? thenable.then(noop2, noop2) : (thenable.status = "pending", thenable.then(
589            function(fulfilledValue) {
590              "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
591            },
592            function(error) {
593              "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error);
594            }
595          )), thenable.status) {
596            case "fulfilled":
597              return thenable.value;
598            case "rejected":
599              throw thenable.reason;
600          }
601      }
602      throw thenable;
603    }
604    function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
605      var type2 = typeof children;
606      if ("undefined" === type2 || "boolean" === type2) children = null;
607      var invokeCallback = false;
608      if (null === children) invokeCallback = true;
609      else
610        switch (type2) {
611          case "bigint":
612          case "string":
613          case "number":
614            invokeCallback = true;
615            break;
616          case "object":
617            switch (children.$$typeof) {
618              case REACT_ELEMENT_TYPE:
619              case REACT_PORTAL_TYPE:
620                invokeCallback = true;
621                break;
622              case REACT_LAZY_TYPE:
623                return invokeCallback = children._init, mapIntoArray(
624                  invokeCallback(children._payload),
625                  array,
626                  escapedPrefix,
627                  nameSoFar,
628                  callback
629                );
630            }
631        }
632      if (invokeCallback)
633        return callback = callback(children), invokeCallback = "" === nameSoFar ? "." + getElementKey(children, 0) : nameSoFar, isArrayImpl(callback) ? (escapedPrefix = "", null != invokeCallback && (escapedPrefix = invokeCallback.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c) {
634          return c;
635        })) : null != callback && (isValidElement(callback) && (callback = cloneAndReplaceKey(
636          callback,
637          escapedPrefix + (null == callback.key || children && children.key === callback.key ? "" : ("" + callback.key).replace(
638            userProvidedKeyEscapeRegex,
639            "$&/"
640          ) + "/") + invokeCallback
641        )), array.push(callback)), 1;
642      invokeCallback = 0;
643      var nextNamePrefix = "" === nameSoFar ? "." : nameSoFar + ":";
644      if (isArrayImpl(children))
645        for (var i2 = 0; i2 < children.length; i2++)
646          nameSoFar = children[i2], type2 = nextNamePrefix + getElementKey(nameSoFar, i2), invokeCallback += mapIntoArray(
647            nameSoFar,
648            array,
649            escapedPrefix,
650            type2,
651            callback
652          );
653      else if (i2 = getIteratorFn(children), "function" === typeof i2)
654        for (children = i2.call(children), i2 = 0; !(nameSoFar = children.next()).done; )
655          nameSoFar = nameSoFar.value, type2 = nextNamePrefix + getElementKey(nameSoFar, i2++), invokeCallback += mapIntoArray(
656            nameSoFar,
657            array,
658            escapedPrefix,
659            type2,
660            callback
661          );
662      else if ("object" === type2) {
663        if ("function" === typeof children.then)
664          return mapIntoArray(
665            resolveThenable(children),
666            array,
667            escapedPrefix,
668            nameSoFar,
669            callback
670          );
671        array = String(children);
672        throw Error(
673          "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
674        );
675      }
676      return invokeCallback;
677    }
678    function mapChildren(children, func, context) {
679      if (null == children) return children;
680      var result = [], count = 0;
681      mapIntoArray(children, result, "", "", function(child) {
682        return func.call(context, child, count++);
683      });
684      return result;
685    }
686    function lazyInitializer(payload) {
687      if (-1 === payload._status) {
688        var ctor = payload._result;
689        ctor = ctor();
690        ctor.then(
691          function(moduleObject) {
692            if (0 === payload._status || -1 === payload._status)
693              payload._status = 1, payload._result = moduleObject;
694          },
695          function(error) {
696            if (0 === payload._status || -1 === payload._status)
697              payload._status = 2, payload._result = error;
698          }
699        );
700        -1 === payload._status && (payload._status = 0, payload._result = ctor);
701      }
702      if (1 === payload._status) return payload._result.default;
703      throw payload._result;
704    }
705    var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
706      if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
707        var event = new window.ErrorEvent("error", {
708          bubbles: true,
709          cancelable: true,
710          message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
711          error
712        });
713        if (!window.dispatchEvent(event)) return;
714      } else if ("object" === typeof process$1 && "function" === typeof process$1.emit) {
715        process$1.emit("uncaughtException", error);
716        return;
717      }
718      console.error(error);
719    }, Children = {
720      map: mapChildren,
721      forEach: function(children, forEachFunc, forEachContext) {
722        mapChildren(
723          children,
724          function() {
725            forEachFunc.apply(this, arguments);
726          },
727          forEachContext
728        );
729      },
730      count: function(children) {
731        var n = 0;
732        mapChildren(children, function() {
733          n++;
734        });
735        return n;
736      },
737      toArray: function(children) {
738        return mapChildren(children, function(child) {
739          return child;
740        }) || [];
741      },
742      only: function(children) {
743        if (!isValidElement(children))
744          throw Error(
745            "React.Children.only expected to receive a single React element child."
746          );
747        return children;
748      }
749    };
750    react_production.Activity = REACT_ACTIVITY_TYPE;
751    react_production.Children = Children;
752    react_production.Component = Component;
753    react_production.Fragment = REACT_FRAGMENT_TYPE;
754    react_production.Profiler = REACT_PROFILER_TYPE;
755    react_production.PureComponent = PureComponent;
756    react_production.StrictMode = REACT_STRICT_MODE_TYPE;
757    react_production.Suspense = REACT_SUSPENSE_TYPE;
758    react_production.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
759    react_production.__COMPILER_RUNTIME = {
760      __proto__: null,
761      c: function(size) {
762        return ReactSharedInternals.H.useMemoCache(size);
763      }
764    };
765    react_production.cache = function(fn) {
766      return function() {
767        return fn.apply(null, arguments);
768      };
769    };
770    react_production.cacheSignal = function() {
771      return null;
772    };
773    react_production.cloneElement = function(element, config, children) {
774      if (null === element || void 0 === element)
775        throw Error(
776          "The argument must be a React element, but you passed " + element + "."
777        );
778      var props = assign({}, element.props), key2 = element.key;
779      if (null != config)
780        for (propName in void 0 !== config.key && (key2 = "" + config.key), config)
781          !hasOwnProperty2.call(config, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config.ref || (props[propName] = config[propName]);
782      var propName = arguments.length - 2;
783      if (1 === propName) props.children = children;
784      else if (1 < propName) {
785        for (var childArray = Array(propName), i2 = 0; i2 < propName; i2++)
786          childArray[i2] = arguments[i2 + 2];
787        props.children = childArray;
788      }
789      return ReactElement(element.type, key2, props);
790    };
791    react_production.createContext = function(defaultValue) {
792      defaultValue = {
793        $$typeof: REACT_CONTEXT_TYPE,
794        _currentValue: defaultValue,
795        _currentValue2: defaultValue,
796        _threadCount: 0,
797        Provider: null,
798        Consumer: null
799      };
800      defaultValue.Provider = defaultValue;
801      defaultValue.Consumer = {
802        $$typeof: REACT_CONSUMER_TYPE,
803        _context: defaultValue
804      };
805      return defaultValue;
806    };
807    react_production.createElement = function(type2, config, children) {
808      var propName, props = {}, key2 = null;
809      if (null != config)
810        for (propName in void 0 !== config.key && (key2 = "" + config.key), config)
811          hasOwnProperty2.call(config, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (props[propName] = config[propName]);
812      var childrenLength = arguments.length - 2;
813      if (1 === childrenLength) props.children = children;
814      else if (1 < childrenLength) {
815        for (var childArray = Array(childrenLength), i2 = 0; i2 < childrenLength; i2++)
816          childArray[i2] = arguments[i2 + 2];
817        props.children = childArray;
818      }
819      if (type2 && type2.defaultProps)
820        for (propName in childrenLength = type2.defaultProps, childrenLength)
821          void 0 === props[propName] && (props[propName] = childrenLength[propName]);
822      return ReactElement(type2, key2, props);
823    };
824    react_production.createRef = function() {
825      return { current: null };
826    };
827    react_production.forwardRef = function(render) {
828      return { $$typeof: REACT_FORWARD_REF_TYPE, render };
829    };
830    react_production.isValidElement = isValidElement;
831    react_production.lazy = function(ctor) {
832      return {
833        $$typeof: REACT_LAZY_TYPE,
834        _payload: { _status: -1, _result: ctor },
835        _init: lazyInitializer
836      };
837    };
838    react_production.memo = function(type2, compare) {
839      return {
840        $$typeof: REACT_MEMO_TYPE,
841        type: type2,
842        compare: void 0 === compare ? null : compare
843      };
844    };
845    react_production.startTransition = function(scope) {
846      var prevTransition = ReactSharedInternals.T, currentTransition = {};
847      ReactSharedInternals.T = currentTransition;

vendor: 4,244 bytes, lines 848-951

848      try {
849        var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
850        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
851        "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && returnValue.then(noop2, reportGlobalError);
852      } catch (error) {
853        reportGlobalError(error);
854      } finally {
855        null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
856      }
857    };
858    react_production.unstable_useCacheRefresh = function() {
859      return ReactSharedInternals.H.useCacheRefresh();
860    };
861    react_production.use = function(usable) {
862      return ReactSharedInternals.H.use(usable);
863    };
864    react_production.useActionState = function(action, initialState, permalink) {
865      return ReactSharedInternals.H.useActionState(action, initialState, permalink);
866    };
867    react_production.useCallback = function(callback, deps) {
868      return ReactSharedInternals.H.useCallback(callback, deps);
869    };
870    react_production.useContext = function(Context2) {
871      return ReactSharedInternals.H.useContext(Context2);
872    };
873    react_production.useDebugValue = function() {
874    };
875    react_production.useDeferredValue = function(value, initialValue) {
876      return ReactSharedInternals.H.useDeferredValue(value, initialValue);
877    };
878    react_production.useEffect = function(create2, deps) {
879      return ReactSharedInternals.H.useEffect(create2, deps);
880    };
881    react_production.useEffectEvent = function(callback) {
882      return ReactSharedInternals.H.useEffectEvent(callback);
883    };
884    react_production.useId = function() {
885      return ReactSharedInternals.H.useId();
886    };
887    react_production.useImperativeHandle = function(ref2, create2, deps) {
888      return ReactSharedInternals.H.useImperativeHandle(ref2, create2, deps);
889    };
890    react_production.useInsertionEffect = function(create2, deps) {
891      return ReactSharedInternals.H.useInsertionEffect(create2, deps);
892    };
893    react_production.useLayoutEffect = function(create2, deps) {
894      return ReactSharedInternals.H.useLayoutEffect(create2, deps);
895    };
896    react_production.useMemo = function(create2, deps) {
897      return ReactSharedInternals.H.useMemo(create2, deps);
898    };
899    react_production.useOptimistic = function(passthrough, reducer) {
900      return ReactSharedInternals.H.useOptimistic(passthrough, reducer);
901    };
902    react_production.useReducer = function(reducer, initialArg, init) {
903      return ReactSharedInternals.H.useReducer(reducer, initialArg, init);
904    };
905    react_production.useRef = function(initialValue) {
906      return ReactSharedInternals.H.useRef(initialValue);
907    };
908    react_production.useState = function(initialState) {
909      return ReactSharedInternals.H.useState(initialState);
910    };
911    react_production.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
912      return ReactSharedInternals.H.useSyncExternalStore(
913        subscribe,
914        getSnapshot,
915        getServerSnapshot
916      );
917    };
918    react_production.useTransition = function() {
919      return ReactSharedInternals.H.useTransition();
920    };
921    react_production.version = "19.2.5";
922    return react_production;
923  }
924  var hasRequiredReact;
925  function requireReact() {
926    if (hasRequiredReact) return react.exports;
927    hasRequiredReact = 1;
928    {
929      react.exports = requireReact_production();
930    }
931    return react.exports;
932  }
933  var reactDom = { exports: {} };
934  var reactDom_production = {};
935  /**
936  * @license React
937  * react-dom.production.js
938  *
939  * Copyright (c) Meta Platforms, Inc. and affiliates.
940  *
941  * This source code is licensed under the MIT license found in the
942  * LICENSE file in the root directory of this source tree.
943  */
944  var hasRequiredReactDom_production;
945  function requireReactDom_production() {
946    if (hasRequiredReactDom_production) return reactDom_production;
947    hasRequiredReactDom_production = 1;
948    var React2 = requireReact();
949    function formatProdErrorMessage(code2) {
950      var url2 = "https://react.dev/errors/" + code2;
951      if (1 < arguments.length) {

vendor: 13,485 bytes, lines 952-1254

952        url2 += "?args[]=" + encodeURIComponent(arguments[1]);
953        for (var i2 = 2; i2 < arguments.length; i2++)
954          url2 += "&args[]=" + encodeURIComponent(arguments[i2]);
955      }
956      return "Minified React error #" + code2 + "; visit " + url2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
957    }
958    function noop2() {
959    }
960    var Internals = {
961      d: {
962        f: noop2,
963        r: function() {
964          throw Error(formatProdErrorMessage(522));
965        },
966        D: noop2,
967        C: noop2,
968        L: noop2,
969        m: noop2,
970        X: noop2,
971        S: noop2,
972        M: noop2
973      },
974      p: 0,
975      findDOMNode: null
976    }, REACT_PORTAL_TYPE = Symbol.for("react.portal");
977    function createPortal$1(children, containerInfo, implementation2) {
978      var key2 = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
979      return {
980        $$typeof: REACT_PORTAL_TYPE,
981        key: null == key2 ? null : "" + key2,
982        children,
983        containerInfo,
984        implementation: implementation2
985      };
986    }
987    var ReactSharedInternals = React2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
988    function getCrossOriginStringAs(as, input) {
989      if ("font" === as) return "";
990      if ("string" === typeof input)
991        return "use-credentials" === input ? input : "";
992    }
993    reactDom_production.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
994    reactDom_production.createPortal = function(children, container) {
995      var key2 = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
996      if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
997        throw Error(formatProdErrorMessage(299));
998      return createPortal$1(children, container, null, key2);
999    };
1000    reactDom_production.flushSync = function(fn) {
1001      var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
1002      try {
1003        if (ReactSharedInternals.T = null, Internals.p = 2, fn) return fn();
1004      } finally {
1005        ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f();
1006      }
1007    };
1008    reactDom_production.preconnect = function(href, options) {
1009      "string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
1010    };
1011    reactDom_production.prefetchDNS = function(href) {
1012      "string" === typeof href && Internals.d.D(href);
1013    };
1014    reactDom_production.preinit = function(href, options) {
1015      if ("string" === typeof href && options && "string" === typeof options.as) {
1016        var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
1017        "style" === as ? Internals.d.S(
1018          href,
1019          "string" === typeof options.precedence ? options.precedence : void 0,
1020          {
1021            crossOrigin,
1022            integrity,
1023            fetchPriority
1024          }
1025        ) : "script" === as && Internals.d.X(href, {
1026          crossOrigin,
1027          integrity,
1028          fetchPriority,
1029          nonce: "string" === typeof options.nonce ? options.nonce : void 0
1030        });
1031      }
1032    };
1033    reactDom_production.preinitModule = function(href, options) {
1034      if ("string" === typeof href)
1035        if ("object" === typeof options && null !== options) {
1036          if (null == options.as || "script" === options.as) {
1037            var crossOrigin = getCrossOriginStringAs(
1038              options.as,
1039              options.crossOrigin
1040            );
1041            Internals.d.M(href, {
1042              crossOrigin,
1043              integrity: "string" === typeof options.integrity ? options.integrity : void 0,
1044              nonce: "string" === typeof options.nonce ? options.nonce : void 0
1045            });
1046          }
1047        } else null == options && Internals.d.M(href);
1048    };
1049    reactDom_production.preload = function(href, options) {
1050      if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
1051        var as = options.as, crossOrigin = getCrossOriginStringAs(as, options.crossOrigin);
1052        Internals.d.L(href, as, {
1053          crossOrigin,
1054          integrity: "string" === typeof options.integrity ? options.integrity : void 0,
1055          nonce: "string" === typeof options.nonce ? options.nonce : void 0,
1056          type: "string" === typeof options.type ? options.type : void 0,
1057          fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
1058          referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
1059          imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
1060          imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
1061          media: "string" === typeof options.media ? options.media : void 0
1062        });
1063      }
1064    };
1065    reactDom_production.preloadModule = function(href, options) {
1066      if ("string" === typeof href)
1067        if (options) {
1068          var crossOrigin = getCrossOriginStringAs(options.as, options.crossOrigin);
1069          Internals.d.m(href, {
1070            as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
1071            crossOrigin,
1072            integrity: "string" === typeof options.integrity ? options.integrity : void 0
1073          });
1074        } else Internals.d.m(href);
1075    };
1076    reactDom_production.requestFormReset = function(form) {
1077      Internals.d.r(form);
1078    };
1079    reactDom_production.unstable_batchedUpdates = function(fn, a) {
1080      return fn(a);
1081    };
1082    reactDom_production.useFormState = function(action, initialState, permalink) {
1083      return ReactSharedInternals.H.useFormState(action, initialState, permalink);
1084    };
1085    reactDom_production.useFormStatus = function() {
1086      return ReactSharedInternals.H.useHostTransitionStatus();
1087    };
1088    reactDom_production.version = "19.2.5";
1089    return reactDom_production;
1090  }
1091  var hasRequiredReactDom;
1092  function requireReactDom() {
1093    if (hasRequiredReactDom) return reactDom.exports;
1094    hasRequiredReactDom = 1;
1095    function checkDCE() {
1096      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") {
1097        return;
1098      }
1099      try {
1100        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
1101      } catch (err) {
1102        console.error(err);
1103      }
1104    }
1105    {
1106      checkDCE();
1107      reactDom.exports = requireReactDom_production();
1108    }
1109    return reactDom.exports;
1110  }
1111  var hasRequiredReactDomClient_production;
1112  function requireReactDomClient_production() {
1113    if (hasRequiredReactDomClient_production) return reactDomClient_production;
1114    hasRequiredReactDomClient_production = 1;
1115    var Scheduler = requireScheduler(), React2 = requireReact(), ReactDOM2 = requireReactDom();
1116    function formatProdErrorMessage(code2) {
1117      var url2 = "https://react.dev/errors/" + code2;
1118      if (1 < arguments.length) {
1119        url2 += "?args[]=" + encodeURIComponent(arguments[1]);
1120        for (var i2 = 2; i2 < arguments.length; i2++)
1121          url2 += "&args[]=" + encodeURIComponent(arguments[i2]);
1122      }
1123      return "Minified React error #" + code2 + "; visit " + url2 + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
1124    }
1125    function isValidContainer(node2) {
1126      return !(!node2 || 1 !== node2.nodeType && 9 !== node2.nodeType && 11 !== node2.nodeType);
1127    }
1128    function getNearestMountedFiber(fiber) {
1129      var node2 = fiber, nearestMounted = fiber;
1130      if (fiber.alternate) for (; node2.return; ) node2 = node2.return;
1131      else {
1132        fiber = node2;
1133        do
1134          node2 = fiber, 0 !== (node2.flags & 4098) && (nearestMounted = node2.return), fiber = node2.return;
1135        while (fiber);
1136      }
1137      return 3 === node2.tag ? nearestMounted : null;
1138    }
1139    function getSuspenseInstanceFromFiber(fiber) {
1140      if (13 === fiber.tag) {
1141        var suspenseState = fiber.memoizedState;
1142        null === suspenseState && (fiber = fiber.alternate, null !== fiber && (suspenseState = fiber.memoizedState));
1143        if (null !== suspenseState) return suspenseState.dehydrated;
1144      }
1145      return null;
1146    }
1147    function getActivityInstanceFromFiber(fiber) {
1148      if (31 === fiber.tag) {
1149        var activityState = fiber.memoizedState;
1150        null === activityState && (fiber = fiber.alternate, null !== fiber && (activityState = fiber.memoizedState));
1151        if (null !== activityState) return activityState.dehydrated;
1152      }
1153      return null;
1154    }
1155    function assertIsMounted(fiber) {
1156      if (getNearestMountedFiber(fiber) !== fiber)
1157        throw Error(formatProdErrorMessage(188));
1158    }
1159    function findCurrentFiberUsingSlowPath(fiber) {
1160      var alternate = fiber.alternate;
1161      if (!alternate) {
1162        alternate = getNearestMountedFiber(fiber);
1163        if (null === alternate) throw Error(formatProdErrorMessage(188));
1164        return alternate !== fiber ? null : fiber;
1165      }
1166      for (var a = fiber, b = alternate; ; ) {
1167        var parentA = a.return;
1168        if (null === parentA) break;
1169        var parentB = parentA.alternate;
1170        if (null === parentB) {
1171          b = parentA.return;
1172          if (null !== b) {
1173            a = b;
1174            continue;
1175          }
1176          break;
1177        }
1178        if (parentA.child === parentB.child) {
1179          for (parentB = parentA.child; parentB; ) {
1180            if (parentB === a) return assertIsMounted(parentA), fiber;
1181            if (parentB === b) return assertIsMounted(parentA), alternate;
1182            parentB = parentB.sibling;
1183          }
1184          throw Error(formatProdErrorMessage(188));
1185        }
1186        if (a.return !== b.return) a = parentA, b = parentB;
1187        else {
1188          for (var didFindChild = false, child$0 = parentA.child; child$0; ) {
1189            if (child$0 === a) {
1190              didFindChild = true;
1191              a = parentA;
1192              b = parentB;
1193              break;
1194            }
1195            if (child$0 === b) {
1196              didFindChild = true;
1197              b = parentA;
1198              a = parentB;
1199              break;
1200            }
1201            child$0 = child$0.sibling;
1202          }
1203          if (!didFindChild) {
1204            for (child$0 = parentB.child; child$0; ) {
1205              if (child$0 === a) {
1206                didFindChild = true;
1207                a = parentB;
1208                b = parentA;
1209                break;
1210              }
1211              if (child$0 === b) {
1212                didFindChild = true;
1213                b = parentB;
1214                a = parentA;
1215                break;
1216              }
1217              child$0 = child$0.sibling;
1218            }
1219            if (!didFindChild) throw Error(formatProdErrorMessage(189));
1220          }
1221        }
1222        if (a.alternate !== b) throw Error(formatProdErrorMessage(190));
1223      }
1224      if (3 !== a.tag) throw Error(formatProdErrorMessage(188));
1225      return a.stateNode.current === a ? fiber : alternate;
1226    }
1227    function findCurrentHostFiberImpl(node2) {
1228      var tag = node2.tag;
1229      if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node2;
1230      for (node2 = node2.child; null !== node2; ) {
1231        tag = findCurrentHostFiberImpl(node2);
1232        if (null !== tag) return tag;
1233        node2 = node2.sibling;
1234      }
1235      return null;
1236    }
1237    var assign = Object.assign, REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy");
1238    var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
1239    var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
1240    var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
1241    function getIteratorFn(maybeIterable) {
1242      if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
1243      maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
1244      return "function" === typeof maybeIterable ? maybeIterable : null;
1245    }
1246    var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
1247    function getComponentNameFromType(type2) {
1248      if (null == type2) return null;
1249      if ("function" === typeof type2)
1250        return type2.$$typeof === REACT_CLIENT_REFERENCE ? null : type2.displayName || type2.name || null;
1251      if ("string" === typeof type2) return type2;
1252      switch (type2) {
1253        case REACT_FRAGMENT_TYPE:
1254          return "Fragment";

vendor: 4,131 bytes, lines 1255-1349

1255        case REACT_PROFILER_TYPE:
1256          return "Profiler";
1257        case REACT_STRICT_MODE_TYPE:
1258          return "StrictMode";
1259        case REACT_SUSPENSE_TYPE:
1260          return "Suspense";
1261        case REACT_SUSPENSE_LIST_TYPE:
1262          return "SuspenseList";
1263        case REACT_ACTIVITY_TYPE:
1264          return "Activity";
1265      }
1266      if ("object" === typeof type2)
1267        switch (type2.$$typeof) {
1268          case REACT_PORTAL_TYPE:
1269            return "Portal";
1270          case REACT_CONTEXT_TYPE:
1271            return type2.displayName || "Context";
1272          case REACT_CONSUMER_TYPE:
1273            return (type2._context.displayName || "Context") + ".Consumer";
1274          case REACT_FORWARD_REF_TYPE:
1275            var innerType = type2.render;
1276            type2 = type2.displayName;
1277            type2 || (type2 = innerType.displayName || innerType.name || "", type2 = "" !== type2 ? "ForwardRef(" + type2 + ")" : "ForwardRef");
1278            return type2;
1279          case REACT_MEMO_TYPE:
1280            return innerType = type2.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type2.type) || "Memo";
1281          case REACT_LAZY_TYPE:
1282            innerType = type2._payload;
1283            type2 = type2._init;
1284            try {
1285              return getComponentNameFromType(type2(innerType));
1286            } catch (x) {
1287            }
1288        }
1289      return null;
1290    }
1291    var isArrayImpl = Array.isArray, ReactSharedInternals = React2.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, ReactDOMSharedInternals = ReactDOM2.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, sharedNotPendingObject = {
1292      pending: false,
1293      data: null,
1294      method: null,
1295      action: null
1296    }, valueStack = [], index = -1;
1297    function createCursor(defaultValue) {
1298      return { current: defaultValue };
1299    }
1300    function pop(cursor) {
1301      0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
1302    }
1303    function push(cursor, value) {
1304      index++;
1305      valueStack[index] = cursor.current;
1306      cursor.current = value;
1307    }
1308    var contextStackCursor = createCursor(null), contextFiberStackCursor = createCursor(null), rootInstanceStackCursor = createCursor(null), hostTransitionProviderCursor = createCursor(null);
1309    function pushHostContainer(fiber, nextRootInstance) {
1310      push(rootInstanceStackCursor, nextRootInstance);
1311      push(contextFiberStackCursor, fiber);
1312      push(contextStackCursor, null);
1313      switch (nextRootInstance.nodeType) {
1314        case 9:
1315        case 11:
1316          fiber = (fiber = nextRootInstance.documentElement) ? (fiber = fiber.namespaceURI) ? getOwnHostContext(fiber) : 0 : 0;
1317          break;
1318        default:
1319          if (fiber = nextRootInstance.tagName, nextRootInstance = nextRootInstance.namespaceURI)
1320            nextRootInstance = getOwnHostContext(nextRootInstance), fiber = getChildHostContextProd(nextRootInstance, fiber);
1321          else
1322            switch (fiber) {
1323              case "svg":
1324                fiber = 1;
1325                break;
1326              case "math":
1327                fiber = 2;
1328                break;
1329              default:
1330                fiber = 0;
1331            }
1332      }
1333      pop(contextStackCursor);
1334      push(contextStackCursor, fiber);
1335    }
1336    function popHostContainer() {
1337      pop(contextStackCursor);
1338      pop(contextFiberStackCursor);
1339      pop(rootInstanceStackCursor);
1340    }
1341    function pushHostContext(fiber) {
1342      null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber);
1343      var context = contextStackCursor.current;
1344      var JSCompiler_inline_result = getChildHostContextProd(context, fiber.type);
1345      context !== JSCompiler_inline_result && (push(contextFiberStackCursor, fiber), push(contextStackCursor, JSCompiler_inline_result));
1346    }
1347    function popHostContext(fiber) {
1348      contextFiberStackCursor.current === fiber && (pop(contextStackCursor), pop(contextFiberStackCursor));
1349      hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor), HostTransitionContext._currentValue = sharedNotPendingOb

vendor: 5,691 bytes, lines 1349-1478

1349ject);
1350    }
1351    var prefix, suffix;
1352    function describeBuiltInComponentFrame(name) {
1353      if (void 0 === prefix)
1354        try {
1355          throw Error();
1356        } catch (x) {
1357          var match = x.stack.trim().match(/\n( *(at )?)/);
1358          prefix = match && match[1] || "";
1359          suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
1360        }
1361      return "\n" + prefix + name + suffix;
1362    }
1363    var reentry = false;
1364    function describeNativeComponentFrame(fn, construct) {
1365      if (!fn || reentry) return "";
1366      reentry = true;
1367      var previousPrepareStackTrace = Error.prepareStackTrace;
1368      Error.prepareStackTrace = void 0;
1369      try {
1370        var RunInRootFrame = {
1371          DetermineComponentFrameRoot: function() {
1372            try {
1373              if (construct) {
1374                var Fake = function() {
1375                  throw Error();
1376                };
1377                Object.defineProperty(Fake.prototype, "props", {
1378                  set: function() {
1379                    throw Error();
1380                  }
1381                });
1382                if ("object" === typeof Reflect && Reflect.construct) {
1383                  try {
1384                    Reflect.construct(Fake, []);
1385                  } catch (x) {
1386                    var control = x;
1387                  }
1388                  Reflect.construct(fn, [], Fake);
1389                } else {
1390                  try {
1391                    Fake.call();
1392                  } catch (x$1) {
1393                    control = x$1;
1394                  }
1395                  fn.call(Fake.prototype);
1396                }
1397              } else {
1398                try {
1399                  throw Error();
1400                } catch (x$2) {
1401                  control = x$2;
1402                }
1403                (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function() {
1404                });
1405              }
1406            } catch (sample) {
1407              if (sample && control && "string" === typeof sample.stack)
1408                return [sample.stack, control.stack];
1409            }
1410            return [null, null];
1411          }
1412        };
1413        RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
1414        var namePropDescriptor = Object.getOwnPropertyDescriptor(
1415          RunInRootFrame.DetermineComponentFrameRoot,
1416          "name"
1417        );
1418        namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(
1419          RunInRootFrame.DetermineComponentFrameRoot,
1420          "name",
1421          { value: "DetermineComponentFrameRoot" }
1422        );
1423        var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
1424        if (sampleStack && controlStack) {
1425          var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
1426          for (namePropDescriptor = RunInRootFrame = 0; RunInRootFrame < sampleLines.length && !sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot"); )
1427            RunInRootFrame++;
1428          for (; namePropDescriptor < controlLines.length && !controlLines[namePropDescriptor].includes(
1429            "DetermineComponentFrameRoot"
1430          ); )
1431            namePropDescriptor++;
1432          if (RunInRootFrame === sampleLines.length || namePropDescriptor === controlLines.length)
1433            for (RunInRootFrame = sampleLines.length - 1, namePropDescriptor = controlLines.length - 1; 1 <= RunInRootFrame && 0 <= namePropDescriptor && sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]; )
1434              namePropDescriptor--;
1435          for (; 1 <= RunInRootFrame && 0 <= namePropDescriptor; RunInRootFrame--, namePropDescriptor--)
1436            if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
1437              if (1 !== RunInRootFrame || 1 !== namePropDescriptor) {
1438                do
1439                  if (RunInRootFrame--, namePropDescriptor--, 0 > namePropDescriptor || sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
1440                    var frame = "\n" + sampleLines[RunInRootFrame].replace(" at new ", " at ");
1441                    fn.displayName && frame.includes("<anonymous>") && (frame = frame.replace("<anonymous>", fn.displayName));
1442                    return frame;
1443                  }
1444                while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
1445              }
1446              break;
1447            }
1448        }
1449      } finally {
1450        reentry = false, Error.prepareStackTrace = previousPrepareStackTrace;
1451      }
1452      return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(previousPrepareStackTrace) : "";
1453    }
1454    function describeFiber(fiber, childFiber) {
1455      switch (fiber.tag) {
1456        case 26:
1457        case 27:
1458        case 5:
1459          return describeBuiltInComponentFrame(fiber.type);
1460        case 16:
1461          return describeBuiltInComponentFrame("Lazy");
1462        case 13:
1463          return fiber.child !== childFiber && null !== childFiber ? describeBuiltInComponentFrame("Suspense Fallback") : describeBuiltInComponentFrame("Suspense");
1464        case 19:
1465          return describeBuiltInComponentFrame("SuspenseList");
1466        case 0:
1467        case 15:
1468          return describeNativeComponentFrame(fiber.type, false);
1469        case 11:
1470          return describeNativeComponentFrame(fiber.type.render, false);
1471        case 1:
1472          return describeNativeComponentFrame(fiber.type, true);
1473        case 31:
1474          return describeBuiltInComponentFrame("Activity");
1475        default:
1476          return "";
1477      }
1478    }

vendor: 13,271 bytes, lines 1479-1784

1479    function getStackByFiberInDevAndProd(workInProgress2) {
1480      try {
1481        var info = "", previous = null;
1482        do
1483          info += describeFiber(workInProgress2, previous), previous = workInProgress2, workInProgress2 = workInProgress2.return;
1484        while (workInProgress2);
1485        return info;
1486      } catch (x) {
1487        return "\nError generating stack: " + x.message + "\n" + x.stack;
1488      }
1489    }
1490    var hasOwnProperty2 = Object.prototype.hasOwnProperty, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now = Scheduler.unstable_now, getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, LowPriority = Scheduler.unstable_LowPriority, IdlePriority = Scheduler.unstable_IdlePriority, log$1 = Scheduler.log, unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null;
1491    function setIsStrictModeForDevtools(newIsStrictMode) {
1492      "function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
1493      if (injectedHook && "function" === typeof injectedHook.setStrictMode)
1494        try {
1495          injectedHook.setStrictMode(rendererID, newIsStrictMode);
1496        } catch (err) {
1497        }
1498    }
1499    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log = Math.log, LN2 = Math.LN2;
1500    function clz32Fallback(x) {
1501      x >>>= 0;
1502      return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
1503    }
1504    var nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304;
1505    function getHighestPriorityLanes(lanes) {
1506      var pendingSyncLanes = lanes & 42;
1507      if (0 !== pendingSyncLanes) return pendingSyncLanes;
1508      switch (lanes & -lanes) {
1509        case 1:
1510          return 1;
1511        case 2:
1512          return 2;
1513        case 4:
1514          return 4;
1515        case 8:
1516          return 8;
1517        case 16:
1518          return 16;
1519        case 32:
1520          return 32;
1521        case 64:
1522          return 64;
1523        case 128:
1524          return 128;
1525        case 256:
1526        case 512:
1527        case 1024:
1528        case 2048:
1529        case 4096:
1530        case 8192:
1531        case 16384:
1532        case 32768:
1533        case 65536:
1534        case 131072:
1535          return lanes & 261888;
1536        case 262144:
1537        case 524288:
1538        case 1048576:
1539        case 2097152:
1540          return lanes & 3932160;
1541        case 4194304:
1542        case 8388608:
1543        case 16777216:
1544        case 33554432:
1545          return lanes & 62914560;
1546        case 67108864:
1547          return 67108864;
1548        case 134217728:
1549          return 134217728;
1550        case 268435456:
1551          return 268435456;
1552        case 536870912:
1553          return 536870912;
1554        case 1073741824:
1555          return 0;
1556        default:
1557          return lanes;
1558      }
1559    }
1560    function getNextLanes(root2, wipLanes, rootHasPendingCommit) {
1561      var pendingLanes = root2.pendingLanes;
1562      if (0 === pendingLanes) return 0;
1563      var nextLanes = 0, suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes;
1564      root2 = root2.warmLanes;
1565      var nonIdlePendingLanes = pendingLanes & 134217727;
1566      0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root2, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root2, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
1567      return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
1568    }
1569    function checkIfRootIsPrerendering(root2, renderLanes2) {
1570      return 0 === (root2.pendingLanes & ~(root2.suspendedLanes & ~root2.pingedLanes) & renderLanes2);
1571    }
1572    function computeExpirationTime(lane, currentTime) {
1573      switch (lane) {
1574        case 1:
1575        case 2:
1576        case 4:
1577        case 8:
1578        case 64:
1579          return currentTime + 250;
1580        case 16:
1581        case 32:
1582        case 128:
1583        case 256:
1584        case 512:
1585        case 1024:
1586        case 2048:
1587        case 4096:
1588        case 8192:
1589        case 16384:
1590        case 32768:
1591        case 65536:
1592        case 131072:
1593        case 262144:
1594        case 524288:
1595        case 1048576:
1596        case 2097152:
1597          return currentTime + 5e3;
1598        case 4194304:
1599        case 8388608:
1600        case 16777216:
1601        case 33554432:
1602          return -1;
1603        case 67108864:
1604        case 134217728:
1605        case 268435456:
1606        case 536870912:
1607        case 1073741824:
1608          return -1;
1609        default:
1610          return -1;
1611      }
1612    }
1613    function claimNextRetryLane() {
1614      var lane = nextRetryLane;
1615      nextRetryLane <<= 1;
1616      0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
1617      return lane;
1618    }
1619    function createLaneMap(initial) {
1620      for (var laneMap = [], i2 = 0; 31 > i2; i2++) laneMap.push(initial);
1621      return laneMap;
1622    }
1623    function markRootUpdated$1(root2, updateLane) {
1624      root2.pendingLanes |= updateLane;
1625      268435456 !== updateLane && (root2.suspendedLanes = 0, root2.pingedLanes = 0, root2.warmLanes = 0);
1626    }
1627    function markRootFinished(root2, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
1628      var previouslyPendingLanes = root2.pendingLanes;
1629      root2.pendingLanes = remainingLanes;
1630      root2.suspendedLanes = 0;
1631      root2.pingedLanes = 0;
1632      root2.warmLanes = 0;
1633      root2.expiredLanes &= remainingLanes;
1634      root2.entangledLanes &= remainingLanes;
1635      root2.errorRecoveryDisabledLanes &= remainingLanes;
1636      root2.shellSuspendCounter = 0;
1637      var entanglements = root2.entanglements, expirationTimes = root2.expirationTimes, hiddenUpdates = root2.hiddenUpdates;
1638      for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes; ) {
1639        var index$7 = 31 - clz32(remainingLanes), lane = 1 << index$7;
1640        entanglements[index$7] = 0;
1641        expirationTimes[index$7] = -1;
1642        var hiddenUpdatesForLane = hiddenUpdates[index$7];
1643        if (null !== hiddenUpdatesForLane)
1644          for (hiddenUpdates[index$7] = null, index$7 = 0; index$7 < hiddenUpdatesForLane.length; index$7++) {
1645            var update = hiddenUpdatesForLane[index$7];
1646            null !== update && (update.lane &= -536870913);
1647          }
1648        remainingLanes &= ~lane;
1649      }
1650      0 !== spawnedLane && markSpawnedDeferredLane(root2, spawnedLane, 0);
1651      0 !== suspendedRetryLanes && 0 === updatedLanes && 0 !== root2.tag && (root2.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
1652    }
1653    function markSpawnedDeferredLane(root2, spawnedLane, entangledLanes) {
1654      root2.pendingLanes |= spawnedLane;
1655      root2.suspendedLanes &= ~spawnedLane;
1656      var spawnedLaneIndex = 31 - clz32(spawnedLane);
1657      root2.entangledLanes |= spawnedLane;
1658      root2.entanglements[spawnedLaneIndex] = root2.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 261930;
1659    }
1660    function markRootEntangled(root2, entangledLanes) {
1661      var rootEntangledLanes = root2.entangledLanes |= entangledLanes;
1662      for (root2 = root2.entanglements; rootEntangledLanes; ) {
1663        var index$8 = 31 - clz32(rootEntangledLanes), lane = 1 << index$8;
1664        lane & entangledLanes | root2[index$8] & entangledLanes && (root2[index$8] |= entangledLanes);
1665        rootEntangledLanes &= ~lane;
1666      }
1667    }
1668    function getBumpedLaneForHydration(root2, renderLanes2) {
1669      var renderLane = renderLanes2 & -renderLanes2;
1670      renderLane = 0 !== (renderLane & 42) ? 1 : getBumpedLaneForHydrationByLane(renderLane);
1671      return 0 !== (renderLane & (root2.suspendedLanes | renderLanes2)) ? 0 : renderLane;
1672    }
1673    function getBumpedLaneForHydrationByLane(lane) {
1674      switch (lane) {
1675        case 2:
1676          lane = 1;
1677          break;
1678        case 8:
1679          lane = 4;
1680          break;
1681        case 32:
1682          lane = 16;
1683          break;
1684        case 256:
1685        case 512:
1686        case 1024:
1687        case 2048:
1688        case 4096:
1689        case 8192:
1690        case 16384:
1691        case 32768:
1692        case 65536:
1693        case 131072:
1694        case 262144:
1695        case 524288:
1696        case 1048576:
1697        case 2097152:
1698        case 4194304:
1699        case 8388608:
1700        case 16777216:
1701        case 33554432:
1702          lane = 128;
1703          break;
1704        case 268435456:
1705          lane = 134217728;
1706          break;
1707        default:
1708          lane = 0;
1709      }
1710      return lane;
1711    }
1712    function lanesToEventPriority(lanes) {
1713      lanes &= -lanes;
1714      return 2 < lanes ? 8 < lanes ? 0 !== (lanes & 134217727) ? 32 : 268435456 : 8 : 2;
1715    }
1716    function resolveUpdatePriority() {
1717      var updatePriority = ReactDOMSharedInternals.p;
1718      if (0 !== updatePriority) return updatePriority;
1719      updatePriority = window.event;
1720      return void 0 === updatePriority ? 32 : getEventPriority(updatePriority.type);
1721    }
1722    function runWithPriority(priority, fn) {
1723      var previousPriority = ReactDOMSharedInternals.p;
1724      try {
1725        return ReactDOMSharedInternals.p = priority, fn();
1726      } finally {
1727        ReactDOMSharedInternals.p = previousPriority;
1728      }
1729    }
1730    var randomKey = Math.random().toString(36).slice(2), internalInstanceKey = "__reactFiber$" + randomKey, internalPropsKey = "__reactProps$" + randomKey, internalContainerInstanceKey = "__reactContainer$" + randomKey, internalEventHandlersKey = "__reactEvents$" + randomKey, internalEventHandlerListenersKey = "__reactListeners$" + randomKey, internalEventHandlesSetKey = "__reactHandles$" + randomKey, internalRootNodeResourcesKey = "__reactResources$" + randomKey, internalHoistableMarker = "__reactMarker$" + randomKey;
1731    function detachDeletedInstance(node2) {
1732      delete node2[internalInstanceKey];
1733      delete node2[internalPropsKey];
1734      delete node2[internalEventHandlersKey];
1735      delete node2[internalEventHandlerListenersKey];
1736      delete node2[internalEventHandlesSetKey];
1737    }
1738    function getClosestInstanceFromNode(targetNode) {
1739      var targetInst = targetNode[internalInstanceKey];
1740      if (targetInst) return targetInst;
1741      for (var parentNode = targetNode.parentNode; parentNode; ) {
1742        if (targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
1743          parentNode = targetInst.alternate;
1744          if (null !== targetInst.child || null !== parentNode && null !== parentNode.child)
1745            for (targetNode = getParentHydrationBoundary(targetNode); null !== targetNode; ) {
1746              if (parentNode = targetNode[internalInstanceKey]) return parentNode;
1747              targetNode = getParentHydrationBoundary(targetNode);
1748            }
1749          return targetInst;
1750        }
1751        targetNode = parentNode;
1752        parentNode = targetNode.parentNode;
1753      }
1754      return null;
1755    }
1756    function getInstanceFromNode(node2) {
1757      if (node2 = node2[internalInstanceKey] || node2[internalContainerInstanceKey]) {
1758        var tag = node2.tag;
1759        if (5 === tag || 6 === tag || 13 === tag || 31 === tag || 26 === tag || 27 === tag || 3 === tag)
1760          return node2;
1761      }
1762      return null;
1763    }
1764    function getNodeFromInstance(inst) {
1765      var tag = inst.tag;
1766      if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return inst.stateNode;
1767      throw Error(formatProdErrorMessage(33));
1768    }
1769    function getResourcesFromRoot(root2) {
1770      var resources = root2[internalRootNodeResourcesKey];
1771      resources || (resources = root2[internalRootNodeResourcesKey] = { hoistableStyles: /* @__PURE__ */ new Map(), hoistableScripts: /* @__PURE__ */ new Map() });
1772      return resources;
1773    }
1774    function markNodeAsHoistable(node2) {
1775      node2[internalHoistableMarker] = true;
1776    }
1777    var allNativeEvents = /* @__PURE__ */ new Set(), registrationNameDependencies = {};
1778    function registerTwoPhaseEvent(registrationName, dependencies) {
1779      registerDirectEvent(registrationName, dependencies);
1780      registerDirectEvent(registrationName + "Capture", dependencies);
1781    }
1782    function registerDirectEvent(registrationName, dependencies) {
1783      registrationNameDependencies[registrationName] = dependencies;
1784      for (registrationName = 0;

vendor: 4,573 bytes, lines 1784-1910

1784 registrationName < dependencies.length; registrationName++)
1785        allNativeEvents.add(dependencies[registrationName]);
1786    }
1787    var VALID_ATTRIBUTE_NAME_REGEX = RegExp(
1788      "^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
1789    ), illegalAttributeNameCache = {}, validatedAttributeNameCache = {};
1790    function isAttributeNameSafe(attributeName) {
1791      if (hasOwnProperty2.call(validatedAttributeNameCache, attributeName))
1792        return true;
1793      if (hasOwnProperty2.call(illegalAttributeNameCache, attributeName)) return false;
1794      if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName))
1795        return validatedAttributeNameCache[attributeName] = true;
1796      illegalAttributeNameCache[attributeName] = true;
1797      return false;
1798    }
1799    function setValueForAttribute(node2, name, value) {
1800      if (isAttributeNameSafe(name))
1801        if (null === value) node2.removeAttribute(name);
1802        else {
1803          switch (typeof value) {
1804            case "undefined":
1805            case "function":
1806            case "symbol":
1807              node2.removeAttribute(name);
1808              return;
1809            case "boolean":
1810              var prefix$10 = name.toLowerCase().slice(0, 5);
1811              if ("data-" !== prefix$10 && "aria-" !== prefix$10) {
1812                node2.removeAttribute(name);
1813                return;
1814              }
1815          }
1816          node2.setAttribute(name, "" + value);
1817        }
1818    }
1819    function setValueForKnownAttribute(node2, name, value) {
1820      if (null === value) node2.removeAttribute(name);
1821      else {
1822        switch (typeof value) {
1823          case "undefined":
1824          case "function":
1825          case "symbol":
1826          case "boolean":
1827            node2.removeAttribute(name);
1828            return;
1829        }
1830        node2.setAttribute(name, "" + value);
1831      }
1832    }
1833    function setValueForNamespacedAttribute(node2, namespace, name, value) {
1834      if (null === value) node2.removeAttribute(name);
1835      else {
1836        switch (typeof value) {
1837          case "undefined":
1838          case "function":
1839          case "symbol":
1840          case "boolean":
1841            node2.removeAttribute(name);
1842            return;
1843        }
1844        node2.setAttributeNS(namespace, name, "" + value);
1845      }
1846    }
1847    function getToStringValue(value) {
1848      switch (typeof value) {
1849        case "bigint":
1850        case "boolean":
1851        case "number":
1852        case "string":
1853        case "undefined":
1854          return value;
1855        case "object":
1856          return value;
1857        default:
1858          return "";
1859      }
1860    }
1861    function isCheckable(elem) {
1862      var type2 = elem.type;
1863      return (elem = elem.nodeName) && "input" === elem.toLowerCase() && ("checkbox" === type2 || "radio" === type2);
1864    }
1865    function trackValueOnNode(node2, valueField, currentValue) {
1866      var descriptor = Object.getOwnPropertyDescriptor(
1867        node2.constructor.prototype,
1868        valueField
1869      );
1870      if (!node2.hasOwnProperty(valueField) && "undefined" !== typeof descriptor && "function" === typeof descriptor.get && "function" === typeof descriptor.set) {
1871        var get2 = descriptor.get, set = descriptor.set;
1872        Object.defineProperty(node2, valueField, {
1873          configurable: true,
1874          get: function() {
1875            return get2.call(this);
1876          },
1877          set: function(value) {
1878            currentValue = "" + value;
1879            set.call(this, value);
1880          }
1881        });
1882        Object.defineProperty(node2, valueField, {
1883          enumerable: descriptor.enumerable
1884        });
1885        return {
1886          getValue: function() {
1887            return currentValue;
1888          },
1889          setValue: function(value) {
1890            currentValue = "" + value;
1891          },
1892          stopTracking: function() {
1893            node2._valueTracker = null;
1894            delete node2[valueField];
1895          }
1896        };
1897      }
1898    }
1899    function track(node2) {
1900      if (!node2._valueTracker) {
1901        var valueField = isCheckable(node2) ? "checked" : "value";
1902        node2._valueTracker = trackValueOnNode(
1903          node2,
1904          valueField,
1905          "" + node2[valueField]
1906        );
1907      }
1908    }
1909    function updateValueIfChanged(node2) {
1910      if (!node2) return false;

vendor: 4,347 bytes, lines 1911-1986

1911      var tracker = node2._valueTracker;
1912      if (!tracker) return true;
1913      var lastValue = tracker.getValue();
1914      var value = "";
1915      node2 && (value = isCheckable(node2) ? node2.checked ? "true" : "false" : node2.value);
1916      node2 = value;
1917      return node2 !== lastValue ? (tracker.setValue(node2), true) : false;
1918    }
1919    function getActiveElement(doc) {
1920      doc = doc || ("undefined" !== typeof document ? document : void 0);
1921      if ("undefined" === typeof doc) return null;
1922      try {
1923        return doc.activeElement || doc.body;
1924      } catch (e) {
1925        return doc.body;
1926      }
1927    }
1928    var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
1929    function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
1930      return value.replace(
1931        escapeSelectorAttributeValueInsideDoubleQuotesRegex,
1932        function(ch) {
1933          return "\\" + ch.charCodeAt(0).toString(16) + " ";
1934        }
1935      );
1936    }
1937    function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type2, name) {
1938      element.name = "";
1939      null != type2 && "function" !== typeof type2 && "symbol" !== typeof type2 && "boolean" !== typeof type2 ? element.type = type2 : element.removeAttribute("type");
1940      if (null != value)
1941        if ("number" === type2) {
1942          if (0 === value && "" === element.value || element.value != value)
1943            element.value = "" + getToStringValue(value);
1944        } else
1945          element.value !== "" + getToStringValue(value) && (element.value = "" + getToStringValue(value));
1946      else
1947        "submit" !== type2 && "reset" !== type2 || element.removeAttribute("value");
1948      null != value ? setDefaultValue(element, type2, getToStringValue(value)) : null != defaultValue ? setDefaultValue(element, type2, getToStringValue(defaultValue)) : null != lastDefaultValue && element.removeAttribute("value");
1949      null == checked && null != defaultChecked && (element.defaultChecked = !!defaultChecked);
1950      null != checked && (element.checked = checked && "function" !== typeof checked && "symbol" !== typeof checked);
1951      null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name ? element.name = "" + getToStringValue(name) : element.removeAttribute("name");
1952    }
1953    function initInput(element, value, defaultValue, checked, defaultChecked, type2, name, isHydrating2) {
1954      null != type2 && "function" !== typeof type2 && "symbol" !== typeof type2 && "boolean" !== typeof type2 && (element.type = type2);
1955      if (null != value || null != defaultValue) {
1956        if (!("submit" !== type2 && "reset" !== type2 || void 0 !== value && null !== value)) {
1957          track(element);
1958          return;
1959        }
1960        defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1961        value = null != value ? "" + getToStringValue(value) : defaultValue;
1962        isHydrating2 || value === element.value || (element.value = value);
1963        element.defaultValue = value;
1964      }
1965      checked = null != checked ? checked : defaultChecked;
1966      checked = "function" !== typeof checked && "symbol" !== typeof checked && !!checked;
1967      element.checked = isHydrating2 ? element.checked : !!checked;
1968      element.defaultChecked = !!checked;
1969      null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name && (element.name = name);
1970      track(element);
1971    }
1972    function setDefaultValue(node2, type2, value) {
1973      "number" === type2 && getActiveElement(node2.ownerDocument) === node2 || node2.defaultValue === "" + value || (node2.defaultValue = "" + value);
1974    }
1975    function updateOptions(node2, multiple, propValue, setDefaultSelected) {
1976      node2 = node2.options;
1977      if (multiple) {
1978        multiple = {};
1979        for (var i2 = 0; i2 < propValue.length; i2++)
1980          multiple["$" + propValue[i2]] = true;
1981        for (propValue = 0; propValue < node2.length; propValue++)
1982          i2 = multiple.hasOwnProperty("$" + node2[propValue].value), node2[propValue].selected !== i2 && (node2[propValue].selected = i2), i2 && setDefaultSelected && (node2[propValue].defaultSelected = true);
1983      } else {
1984        propValue = "" + getToStringValue(propValue);
1985        multiple = null;
1986        for (i2 = 0; i2 < node2.length; i2++) {

vendor: 4,398 bytes, lines 1987-2056

1987          if (node2[i2].value === propValue) {
1988            node2[i2].selected = true;
1989            setDefaultSelected && (node2[i2].defaultSelected = true);
1990            return;
1991          }
1992          null !== multiple || node2[i2].disabled || (multiple = node2[i2]);
1993        }
1994        null !== multiple && (multiple.selected = true);
1995      }
1996    }
1997    function updateTextarea(element, value, defaultValue) {
1998      if (null != value && (value = "" + getToStringValue(value), value !== element.value && (element.value = value), null == defaultValue)) {
1999        element.defaultValue !== value && (element.defaultValue = value);
2000        return;
2001      }
2002      element.defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
2003    }
2004    function initTextarea(element, value, defaultValue, children) {
2005      if (null == value) {
2006        if (null != children) {
2007          if (null != defaultValue) throw Error(formatProdErrorMessage(92));
2008          if (isArrayImpl(children)) {
2009            if (1 < children.length) throw Error(formatProdErrorMessage(93));
2010            children = children[0];
2011          }
2012          defaultValue = children;
2013        }
2014        null == defaultValue && (defaultValue = "");
2015        value = defaultValue;
2016      }
2017      defaultValue = getToStringValue(value);
2018      element.defaultValue = defaultValue;
2019      children = element.textContent;
2020      children === defaultValue && "" !== children && null !== children && (element.value = children);
2021      track(element);
2022    }
2023    function setTextContent(node2, text) {
2024      if (text) {
2025        var firstChild = node2.firstChild;
2026        if (firstChild && firstChild === node2.lastChild && 3 === firstChild.nodeType) {
2027          firstChild.nodeValue = text;
2028          return;
2029        }
2030      }
2031      node2.textContent = text;
2032    }
2033    var unitlessNumbers = new Set(
2034      "animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(
2035        " "
2036      )
2037    );
2038    function setValueForStyle(style2, styleName, value) {
2039      var isCustomProperty = 0 === styleName.indexOf("--");
2040      null == value || "boolean" === typeof value || "" === value ? isCustomProperty ? style2.setProperty(styleName, "") : "float" === styleName ? style2.cssFloat = "" : style2[styleName] = "" : isCustomProperty ? style2.setProperty(styleName, value) : "number" !== typeof value || 0 === value || unitlessNumbers.has(styleName) ? "float" === styleName ? style2.cssFloat = value : style2[styleName] = ("" + value).trim() : style2[styleName] = value + "px";
2041    }
2042    function setValueForStyles(node2, styles, prevStyles) {
2043      if (null != styles && "object" !== typeof styles)
2044        throw Error(formatProdErrorMessage(62));
2045      node2 = node2.style;
2046      if (null != prevStyles) {
2047        for (var styleName in prevStyles)
2048          !prevStyles.hasOwnProperty(styleName) || null != styles && styles.hasOwnProperty(styleName) || (0 === styleName.indexOf("--") ? node2.setProperty(styleName, "") : "float" === styleName ? node2.cssFloat = "" : node2[styleName] = "");
2049        for (var styleName$16 in styles)
2050          styleName = styles[styleName$16], styles.hasOwnProperty(styleName$16) && prevStyles[styleName$16] !== styleName && setValueForStyle(node2, styleName$16, styleName);
2051      } else
2052        for (var styleName$17 in styles)
2053          styles.hasOwnProperty(styleName$17) && setValueForStyle(node2, styleName$17, styles[styleName$17]);
2054    }
2055    function isCustomElement(tagName) {
2056      if (-1 === tagName.indexOf("-")) return false;

vendor: 5,622 bytes, lines 2057-2188

2057      switch (tagName) {
2058        case "annotation-xml":
2059        case "color-profile":
2060        case "font-face":
2061        case "font-face-src":
2062        case "font-face-uri":
2063        case "font-face-format":
2064        case "font-face-name":
2065        case "missing-glyph":
2066          return false;
2067        default:
2068          return true;
2069      }
2070    }
2071    var aliases = /* @__PURE__ */ new Map([
2072      ["acceptCharset", "accept-charset"],
2073      ["htmlFor", "for"],
2074      ["httpEquiv", "http-equiv"],
2075      ["crossOrigin", "crossorigin"],
2076      ["accentHeight", "accent-height"],
2077      ["alignmentBaseline", "alignment-baseline"],
2078      ["arabicForm", "arabic-form"],
2079      ["baselineShift", "baseline-shift"],
2080      ["capHeight", "cap-height"],
2081      ["clipPath", "clip-path"],
2082      ["clipRule", "clip-rule"],
2083      ["colorInterpolation", "color-interpolation"],
2084      ["colorInterpolationFilters", "color-interpolation-filters"],
2085      ["colorProfile", "color-profile"],
2086      ["colorRendering", "color-rendering"],
2087      ["dominantBaseline", "dominant-baseline"],
2088      ["enableBackground", "enable-background"],
2089      ["fillOpacity", "fill-opacity"],
2090      ["fillRule", "fill-rule"],
2091      ["floodColor", "flood-color"],
2092      ["floodOpacity", "flood-opacity"],
2093      ["fontFamily", "font-family"],
2094      ["fontSize", "font-size"],
2095      ["fontSizeAdjust", "font-size-adjust"],
2096      ["fontStretch", "font-stretch"],
2097      ["fontStyle", "font-style"],
2098      ["fontVariant", "font-variant"],
2099      ["fontWeight", "font-weight"],
2100      ["glyphName", "glyph-name"],
2101      ["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
2102      ["glyphOrientationVertical", "glyph-orientation-vertical"],
2103      ["horizAdvX", "horiz-adv-x"],
2104      ["horizOriginX", "horiz-origin-x"],
2105      ["imageRendering", "image-rendering"],
2106      ["letterSpacing", "letter-spacing"],
2107      ["lightingColor", "lighting-color"],
2108      ["markerEnd", "marker-end"],
2109      ["markerMid", "marker-mid"],
2110      ["markerStart", "marker-start"],
2111      ["overlinePosition", "overline-position"],
2112      ["overlineThickness", "overline-thickness"],
2113      ["paintOrder", "paint-order"],
2114      ["panose-1", "panose-1"],
2115      ["pointerEvents", "pointer-events"],
2116      ["renderingIntent", "rendering-intent"],
2117      ["shapeRendering", "shape-rendering"],
2118      ["stopColor", "stop-color"],
2119      ["stopOpacity", "stop-opacity"],
2120      ["strikethroughPosition", "strikethrough-position"],
2121      ["strikethroughThickness", "strikethrough-thickness"],
2122      ["strokeDasharray", "stroke-dasharray"],
2123      ["strokeDashoffset", "stroke-dashoffset"],
2124      ["strokeLinecap", "stroke-linecap"],
2125      ["strokeLinejoin", "stroke-linejoin"],
2126      ["strokeMiterlimit", "stroke-miterlimit"],
2127      ["strokeOpacity", "stroke-opacity"],
2128      ["strokeWidth", "stroke-width"],
2129      ["textAnchor", "text-anchor"],
2130      ["textDecoration", "text-decoration"],
2131      ["textRendering", "text-rendering"],
2132      ["transformOrigin", "transform-origin"],
2133      ["underlinePosition", "underline-position"],
2134      ["underlineThickness", "underline-thickness"],
2135      ["unicodeBidi", "unicode-bidi"],
2136      ["unicodeRange", "unicode-range"],
2137      ["unitsPerEm", "units-per-em"],
2138      ["vAlphabetic", "v-alphabetic"],
2139      ["vHanging", "v-hanging"],
2140      ["vIdeographic", "v-ideographic"],
2141      ["vMathematical", "v-mathematical"],
2142      ["vectorEffect", "vector-effect"],
2143      ["vertAdvY", "vert-adv-y"],
2144      ["vertOriginX", "vert-origin-x"],
2145      ["vertOriginY", "vert-origin-y"],
2146      ["wordSpacing", "word-spacing"],
2147      ["writingMode", "writing-mode"],
2148      ["xmlnsXlink", "xmlns:xlink"],
2149      ["xHeight", "x-height"]
2150    ]), isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
2151    function sanitizeURL(url2) {
2152      return isJavaScriptProtocol.test("" + url2) ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')" : url2;
2153    }
2154    function noop$12() {
2155    }
2156    var currentReplayingEvent = null;
2157    function getEventTarget(nativeEvent) {
2158      nativeEvent = nativeEvent.target || nativeEvent.srcElement || window;
2159      nativeEvent.correspondingUseElement && (nativeEvent = nativeEvent.correspondingUseElement);
2160      return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
2161    }
2162    var restoreTarget = null, restoreQueue = null;
2163    function restoreStateOfTarget(target) {
2164      var internalInstance = getInstanceFromNode(target);
2165      if (internalInstance && (target = internalInstance.stateNode)) {
2166        var props = target[internalPropsKey] || null;
2167        a: switch (target = internalInstance.stateNode, internalInstance.type) {
2168          case "input":
2169            updateInput(
2170              target,
2171              props.value,
2172              props.defaultValue,
2173              props.defaultValue,
2174              props.checked,
2175              props.defaultChecked,
2176              props.type,
2177              props.name
2178            );
2179            internalInstance = props.name;
2180            if ("radio" === props.type && null != internalInstance) {
2181              for (props = target; props.parentNode; ) props = props.parentNode;
2182              props = props.querySelectorAll(
2183                'input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes(
2184                  "" + internalInstance
2185                ) + '"][type="radio"]'
2186              );
2187              for (internalInstance = 0; internalInstance < props.length; internalInstance++) {
2188                var otherNode = props[internalInstance];

2189                if (otherNode !== target && otherNode.form === target.form) {
2190                  var otherProps = otherNode[internalPropsKey] || null;
2191                  if (!otherProps) throw Error(formatProdErrorMessage(90));
2192                  updateInput(
2193                    otherNode,
2194                    otherProps.value,
2195                    otherProps.defaultValue,
2196                    otherProps.defaultValue,
2197                    otherProps.checked,
2198                    otherProps.defaultChecked,
2199                    otherProps.type,
2200                    otherProps.name
2201                  );
2202                }
2203              }
2204              for (internalInstance = 0; internalInstance < props.length; internalInstance++)
2205                otherNode = props[internalInstance], otherNode.form === target.form && updateValueIfChanged(otherNode);
2206            }
2207            break a;
2208          case "textarea":
2209            updateTextarea(target, props.value, props.defaultValue);
2210            break a;
2211          case "select":
2212            internalInstance = props.value, null != internalInstance && updateOptions(target, !!props.multiple, internalInstance, false);
2213        }
2214      }
2215    }
2216    var isInsideEventHandler = false;
2217    function batchedUpdates$1(fn, a, b) {
2218      if (isInsideEventHandler) return fn(a, b);
2219      isInsideEventHandler = true;
2220      try {
2221        var JSCompiler_inline_result = fn(a);
2222        return JSCompiler_inline_result;
2223      } finally {
2224        if (isInsideEventHandler = false, null !== restoreTarget || null !== restoreQueue) {
2225          if (flushSyncWork$1(), restoreTarget && (a = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(a), fn))
2226            for (a = 0; a < fn.length; a++) restoreStateOfTarget(fn[a]);
2227        }
2228      }
2229    }
2230    function getListener(inst, registrationName) {
2231      var stateNode = inst.stateNode;
2232      if (null === stateNode) return null;
2233      var props = stateNode[internalPropsKey] || null;
2234      if (null === props) return null;
2235      stateNode = props[registrationName];
2236      a: switch (registrationName) {
2237        case "onClick":
2238        case "onClickCapture":
2239        case "onDoubleClick":
2240        case "onDoubleClickCapture":
2241        case "onMouseDown":
2242        case "onMouseDownCapture":
2243        case "onMouseMove":
2244        case "onMouseMoveCapture":
2245        case "onMouseUp":
2246        case "onMouseUpCapture":
2247        case "onMouseEnter":
2248          (props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
2249          inst = !props;
2250          break a;
2251        default:
2252          inst = false;
2253      }
2254      if (inst) return null;
2255      if (stateNode && "function" !== typeof stateNode)
2256        throw Error(
2257          formatProdErrorMessage(231, registrationName, typeof stateNode)
2258        );
2259      return stateNode;
2260    }
2261    var canUseDOM = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), passiveBrowserEventsSupported = false;
2262    if (canUseDOM)
2263      try {
2264        var options = {};
2265        Object.defineProperty(options, "passive", {
2266          get: function() {
2267            passiveBrowserEventsSupported = true;
2268          }
2269        });
2270        window.addEventListener("test", options, options);
2271        window.removeEventListener("test", options, options);
2272      } catch (e) {
2273        passiveBrowserEventsSupported = false;
2274      }
2275    var root = null, startText = null, fallbackText = null;
2276    function getData() {
2277      if (fallbackText) return fallbackText;
2278      var start, startValue = startText, startLength = startValue.length, end, endValue = "value" in root ? root.value : root.textContent, endLength = endValue.length;
2279      for (start = 0; start < startLength && startValue[start] === endValue[start]; start++) ;
2280      var minEnd = startLength - start;
2281      for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++) ;
2282      return fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0);
2283    }

vendor: 21,066 bytes, lines 2284-2734

2284    function getEventCharCode(nativeEvent) {
2285      var keyCode = nativeEvent.keyCode;
2286      "charCode" in nativeEvent ? (nativeEvent = nativeEvent.charCode, 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13)) : nativeEvent = keyCode;
2287      10 === nativeEvent && (nativeEvent = 13);
2288      return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
2289    }
2290    function functionThatReturnsTrue() {
2291      return true;
2292    }
2293    function functionThatReturnsFalse() {
2294      return false;
2295    }
2296    function createSyntheticEvent(Interface) {
2297      function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
2298        this._reactName = reactName;
2299        this._targetInst = targetInst;
2300        this.type = reactEventType;
2301        this.nativeEvent = nativeEvent;
2302        this.target = nativeEventTarget;
2303        this.currentTarget = null;
2304        for (var propName in Interface)
2305          Interface.hasOwnProperty(propName) && (reactName = Interface[propName], this[propName] = reactName ? reactName(nativeEvent) : nativeEvent[propName]);
2306        this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : false === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
2307        this.isPropagationStopped = functionThatReturnsFalse;
2308        return this;
2309      }
2310      assign(SyntheticBaseEvent.prototype, {
2311        preventDefault: function() {
2312          this.defaultPrevented = true;
2313          var event = this.nativeEvent;
2314          event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = false), this.isDefaultPrevented = functionThatReturnsTrue);
2315        },
2316        stopPropagation: function() {
2317          var event = this.nativeEvent;
2318          event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = true), this.isPropagationStopped = functionThatReturnsTrue);
2319        },
2320        persist: function() {
2321        },
2322        isPersistent: functionThatReturnsTrue
2323      });
2324      return SyntheticBaseEvent;
2325    }
2326    var EventInterface = {
2327      eventPhase: 0,
2328      bubbles: 0,
2329      cancelable: 0,
2330      timeStamp: function(event) {
2331        return event.timeStamp || Date.now();
2332      },
2333      defaultPrevented: 0,
2334      isTrusted: 0
2335    }, SyntheticEvent = createSyntheticEvent(EventInterface), UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }), SyntheticUIEvent = createSyntheticEvent(UIEventInterface), lastMovementX, lastMovementY, lastMouseEvent, MouseEventInterface = assign({}, UIEventInterface, {
2336      screenX: 0,
2337      screenY: 0,
2338      clientX: 0,
2339      clientY: 0,
2340      pageX: 0,
2341      pageY: 0,
2342      ctrlKey: 0,
2343      shiftKey: 0,
2344      altKey: 0,
2345      metaKey: 0,
2346      getModifierState: getEventModifierState,
2347      button: 0,
2348      buttons: 0,
2349      relatedTarget: function(event) {
2350        return void 0 === event.relatedTarget ? event.fromElement === event.srcElement ? event.toElement : event.fromElement : event.relatedTarget;
2351      },
2352      movementX: function(event) {
2353        if ("movementX" in event) return event.movementX;
2354        event !== lastMouseEvent && (lastMouseEvent && "mousemove" === event.type ? (lastMovementX = event.screenX - lastMouseEvent.screenX, lastMovementY = event.screenY - lastMouseEvent.screenY) : lastMovementY = lastMovementX = 0, lastMouseEvent = event);
2355        return lastMovementX;
2356      },
2357      movementY: function(event) {
2358        return "movementY" in event ? event.movementY : lastMovementY;
2359      }
2360    }), SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface), DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }), SyntheticDragEvent = createSyntheticEvent(DragEventInterface), FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }), SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface), AnimationEventInterface = assign({}, EventInterface, {
2361      animationName: 0,
2362      elapsedTime: 0,
2363      pseudoElement: 0
2364    }), SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface), ClipboardEventInterface = assign({}, EventInterface, {
2365      clipboardData: function(event) {
2366        return "clipboardData" in event ? event.clipboardData : window.clipboardData;
2367      }
2368    }), SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface), CompositionEventInterface = assign({}, EventInterface, { data: 0 }), SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface), normalizeKey = {
2369      Esc: "Escape",
2370      Spacebar: " ",
2371      Left: "ArrowLeft",
2372      Up: "ArrowUp",
2373      Right: "ArrowRight",
2374      Down: "ArrowDown",
2375      Del: "Delete",
2376      Win: "OS",
2377      Menu: "ContextMenu",
2378      Apps: "ContextMenu",
2379      Scroll: "ScrollLock",
2380      MozPrintableKey: "Unidentified"
2381    }, translateToKey = {
2382      8: "Backspace",
2383      9: "Tab",
2384      12: "Clear",
2385      13: "Enter",
2386      16: "Shift",
2387      17: "Control",
2388      18: "Alt",
2389      19: "Pause",
2390      20: "CapsLock",
2391      27: "Escape",
2392      32: " ",
2393      33: "PageUp",
2394      34: "PageDown",
2395      35: "End",
2396      36: "Home",
2397      37: "ArrowLeft",
2398      38: "ArrowUp",
2399      39: "ArrowRight",
2400      40: "ArrowDown",
2401      45: "Insert",
2402      46: "Delete",
2403      112: "F1",
2404      113: "F2",
2405      114: "F3",
2406      115: "F4",
2407      116: "F5",
2408      117: "F6",
2409      118: "F7",
2410      119: "F8",
2411      120: "F9",
2412      121: "F10",
2413      122: "F11",
2414      123: "F12",
2415      144: "NumLock",
2416      145: "ScrollLock",
2417      224: "Meta"
2418    }, modifierKeyToProp = {
2419      Alt: "altKey",
2420      Control: "ctrlKey",
2421      Meta: "metaKey",
2422      Shift: "shiftKey"
2423    };
2424    function modifierStateGetter(keyArg) {
2425      var nativeEvent = this.nativeEvent;
2426      return nativeEvent.getModifierState ? nativeEvent.getModifierState(keyArg) : (keyArg = modifierKeyToProp[keyArg]) ? !!nativeEvent[keyArg] : false;
2427    }
2428    function getEventModifierState() {
2429      return modifierStateGetter;
2430    }
2431    var KeyboardEventInterface = assign({}, UIEventInterface, {
2432      key: function(nativeEvent) {
2433        if (nativeEvent.key) {
2434          var key2 = normalizeKey[nativeEvent.key] || nativeEvent.key;
2435          if ("Unidentified" !== key2) return key2;
2436        }
2437        return "keypress" === nativeEvent.type ? (nativeEvent = getEventCharCode(nativeEvent), 13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent)) : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type ? translateToKey[nativeEvent.keyCode] || "Unidentified" : "";
2438      },
2439      code: 0,
2440      location: 0,
2441      ctrlKey: 0,
2442      shiftKey: 0,
2443      altKey: 0,
2444      metaKey: 0,
2445      repeat: 0,
2446      locale: 0,
2447      getModifierState: getEventModifierState,
2448      charCode: function(event) {
2449        return "keypress" === event.type ? getEventCharCode(event) : 0;
2450      },
2451      keyCode: function(event) {
2452        return "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
2453      },
2454      which: function(event) {
2455        return "keypress" === event.type ? getEventCharCode(event) : "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
2456      }
2457    }), SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface), PointerEventInterface = assign({}, MouseEventInterface, {
2458      pointerId: 0,
2459      width: 0,
2460      height: 0,
2461      pressure: 0,
2462      tangentialPressure: 0,
2463      tiltX: 0,
2464      tiltY: 0,
2465      twist: 0,
2466      pointerType: 0,
2467      isPrimary: 0
2468    }), SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface), TouchEventInterface = assign({}, UIEventInterface, {
2469      touches: 0,
2470      targetTouches: 0,
2471      changedTouches: 0,
2472      altKey: 0,
2473      metaKey: 0,
2474      ctrlKey: 0,
2475      shiftKey: 0,
2476      getModifierState: getEventModifierState
2477    }), SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface), TransitionEventInterface = assign({}, EventInterface, {
2478      propertyName: 0,
2479      elapsedTime: 0,
2480      pseudoElement: 0
2481    }), SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface), WheelEventInterface = assign({}, MouseEventInterface, {
2482      deltaX: function(event) {
2483        return "deltaX" in event ? event.deltaX : "wheelDeltaX" in event ? -event.wheelDeltaX : 0;
2484      },
2485      deltaY: function(event) {
2486        return "deltaY" in event ? event.deltaY : "wheelDeltaY" in event ? -event.wheelDeltaY : "wheelDelta" in event ? -event.wheelDelta : 0;
2487      },
2488      deltaZ: 0,
2489      deltaMode: 0
2490    }), SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface), ToggleEventInterface = assign({}, EventInterface, {
2491      newState: 0,
2492      oldState: 0
2493    }), SyntheticToggleEvent = createSyntheticEvent(ToggleEventInterface), END_KEYCODES = [9, 13, 27, 32], canUseCompositionEvent = canUseDOM && "CompositionEvent" in window, documentMode = null;
2494    canUseDOM && "documentMode" in document && (documentMode = document.documentMode);
2495    var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode, useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && 8 < documentMode && 11 >= documentMode), SPACEBAR_CHAR = String.fromCharCode(32), hasSpaceKeypress = false;
2496    function isFallbackCompositionEnd(domEventName, nativeEvent) {
2497      switch (domEventName) {
2498        case "keyup":
2499          return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
2500        case "keydown":
2501          return 229 !== nativeEvent.keyCode;
2502        case "keypress":
2503        case "mousedown":
2504        case "focusout":
2505          return true;
2506        default:
2507          return false;
2508      }
2509    }
2510    function getDataFromCustomEvent(nativeEvent) {
2511      nativeEvent = nativeEvent.detail;
2512      return "object" === typeof nativeEvent && "data" in nativeEvent ? nativeEvent.data : null;
2513    }
2514    var isComposing = false;
2515    function getNativeBeforeInputChars(domEventName, nativeEvent) {
2516      switch (domEventName) {
2517        case "compositionend":
2518          return getDataFromCustomEvent(nativeEvent);
2519        case "keypress":
2520          if (32 !== nativeEvent.which) return null;
2521          hasSpaceKeypress = true;
2522          return SPACEBAR_CHAR;
2523        case "textInput":
2524          return domEventName = nativeEvent.data, domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName;
2525        default:
2526          return null;
2527      }
2528    }
2529    function getFallbackBeforeInputChars(domEventName, nativeEvent) {
2530      if (isComposing)
2531        return "compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent) ? (domEventName = getData(), fallbackText = startText = root = null, isComposing = false, domEventName) : null;
2532      switch (domEventName) {
2533        case "paste":
2534          return null;
2535        case "keypress":
2536          if (!(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) || nativeEvent.ctrlKey && nativeEvent.altKey) {
2537            if (nativeEvent.char && 1 < nativeEvent.char.length)
2538              return nativeEvent.char;
2539            if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
2540          }
2541          return null;
2542        case "compositionend":
2543          return useFallbackCompositionData && "ko" !== nativeEvent.locale ? null : nativeEvent.data;
2544        default:
2545          return null;
2546      }
2547    }
2548    var supportedInputTypes = {
2549      color: true,
2550      date: true,
2551      datetime: true,
2552      "datetime-local": true,
2553      email: true,
2554      month: true,
2555      number: true,
2556      password: true,
2557      range: true,
2558      search: true,
2559      tel: true,
2560      text: true,
2561      time: true,
2562      url: true,
2563      week: true
2564    };
2565    function isTextInputElement(elem) {
2566      var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2567      return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName ? true : false;
2568    }
2569    function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
2570      restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [target] : restoreTarget = target;
2571      inst = accumulateTwoPhaseListeners(inst, "onChange");
2572      0 < inst.length && (nativeEvent = new SyntheticEvent(
2573        "onChange",
2574        "change",
2575        null,
2576        nativeEvent,
2577        target
2578      ), dispatchQueue.push({ event: nativeEvent, listeners: inst }));
2579    }
2580    var activeElement$1 = null, activeElementInst$1 = null;
2581    function runEventInBatch(dispatchQueue) {
2582      processDispatchQueue(dispatchQueue, 0);
2583    }
2584    function getInstIfValueChanged(targetInst) {
2585      var targetNode = getNodeFromInstance(targetInst);
2586      if (updateValueIfChanged(targetNode)) return targetInst;
2587    }
2588    function getTargetInstForChangeEvent(domEventName, targetInst) {
2589      if ("change" === domEventName) return targetInst;
2590    }
2591    var isInputEventSupported = false;
2592    if (canUseDOM) {
2593      var JSCompiler_inline_result$jscomp$286;
2594      if (canUseDOM) {
2595        var isSupported$jscomp$inline_427 = "oninput" in document;
2596        if (!isSupported$jscomp$inline_427) {
2597          var element$jscomp$inline_428 = document.createElement("div");
2598          element$jscomp$inline_428.setAttribute("oninput", "return;");
2599          isSupported$jscomp$inline_427 = "function" === typeof element$jscomp$inline_428.oninput;
2600        }
2601        JSCompiler_inline_result$jscomp$286 = isSupported$jscomp$inline_427;
2602      } else JSCompiler_inline_result$jscomp$286 = false;
2603      isInputEventSupported = JSCompiler_inline_result$jscomp$286 && (!document.documentMode || 9 < document.documentMode);
2604    }
2605    function stopWatchingForValueChange() {
2606      activeElement$1 && (activeElement$1.detachEvent("onpropertychange", handlePropertyChange), activeElementInst$1 = activeElement$1 = null);
2607    }
2608    function handlePropertyChange(nativeEvent) {
2609      if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst$1)) {
2610        var dispatchQueue = [];
2611        createAndAccumulateChangeEvent(
2612          dispatchQueue,
2613          activeElementInst$1,
2614          nativeEvent,
2615          getEventTarget(nativeEvent)
2616        );
2617        batchedUpdates$1(runEventInBatch, dispatchQueue);
2618      }
2619    }
2620    function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
2621      "focusin" === domEventName ? (stopWatchingForValueChange(), activeElement$1 = target, activeElementInst$1 = targetInst, activeElement$1.attachEvent("onpropertychange", handlePropertyChange)) : "focusout" === domEventName && stopWatchingForValueChange();
2622    }
2623    function getTargetInstForInputEventPolyfill(domEventName) {
2624      if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName)
2625        return getInstIfValueChanged(activeElementInst$1);
2626    }
2627    function getTargetInstForClickEvent(domEventName, targetInst) {
2628      if ("click" === domEventName) return getInstIfValueChanged(targetInst);
2629    }
2630    function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
2631      if ("input" === domEventName || "change" === domEventName)
2632        return getInstIfValueChanged(targetInst);
2633    }
2634    function is(x, y) {
2635      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
2636    }
2637    var objectIs2 = "function" === typeof Object.is ? Object.is : is;
2638    function shallowEqual(objA, objB) {
2639      if (objectIs2(objA, objB)) return true;
2640      if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB)
2641        return false;
2642      var keysA = Object.keys(objA), keysB = Object.keys(objB);
2643      if (keysA.length !== keysB.length) return false;
2644      for (keysB = 0; keysB < keysA.length; keysB++) {
2645        var currentKey = keysA[keysB];
2646        if (!hasOwnProperty2.call(objB, currentKey) || !objectIs2(objA[currentKey], objB[currentKey]))
2647          return false;
2648      }
2649      return true;
2650    }
2651    function getLeafNode(node2) {
2652      for (; node2 && node2.firstChild; ) node2 = node2.firstChild;
2653      return node2;
2654    }
2655    function getNodeForCharacterOffset(root2, offset) {
2656      var node2 = getLeafNode(root2);
2657      root2 = 0;
2658      for (var nodeEnd; node2; ) {
2659        if (3 === node2.nodeType) {
2660          nodeEnd = root2 + node2.textContent.length;
2661          if (root2 <= offset && nodeEnd >= offset)
2662            return { node: node2, offset: offset - root2 };
2663          root2 = nodeEnd;
2664        }
2665        a: {
2666          for (; node2; ) {
2667            if (node2.nextSibling) {
2668              node2 = node2.nextSibling;
2669              break a;
2670            }
2671            node2 = node2.parentNode;
2672          }
2673          node2 = void 0;
2674        }
2675        node2 = getLeafNode(node2);
2676      }
2677    }
2678    function containsNode(outerNode, innerNode) {
2679      return outerNode && innerNode ? outerNode === innerNode ? true : outerNode && 3 === outerNode.nodeType ? false : innerNode && 3 === innerNode.nodeType ? containsNode(outerNode, innerNode.parentNode) : "contains" in outerNode ? outerNode.contains(innerNode) : outerNode.compareDocumentPosition ? !!(outerNode.compareDocumentPosition(innerNode) & 16) : false : false;
2680    }
2681    function getActiveElementDeep(containerInfo) {
2682      containerInfo = null != containerInfo && null != containerInfo.ownerDocument && null != containerInfo.ownerDocument.defaultView ? containerInfo.ownerDocument.defaultView : window;
2683      for (var element = getActiveElement(containerInfo.document); element instanceof containerInfo.HTMLIFrameElement; ) {
2684        try {
2685          var JSCompiler_inline_result = "string" === typeof element.contentWindow.location.href;
2686        } catch (err) {
2687          JSCompiler_inline_result = false;
2688        }
2689        if (JSCompiler_inline_result) containerInfo = element.contentWindow;
2690        else break;
2691        element = getActiveElement(containerInfo.document);
2692      }
2693      return element;
2694    }
2695    function hasSelectionCapabilities(elem) {
2696      var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2697      return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
2698    }
2699    var skipSelectionChangeEvent = canUseDOM && "documentMode" in document && 11 >= document.documentMode, activeElement = null, activeElementInst = null, lastSelection = null, mouseDown = false;
2700    function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
2701      var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
2702      mouseDown || null == activeElement || activeElement !== getActiveElement(doc) || (doc = activeElement, "selectionStart" in doc && hasSelectionCapabilities(doc) ? doc = { start: doc.selectionStart, end: doc.selectionEnd } : (doc = (doc.ownerDocument && doc.ownerDocument.defaultView || window).getSelection(), doc = {
2703        anchorNode: doc.anchorNode,
2704        anchorOffset: doc.anchorOffset,
2705        focusNode: doc.focusNode,
2706        focusOffset: doc.focusOffset
2707      }), lastSelection && shallowEqual(lastSelection, doc) || (lastSelection = doc, doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect"), 0 < doc.length && (nativeEvent = new SyntheticEvent(
2708        "onSelect",
2709        "select",
2710        null,
2711        nativeEvent,
2712        nativeEventTarget
2713      ), dispatchQueue.push({ event: nativeEvent, listeners: doc }), nativeEvent.target = activeElement)));
2714    }
2715    function makePrefixMap(styleProp, eventName) {
2716      var prefixes = {};
2717      prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
2718      prefixes["Webkit" + styleProp] = "webkit" + eventName;
2719      prefixes["Moz" + styleProp] = "moz" + eventName;
2720      return prefixes;
2721    }
2722    var vendorPrefixes = {
2723      animationend: makePrefixMap("Animation", "AnimationEnd"),
2724      animationiteration: makePrefixMap("Animation", "AnimationIteration"),
2725      animationstart: makePrefixMap("Animation", "AnimationStart"),
2726      transitionrun: makePrefixMap("Transition", "TransitionRun"),
2727      transitionstart: makePrefixMap("Transition", "TransitionStart"),
2728      transitioncancel: makePrefixMap("Transition", "TransitionCancel"),
2729      transitionend: makePrefixMap("Transition", "TransitionEnd")
2730    }, prefixedEventNames = {}, style = {};
2731    canUseDOM && (style = document.createElement("div").style, "AnimationEvent" in window || (delete vendorPrefixes.animationend.animation, delete vendorPrefixes.animationiteration.animation, delete vendorPrefixes.animationstart.animation), "TransitionEvent" in window || delete vendorPrefixes.transitionend.transition);
2732    function getVendorPrefixedEventName(eventName) {
2733      if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
2734      if (!vendorPrefixes[eventName]) return eventName;

vendor: 16,217 bytes, lines 2735-3033

2735      var prefixMap = vendorPrefixes[eventName], styleProp;
2736      for (styleProp in prefixMap)
2737        if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
2738          return prefixedEventNames[eventName] = prefixMap[styleProp];
2739      return eventName;
2740    }
2741    var ANIMATION_END = getVendorPrefixedEventName("animationend"), ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"), ANIMATION_START = getVendorPrefixedEventName("animationstart"), TRANSITION_RUN = getVendorPrefixedEventName("transitionrun"), TRANSITION_START = getVendorPrefixedEventName("transitionstart"), TRANSITION_CANCEL = getVendorPrefixedEventName("transitioncancel"), TRANSITION_END = getVendorPrefixedEventName("transitionend"), topLevelEventsToReactNames = /* @__PURE__ */ new Map(), simpleEventPluginEvents = "abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
2742      " "
2743    );
2744    simpleEventPluginEvents.push("scrollEnd");
2745    function registerSimpleEvent(domEventName, reactName) {
2746      topLevelEventsToReactNames.set(domEventName, reactName);
2747      registerTwoPhaseEvent(reactName, [domEventName]);
2748    }
2749    var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
2750      if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
2751        var event = new window.ErrorEvent("error", {
2752          bubbles: true,
2753          cancelable: true,
2754          message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
2755          error
2756        });
2757        if (!window.dispatchEvent(event)) return;
2758      } else if ("object" === typeof process$1 && "function" === typeof process$1.emit) {
2759        process$1.emit("uncaughtException", error);
2760        return;
2761      }
2762      console.error(error);
2763    }, concurrentQueues = [], concurrentQueuesIndex = 0, concurrentlyUpdatedLanes = 0;
2764    function finishQueueingConcurrentUpdates() {
2765      for (var endIndex = concurrentQueuesIndex, i2 = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i2 < endIndex; ) {
2766        var fiber = concurrentQueues[i2];
2767        concurrentQueues[i2++] = null;
2768        var queue2 = concurrentQueues[i2];
2769        concurrentQueues[i2++] = null;
2770        var update = concurrentQueues[i2];
2771        concurrentQueues[i2++] = null;
2772        var lane = concurrentQueues[i2];
2773        concurrentQueues[i2++] = null;
2774        if (null !== queue2 && null !== update) {
2775          var pending = queue2.pending;
2776          null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
2777          queue2.pending = update;
2778        }
2779        0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
2780      }
2781    }
2782    function enqueueUpdate$1(fiber, queue2, update, lane) {
2783      concurrentQueues[concurrentQueuesIndex++] = fiber;
2784      concurrentQueues[concurrentQueuesIndex++] = queue2;
2785      concurrentQueues[concurrentQueuesIndex++] = update;
2786      concurrentQueues[concurrentQueuesIndex++] = lane;
2787      concurrentlyUpdatedLanes |= lane;
2788      fiber.lanes |= lane;
2789      fiber = fiber.alternate;
2790      null !== fiber && (fiber.lanes |= lane);
2791    }
2792    function enqueueConcurrentHookUpdate(fiber, queue2, update, lane) {
2793      enqueueUpdate$1(fiber, queue2, update, lane);
2794      return getRootForUpdatedFiber(fiber);
2795    }
2796    function enqueueConcurrentRenderForLane(fiber, lane) {
2797      enqueueUpdate$1(fiber, null, null, lane);
2798      return getRootForUpdatedFiber(fiber);
2799    }
2800    function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
2801      sourceFiber.lanes |= lane;
2802      var alternate = sourceFiber.alternate;
2803      null !== alternate && (alternate.lanes |= lane);
2804      for (var isHidden = false, parent = sourceFiber.return; null !== parent; )
2805        parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = true)), sourceFiber = parent, parent = parent.return;
2806      return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
2807    }
2808    function getRootForUpdatedFiber(sourceFiber) {
2809      if (50 < nestedUpdateCount)
2810        throw nestedUpdateCount = 0, rootWithNestedUpdates = null, Error(formatProdErrorMessage(185));
2811      for (var parent = sourceFiber.return; null !== parent; )
2812        sourceFiber = parent, parent = sourceFiber.return;
2813      return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
2814    }
2815    var emptyContextObject = {};
2816    function FiberNode(tag, pendingProps, key2, mode) {
2817      this.tag = tag;
2818      this.key = key2;
2819      this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
2820      this.index = 0;
2821      this.refCleanup = this.ref = null;
2822      this.pendingProps = pendingProps;
2823      this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
2824      this.mode = mode;
2825      this.subtreeFlags = this.flags = 0;
2826      this.deletions = null;
2827      this.childLanes = this.lanes = 0;
2828      this.alternate = null;
2829    }
2830    function createFiberImplClass(tag, pendingProps, key2, mode) {
2831      return new FiberNode(tag, pendingProps, key2, mode);
2832    }
2833    function shouldConstruct(Component) {
2834      Component = Component.prototype;
2835      return !(!Component || !Component.isReactComponent);
2836    }
2837    function createWorkInProgress(current, pendingProps) {
2838      var workInProgress2 = current.alternate;
2839      null === workInProgress2 ? (workInProgress2 = createFiberImplClass(
2840        current.tag,
2841        pendingProps,
2842        current.key,
2843        current.mode
2844      ), workInProgress2.elementType = current.elementType, workInProgress2.type = current.type, workInProgress2.stateNode = current.stateNode, workInProgress2.alternate = current, current.alternate = workInProgress2) : (workInProgress2.pendingProps = pendingProps, workInProgress2.type = current.type, workInProgress2.flags = 0, workInProgress2.subtreeFlags = 0, workInProgress2.deletions = null);
2845      workInProgress2.flags = current.flags & 65011712;
2846      workInProgress2.childLanes = current.childLanes;
2847      workInProgress2.lanes = current.lanes;
2848      workInProgress2.child = current.child;
2849      workInProgress2.memoizedProps = current.memoizedProps;
2850      workInProgress2.memoizedState = current.memoizedState;
2851      workInProgress2.updateQueue = current.updateQueue;
2852      pendingProps = current.dependencies;
2853      workInProgress2.dependencies = null === pendingProps ? null : { lanes: pendingProps.lanes, firstContext: pendingProps.firstContext };
2854      workInProgress2.sibling = current.sibling;
2855      workInProgress2.index = current.index;
2856      workInProgress2.ref = current.ref;
2857      workInProgress2.refCleanup = current.refCleanup;
2858      return workInProgress2;
2859    }
2860    function resetWorkInProgress(workInProgress2, renderLanes2) {
2861      workInProgress2.flags &= 65011714;
2862      var current = workInProgress2.alternate;
2863      null === current ? (workInProgress2.childLanes = 0, workInProgress2.lanes = renderLanes2, workInProgress2.child = null, workInProgress2.subtreeFlags = 0, workInProgress2.memoizedProps = null, workInProgress2.memoizedState = null, workInProgress2.updateQueue = null, workInProgress2.dependencies = null, workInProgress2.stateNode = null) : (workInProgress2.childLanes = current.childLanes, workInProgress2.lanes = current.lanes, workInProgress2.child = current.child, workInProgress2.subtreeFlags = 0, workInProgress2.deletions = null, workInProgress2.memoizedProps = current.memoizedProps, workInProgress2.memoizedState = current.memoizedState, workInProgress2.updateQueue = current.updateQueue, workInProgress2.type = current.type, renderLanes2 = current.dependencies, workInProgress2.dependencies = null === renderLanes2 ? null : {
2864        lanes: renderLanes2.lanes,
2865        firstContext: renderLanes2.firstContext
2866      });
2867      return workInProgress2;
2868    }
2869    function createFiberFromTypeAndProps(type2, key2, pendingProps, owner, mode, lanes) {
2870      var fiberTag = 0;
2871      owner = type2;
2872      if ("function" === typeof type2) shouldConstruct(type2) && (fiberTag = 1);
2873      else if ("string" === typeof type2)
2874        fiberTag = isHostHoistableType(
2875          type2,
2876          pendingProps,
2877          contextStackCursor.current
2878        ) ? 26 : "html" === type2 || "head" === type2 || "body" === type2 ? 27 : 5;
2879      else
2880        a: switch (type2) {
2881          case REACT_ACTIVITY_TYPE:
2882            return type2 = createFiberImplClass(31, pendingProps, key2, mode), type2.elementType = REACT_ACTIVITY_TYPE, type2.lanes = lanes, type2;
2883          case REACT_FRAGMENT_TYPE:
2884            return createFiberFromFragment(pendingProps.children, mode, lanes, key2);
2885          case REACT_STRICT_MODE_TYPE:
2886            fiberTag = 8;
2887            mode |= 24;
2888            break;
2889          case REACT_PROFILER_TYPE:
2890            return type2 = createFiberImplClass(12, pendingProps, key2, mode | 2), type2.elementType = REACT_PROFILER_TYPE, type2.lanes = lanes, type2;
2891          case REACT_SUSPENSE_TYPE:
2892            return type2 = createFiberImplClass(13, pendingProps, key2, mode), type2.elementType = REACT_SUSPENSE_TYPE, type2.lanes = lanes, type2;
2893          case REACT_SUSPENSE_LIST_TYPE:
2894            return type2 = createFiberImplClass(19, pendingProps, key2, mode), type2.elementType = REACT_SUSPENSE_LIST_TYPE, type2.lanes = lanes, type2;
2895          default:
2896            if ("object" === typeof type2 && null !== type2)
2897              switch (type2.$$typeof) {
2898                case REACT_CONTEXT_TYPE:
2899                  fiberTag = 10;
2900                  break a;
2901                case REACT_CONSUMER_TYPE:
2902                  fiberTag = 9;
2903                  break a;
2904                case REACT_FORWARD_REF_TYPE:
2905                  fiberTag = 11;
2906                  break a;
2907                case REACT_MEMO_TYPE:
2908                  fiberTag = 14;
2909                  break a;
2910                case REACT_LAZY_TYPE:
2911                  fiberTag = 16;
2912                  owner = null;
2913                  break a;
2914              }
2915            fiberTag = 29;
2916            pendingProps = Error(
2917              formatProdErrorMessage(130, null === type2 ? "null" : typeof type2, "")
2918            );
2919            owner = null;
2920        }
2921      key2 = createFiberImplClass(fiberTag, pendingProps, key2, mode);
2922      key2.elementType = type2;
2923      key2.type = owner;
2924      key2.lanes = lanes;
2925      return key2;
2926    }
2927    function createFiberFromFragment(elements, mode, lanes, key2) {
2928      elements = createFiberImplClass(7, elements, key2, mode);
2929      elements.lanes = lanes;
2930      return elements;
2931    }
2932    function createFiberFromText(content, mode, lanes) {
2933      content = createFiberImplClass(6, content, null, mode);
2934      content.lanes = lanes;
2935      return content;
2936    }
2937    function createFiberFromDehydratedFragment(dehydratedNode) {
2938      var fiber = createFiberImplClass(18, null, null, 0);
2939      fiber.stateNode = dehydratedNode;
2940      return fiber;
2941    }
2942    function createFiberFromPortal(portal, mode, lanes) {
2943      mode = createFiberImplClass(
2944        4,
2945        null !== portal.children ? portal.children : [],
2946        portal.key,
2947        mode
2948      );
2949      mode.lanes = lanes;
2950      mode.stateNode = {
2951        containerInfo: portal.containerInfo,
2952        pendingChildren: null,
2953        implementation: portal.implementation
2954      };
2955      return mode;
2956    }
2957    var CapturedStacks = /* @__PURE__ */ new WeakMap();
2958    function createCapturedValueAtFiber(value, source) {
2959      if ("object" === typeof value && null !== value) {
2960        var existing = CapturedStacks.get(value);
2961        if (void 0 !== existing) return existing;
2962        source = {
2963          value,
2964          source,
2965          stack: getStackByFiberInDevAndProd(source)
2966        };
2967        CapturedStacks.set(value, source);
2968        return source;
2969      }
2970      return {
2971        value,
2972        source,
2973        stack: getStackByFiberInDevAndProd(source)
2974      };
2975    }
2976    var forkStack = [], forkStackIndex = 0, treeForkProvider = null, treeForkCount = 0, idStack = [], idStackIndex = 0, treeContextProvider = null, treeContextId = 1, treeContextOverflow = "";
2977    function pushTreeFork(workInProgress2, totalChildren) {
2978      forkStack[forkStackIndex++] = treeForkCount;
2979      forkStack[forkStackIndex++] = treeForkProvider;
2980      treeForkProvider = workInProgress2;
2981      treeForkCount = totalChildren;
2982    }
2983    function pushTreeId(workInProgress2, totalChildren, index2) {
2984      idStack[idStackIndex++] = treeContextId;
2985      idStack[idStackIndex++] = treeContextOverflow;
2986      idStack[idStackIndex++] = treeContextProvider;
2987      treeContextProvider = workInProgress2;
2988      var baseIdWithLeadingBit = treeContextId;
2989      workInProgress2 = treeContextOverflow;
2990      var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
2991      baseIdWithLeadingBit &= ~(1 << baseLength);
2992      index2 += 1;
2993      var length = 32 - clz32(totalChildren) + baseLength;
2994      if (30 < length) {
2995        var numberOfOverflowBits = baseLength - baseLength % 5;
2996        length = (baseIdWithLeadingBit & (1 << numberOfOverflowBits) - 1).toString(32);
2997        baseIdWithLeadingBit >>= numberOfOverflowBits;
2998        baseLength -= numberOfOverflowBits;
2999        treeContextId = 1 << 32 - clz32(totalChildren) + baseLength | index2 << baseLength | baseIdWithLeadingBit;
3000        treeContextOverflow = length + workInProgress2;
3001      } else
3002        treeContextId = 1 << length | index2 << baseLength | baseIdWithLeadingBit, treeContextOverflow = workInProgress2;
3003    }
3004    function pushMaterializedTreeId(workInProgress2) {
3005      null !== workInProgress2.return && (pushTreeFork(workInProgress2, 1), pushTreeId(workInProgress2, 1, 0));
3006    }
3007    function popTreeContext(workInProgress2) {
3008      for (; workInProgress2 === treeForkProvider; )
3009        treeForkProvider = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null, treeForkCount = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null;
3010      for (; workInProgress2 === treeContextProvider; )
3011        treeContextProvider = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextOverflow = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextId = idStack[--idStackIndex], idStack[idStackIndex] = null;
3012    }
3013    function restoreSuspendedTreeContext(workInProgress2, suspendedContext) {
3014      idStack[idStackIndex++] = treeContextId;
3015      idStack[idStackIndex++] = treeContextOverflow;
3016      idStack[idStackIndex++] = treeContextProvider;
3017      treeContextId = suspendedContext.id;
3018      treeContextOverflow = suspendedContext.overflow;
3019      treeContextProvider = workInProgress2;
3020    }
3021    var hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = false, hydrationErrors = null, rootOrSingletonContext = false, HydrationMismatchException = Error(formatProdErrorMessage(519));
3022    function throwOnHydrationMismatch(fiber) {
3023      var error = Error(
3024        formatProdErrorMessage(
3025          418,
3026          1 < arguments.length && void 0 !== arguments[1] && arguments[1] ? "text" : "HTML",
3027          ""
3028        )
3029      );
3030      queueHydrationError(createCapturedValueAtFiber(error, fiber));
3031      throw HydrationMismatchException;
3032    }
3033    function prepareToHydrateHostInstance(fiber) {

3034      var instance = fiber.stateNode, type2 = fiber.type, props = fiber.memoizedProps;
3035      instance[internalInstanceKey] = fiber;
3036      instance[internalPropsKey] = props;
3037      switch (type2) {
3038        case "dialog":
3039          listenToNonDelegatedEvent("cancel", instance);
3040          listenToNonDelegatedEvent("close", instance);
3041          break;
3042        case "iframe":
3043        case "object":
3044        case "embed":
3045          listenToNonDelegatedEvent("load", instance);
3046          break;
3047        case "video":
3048        case "audio":
3049          for (type2 = 0; type2 < mediaEventTypes.length; type2++)
3050            listenToNonDelegatedEvent(mediaEventTypes[type2], instance);
3051          break;
3052        case "source":
3053          listenToNonDelegatedEvent("error", instance);
3054          break;
3055        case "img":
3056        case "image":
3057        case "link":
3058          listenToNonDelegatedEvent("error", instance);
3059          listenToNonDelegatedEvent("load", instance);
3060          break;
3061        case "details":
3062          listenToNonDelegatedEvent("toggle", instance);
3063          break;
3064        case "input":
3065          listenToNonDelegatedEvent("invalid", instance);
3066          initInput(
3067            instance,
3068            props.value,
3069            props.defaultValue,
3070            props.checked,
3071            props.defaultChecked,
3072            props.type,
3073            props.name,
3074            true
3075          );
3076          break;
3077        case "select":
3078          listenToNonDelegatedEvent("invalid", instance);
3079          break;
3080        case "textarea":
3081          listenToNonDelegatedEvent("invalid", instance), initTextarea(instance, props.value, props.defaultValue, props.children);
3082      }
3083      type2 = props.children;
3084      "string" !== typeof type2 && "number" !== typeof type2 && "bigint" !== typeof type2 || instance.textContent === "" + type2 || true === props.suppressHydrationWarning || checkForUnmatchedText(instance.textContent, type2) ? (null != props.popover && (listenToNonDelegatedEvent("beforetoggle", instance), listenToNonDelegatedEvent("toggle", instance)), null != props.onScroll && listenToNonDelegatedEvent("scroll", instance), null != props.onScrollEnd && listenToNonDelegatedEvent("scrollend", instance), null != props.onClick && (instance.onclick = noop$12), instance = true) : instance = false;
3085      instance || throwOnHydrationMismatch(fiber, true);
3086    }
3087    function popToNextHostParent(fiber) {
3088      for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
3089        switch (hydrationParentFiber.tag) {
3090          case 5:
3091          case 31:
3092          case 13:
3093            rootOrSingletonContext = false;
3094            return;
3095          case 27:
3096          case 3:
3097            rootOrSingletonContext = true;
3098            return;
3099          default:
3100            hydrationParentFiber = hydrationParentFiber.return;
3101        }
3102    }
3103    function popHydrationState(fiber) {
3104      if (fiber !== hydrationParentFiber) return false;
3105      if (!isHydrating) return popToNextHostParent(fiber), isHydrating = true, false;
3106      var tag = fiber.tag, JSCompiler_temp;
3107      if (JSCompiler_temp = 3 !== tag && 27 !== tag) {
3108        if (JSCompiler_temp = 5 === tag)
3109          JSCompiler_temp = fiber.type, JSCompiler_temp = !("form" !== JSCompiler_temp && "button" !== JSCompiler_temp) || shouldSetTextContent(fiber.type, fiber.memoizedProps);
3110        JSCompiler_temp = !JSCompiler_temp;
3111      }
3112      JSCompiler_temp && nextHydratableInstance && throwOnHydrationMismatch(fiber);
3113      popToNextHostParent(fiber);
3114      if (13 === tag) {
3115        fiber = fiber.memoizedState;
3116        fiber = null !== fiber ? fiber.dehydrated : null;
3117        if (!fiber) throw Error(formatProdErrorMessage(317));
3118        nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
3119      } else if (31 === tag) {
3120        fiber = fiber.memoizedState;
3121        fiber = null !== fiber ? fiber.dehydrated : null;
3122        if (!fiber) throw Error(formatProdErrorMessage(317));
3123        nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
3124      } else
3125        27 === tag ? (tag = nextHydratableInstance, isSingletonScope(fiber.type) ? (fiber = previousHydratableOnEnteringScopedSingleton, previousHydratableOnEnteringScopedSingleton = null, nextHydratableInstance = f

vendor: 1,762 bytes, lines 3125-3159

3125iber) : nextHydratableInstance = tag) : nextHydratableInstance = hydrationParentFiber ? getNextHydratable(fiber.stateNode.nextSibling) : null;
3126      return true;
3127    }
3128    function resetHydrationState() {
3129      nextHydratableInstance = hydrationParentFiber = null;
3130      isHydrating = false;
3131    }
3132    function upgradeHydrationErrorsToRecoverable() {
3133      var queuedErrors = hydrationErrors;
3134      null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(
3135        workInProgressRootRecoverableErrors,
3136        queuedErrors
3137      ), hydrationErrors = null);
3138      return queuedErrors;
3139    }
3140    function queueHydrationError(error) {
3141      null === hydrationErrors ? hydrationErrors = [error] : hydrationErrors.push(error);
3142    }
3143    var valueCursor = createCursor(null), currentlyRenderingFiber$1 = null, lastContextDependency = null;
3144    function pushProvider(providerFiber, context, nextValue) {
3145      push(valueCursor, context._currentValue);
3146      context._currentValue = nextValue;
3147    }
3148    function popProvider(context) {
3149      context._currentValue = valueCursor.current;
3150      pop(valueCursor);
3151    }
3152    function scheduleContextWorkOnParentPath(parent, renderLanes2, propagationRoot) {
3153      for (; null !== parent; ) {
3154        var alternate = parent.alternate;
3155        (parent.childLanes & renderLanes2) !== renderLanes2 ? (parent.childLanes |= renderLanes2, null !== alternate && (alternate.childLanes |= renderLanes2)) : null !== alternate && (alternate.childLanes & renderLanes2) !== renderLanes2 && (alternate.childLanes |= renderLanes2);
3156        if (parent === propagationRoot) break;
3157        parent = parent.return;
3158      }
3159    }

vendor: 5,417 bytes, lines 3160-3286

3160    function propagateContextChanges(workInProgress2, contexts, renderLanes2, forcePropagateEntireTree) {
3161      var fiber = workInProgress2.child;
3162      null !== fiber && (fiber.return = workInProgress2);
3163      for (; null !== fiber; ) {
3164        var list = fiber.dependencies;
3165        if (null !== list) {
3166          var nextFiber = fiber.child;
3167          list = list.firstContext;
3168          a: for (; null !== list; ) {
3169            var dependency = list;
3170            list = fiber;
3171            for (var i2 = 0; i2 < contexts.length; i2++)
3172              if (dependency.context === contexts[i2]) {
3173                list.lanes |= renderLanes2;
3174                dependency = list.alternate;
3175                null !== dependency && (dependency.lanes |= renderLanes2);
3176                scheduleContextWorkOnParentPath(
3177                  list.return,
3178                  renderLanes2,
3179                  workInProgress2
3180                );
3181                forcePropagateEntireTree || (nextFiber = null);
3182                break a;
3183              }
3184            list = dependency.next;
3185          }
3186        } else if (18 === fiber.tag) {
3187          nextFiber = fiber.return;
3188          if (null === nextFiber) throw Error(formatProdErrorMessage(341));
3189          nextFiber.lanes |= renderLanes2;
3190          list = nextFiber.alternate;
3191          null !== list && (list.lanes |= renderLanes2);
3192          scheduleContextWorkOnParentPath(nextFiber, renderLanes2, workInProgress2);
3193          nextFiber = null;
3194        } else nextFiber = fiber.child;
3195        if (null !== nextFiber) nextFiber.return = fiber;
3196        else
3197          for (nextFiber = fiber; null !== nextFiber; ) {
3198            if (nextFiber === workInProgress2) {
3199              nextFiber = null;
3200              break;
3201            }
3202            fiber = nextFiber.sibling;
3203            if (null !== fiber) {
3204              fiber.return = nextFiber.return;
3205              nextFiber = fiber;
3206              break;
3207            }
3208            nextFiber = nextFiber.return;
3209          }
3210        fiber = nextFiber;
3211      }
3212    }
3213    function propagateParentContextChanges(current, workInProgress2, renderLanes2, forcePropagateEntireTree) {
3214      current = null;
3215      for (var parent = workInProgress2, isInsidePropagationBailout = false; null !== parent; ) {
3216        if (!isInsidePropagationBailout) {
3217          if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = true;
3218          else if (0 !== (parent.flags & 262144)) break;
3219        }
3220        if (10 === parent.tag) {
3221          var currentParent = parent.alternate;
3222          if (null === currentParent) throw Error(formatProdErrorMessage(387));
3223          currentParent = currentParent.memoizedProps;
3224          if (null !== currentParent) {
3225            var context = parent.type;
3226            objectIs2(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
3227          }
3228        } else if (parent === hostTransitionProviderCursor.current) {
3229          currentParent = parent.alternate;
3230          if (null === currentParent) throw Error(formatProdErrorMessage(387));
3231          currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
3232        }
3233        parent = parent.return;
3234      }
3235      null !== current && propagateContextChanges(
3236        workInProgress2,
3237        current,
3238        renderLanes2,
3239        forcePropagateEntireTree
3240      );
3241      workInProgress2.flags |= 262144;
3242    }
3243    function checkIfContextChanged(currentDependencies) {
3244      for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies; ) {
3245        if (!objectIs2(
3246          currentDependencies.context._currentValue,
3247          currentDependencies.memoizedValue
3248        ))
3249          return true;
3250        currentDependencies = currentDependencies.next;
3251      }
3252      return false;
3253    }
3254    function prepareToReadContext(workInProgress2) {
3255      currentlyRenderingFiber$1 = workInProgress2;
3256      lastContextDependency = null;
3257      workInProgress2 = workInProgress2.dependencies;
3258      null !== workInProgress2 && (workInProgress2.firstContext = null);
3259    }
3260    function readContext(context) {
3261      return readContextForConsumer(currentlyRenderingFiber$1, context);
3262    }
3263    function readContextDuringReconciliation(consumer, context) {
3264      null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
3265      return readContextForConsumer(consumer, context);
3266    }
3267    function readContextForConsumer(consumer, context) {
3268      var value = context._currentValue;
3269      context = { context, memoizedValue: value, next: null };
3270      if (null === lastContextDependency) {
3271        if (null === consumer) throw Error(formatProdErrorMessage(308));
3272        lastContextDependency = context;
3273        consumer.dependencies = { lanes: 0, firstContext: context };
3274        consumer.flags |= 524288;
3275      } else lastContextDependency = lastContextDependency.next = context;
3276      return value;
3277    }
3278    var AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function() {
3279      var listeners = [], signal = this.signal = {
3280        aborted: false,
3281        addEventListener: function(type2, listener) {
3282          listeners.push(listener);
3283        }
3284      };
3285      this.abort = function() {
3286        signal.aborted = true;

vendor: 37,071 bytes, lines 3287-4064

3287        listeners.forEach(function(listener) {
3288          return listener();
3289        });
3290      };
3291    }, scheduleCallback$2 = Scheduler.unstable_scheduleCallback, NormalPriority = Scheduler.unstable_NormalPriority, CacheContext = {
3292      $$typeof: REACT_CONTEXT_TYPE,
3293      Consumer: null,
3294      Provider: null,
3295      _currentValue: null,
3296      _currentValue2: null,
3297      _threadCount: 0
3298    };
3299    function createCache() {
3300      return {
3301        controller: new AbortControllerLocal(),
3302        data: /* @__PURE__ */ new Map(),
3303        refCount: 0
3304      };
3305    }
3306    function releaseCache(cache2) {
3307      cache2.refCount--;
3308      0 === cache2.refCount && scheduleCallback$2(NormalPriority, function() {
3309        cache2.controller.abort();
3310      });
3311    }
3312    var currentEntangledListeners = null, currentEntangledPendingCount = 0, currentEntangledLane = 0, currentEntangledActionThenable = null;
3313    function entangleAsyncAction(transition, thenable) {
3314      if (null === currentEntangledListeners) {
3315        var entangledListeners = currentEntangledListeners = [];
3316        currentEntangledPendingCount = 0;
3317        currentEntangledLane = requestTransitionLane();
3318        currentEntangledActionThenable = {
3319          status: "pending",
3320          value: void 0,
3321          then: function(resolve) {
3322            entangledListeners.push(resolve);
3323          }
3324        };
3325      }
3326      currentEntangledPendingCount++;
3327      thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
3328      return thenable;
3329    }
3330    function pingEngtangledActionScope() {
3331      if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
3332        null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
3333        var listeners = currentEntangledListeners;
3334        currentEntangledListeners = null;
3335        currentEntangledLane = 0;
3336        currentEntangledActionThenable = null;
3337        for (var i2 = 0; i2 < listeners.length; i2++) (0, listeners[i2])();
3338      }
3339    }
3340    function chainThenableValue(thenable, result) {
3341      var listeners = [], thenableWithOverride = {
3342        status: "pending",
3343        value: null,
3344        reason: null,
3345        then: function(resolve) {
3346          listeners.push(resolve);
3347        }
3348      };
3349      thenable.then(
3350        function() {
3351          thenableWithOverride.status = "fulfilled";
3352          thenableWithOverride.value = result;
3353          for (var i2 = 0; i2 < listeners.length; i2++) (0, listeners[i2])(result);
3354        },
3355        function(error) {
3356          thenableWithOverride.status = "rejected";
3357          thenableWithOverride.reason = error;
3358          for (error = 0; error < listeners.length; error++)
3359            (0, listeners[error])(void 0);
3360        }
3361      );
3362      return thenableWithOverride;
3363    }
3364    var prevOnStartTransitionFinish = ReactSharedInternals.S;
3365    ReactSharedInternals.S = function(transition, returnValue) {
3366      globalMostRecentTransitionTime = now();
3367      "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
3368      null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
3369    };
3370    var resumedCache = createCursor(null);
3371    function peekCacheFromPool() {
3372      var cacheResumedFromPreviousRender = resumedCache.current;
3373      return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
3374    }
3375    function pushTransition(offscreenWorkInProgress, prevCachePool) {
3376      null === prevCachePool ? push(resumedCache, resumedCache.current) : push(resumedCache, prevCachePool.pool);
3377    }
3378    function getSuspendedCache() {
3379      var cacheFromPool = peekCacheFromPool();
3380      return null === cacheFromPool ? null : { parent: CacheContext._currentValue, pool: cacheFromPool };
3381    }
3382    var SuspenseException = Error(formatProdErrorMessage(460)), SuspenseyCommitException = Error(formatProdErrorMessage(474)), SuspenseActionException = Error(formatProdErrorMessage(542)), noopSuspenseyCommitThenable = { then: function() {
3383    } };
3384    function isThenableResolved(thenable) {
3385      thenable = thenable.status;
3386      return "fulfilled" === thenable || "rejected" === thenable;
3387    }
3388    function trackUsedThenable(thenableState2, thenable, index2) {
3389      index2 = thenableState2[index2];
3390      void 0 === index2 ? thenableState2.push(thenable) : index2 !== thenable && (thenable.then(noop$12, noop$12), thenable = index2);
3391      switch (thenable.status) {
3392        case "fulfilled":
3393          return thenable.value;
3394        case "rejected":
3395          throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
3396        default:
3397          if ("string" === typeof thenable.status) thenable.then(noop$12, noop$12);
3398          else {
3399            thenableState2 = workInProgressRoot;
3400            if (null !== thenableState2 && 100 < thenableState2.shellSuspendCounter)
3401              throw Error(formatProdErrorMessage(482));
3402            thenableState2 = thenable;
3403            thenableState2.status = "pending";
3404            thenableState2.then(
3405              function(fulfilledValue) {
3406                if ("pending" === thenable.status) {
3407                  var fulfilledThenable = thenable;
3408                  fulfilledThenable.status = "fulfilled";
3409                  fulfilledThenable.value = fulfilledValue;
3410                }
3411              },
3412              function(error) {
3413                if ("pending" === thenable.status) {
3414                  var rejectedThenable = thenable;
3415                  rejectedThenable.status = "rejected";
3416                  rejectedThenable.reason = error;
3417                }
3418              }
3419            );
3420          }
3421          switch (thenable.status) {
3422            case "fulfilled":
3423              return thenable.value;
3424            case "rejected":
3425              throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
3426          }
3427          suspendedThenable = thenable;
3428          throw SuspenseException;
3429      }
3430    }
3431    function resolveLazy(lazyType) {
3432      try {
3433        var init = lazyType._init;
3434        return init(lazyType._payload);
3435      } catch (x) {
3436        if (null !== x && "object" === typeof x && "function" === typeof x.then)
3437          throw suspendedThenable = x, SuspenseException;
3438        throw x;
3439      }
3440    }
3441    var suspendedThenable = null;
3442    function getSuspendedThenable() {
3443      if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
3444      var thenable = suspendedThenable;
3445      suspendedThenable = null;
3446      return thenable;
3447    }
3448    function checkIfUseWrappedInAsyncCatch(rejectedReason) {
3449      if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException)
3450        throw Error(formatProdErrorMessage(483));
3451    }
3452    var thenableState$1 = null, thenableIndexCounter$1 = 0;
3453    function unwrapThenable(thenable) {
3454      var index2 = thenableIndexCounter$1;
3455      thenableIndexCounter$1 += 1;
3456      null === thenableState$1 && (thenableState$1 = []);
3457      return trackUsedThenable(thenableState$1, thenable, index2);
3458    }
3459    function coerceRef(workInProgress2, element) {
3460      element = element.props.ref;
3461      workInProgress2.ref = void 0 !== element ? element : null;
3462    }
3463    function throwOnInvalidObjectTypeImpl(returnFiber, newChild) {
3464      if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE)
3465        throw Error(formatProdErrorMessage(525));
3466      returnFiber = Object.prototype.toString.call(newChild);
3467      throw Error(
3468        formatProdErrorMessage(
3469          31,
3470          "[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber
3471        )
3472      );
3473    }
3474    function createChildReconciler(shouldTrackSideEffects) {
3475      function deleteChild(returnFiber, childToDelete) {
3476        if (shouldTrackSideEffects) {
3477          var deletions = returnFiber.deletions;
3478          null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
3479        }
3480      }
3481      function deleteRemainingChildren(returnFiber, currentFirstChild) {
3482        if (!shouldTrackSideEffects) return null;
3483        for (; null !== currentFirstChild; )
3484          deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
3485        return null;
3486      }
3487      function mapRemainingChildren(currentFirstChild) {
3488        for (var existingChildren = /* @__PURE__ */ new Map(); null !== currentFirstChild; )
3489          null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
3490        return existingChildren;
3491      }
3492      function useFiber(fiber, pendingProps) {
3493        fiber = createWorkInProgress(fiber, pendingProps);
3494        fiber.index = 0;
3495        fiber.sibling = null;
3496        return fiber;
3497      }
3498      function placeChild(newFiber, lastPlacedIndex, newIndex) {
3499        newFiber.index = newIndex;
3500        if (!shouldTrackSideEffects)
3501          return newFiber.flags |= 1048576, lastPlacedIndex;
3502        newIndex = newFiber.alternate;
3503        if (null !== newIndex)
3504          return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
3505        newFiber.flags |= 67108866;
3506        return lastPlacedIndex;
3507      }
3508      function placeSingleChild(newFiber) {
3509        shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
3510        return newFiber;
3511      }
3512      function updateTextNode(returnFiber, current, textContent, lanes) {
3513        if (null === current || 6 !== current.tag)
3514          return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current;
3515        current = useFiber(current, textContent);
3516        current.return = returnFiber;
3517        return current;
3518      }
3519      function updateElement(returnFiber, current, element, lanes) {
3520        var elementType = element.type;
3521        if (elementType === REACT_FRAGMENT_TYPE)
3522          return updateFragment(
3523            returnFiber,
3524            current,
3525            element.props.children,
3526            lanes,
3527            element.key
3528          );
3529        if (null !== current && (current.elementType === elementType || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type))
3530          return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current;
3531        current = createFiberFromTypeAndProps(
3532          element.type,
3533          element.key,
3534          element.props,
3535          null,
3536          returnFiber.mode,
3537          lanes
3538        );
3539        coerceRef(current, element);
3540        current.return = returnFiber;
3541        return current;
3542      }
3543      function updatePortal(returnFiber, current, portal, lanes) {
3544        if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation)
3545          return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current;
3546        current = useFiber(current, portal.children || []);
3547        current.return = returnFiber;
3548        return current;
3549      }
3550      function updateFragment(returnFiber, current, fragment, lanes, key2) {
3551        if (null === current || 7 !== current.tag)
3552          return current = createFiberFromFragment(
3553            fragment,
3554            returnFiber.mode,
3555            lanes,
3556            key2
3557          ), current.return = returnFiber, current;
3558        current = useFiber(current, fragment);
3559        current.return = returnFiber;
3560        return current;
3561      }
3562      function createChild(returnFiber, newChild, lanes) {
3563        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
3564          return newChild = createFiberFromText(
3565            "" + newChild,
3566            returnFiber.mode,
3567            lanes
3568          ), newChild.return = returnFiber, newChild;
3569        if ("object" === typeof newChild && null !== newChild) {
3570          switch (newChild.$$typeof) {
3571            case REACT_ELEMENT_TYPE:
3572              return lanes = createFiberFromTypeAndProps(
3573                newChild.type,
3574                newChild.key,
3575                newChild.props,
3576                null,
3577                returnFiber.mode,
3578                lanes
3579              ), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes;
3580            case REACT_PORTAL_TYPE:
3581              return newChild = createFiberFromPortal(
3582                newChild,
3583                returnFiber.mode,
3584                lanes
3585              ), newChild.return = returnFiber, newChild;
3586            case REACT_LAZY_TYPE:
3587              return newChild = resolveLazy(newChild), createChild(returnFiber, newChild, lanes);
3588          }
3589          if (isArrayImpl(newChild) || getIteratorFn(newChild))
3590            return newChild = createFiberFromFragment(
3591              newChild,
3592              returnFiber.mode,
3593              lanes,
3594              null
3595            ), newChild.return = returnFiber, newChild;
3596          if ("function" === typeof newChild.then)
3597            return createChild(returnFiber, unwrapThenable(newChild), lanes);
3598          if (newChild.$$typeof === REACT_CONTEXT_TYPE)
3599            return createChild(
3600              returnFiber,
3601              readContextDuringReconciliation(returnFiber, newChild),
3602              lanes
3603            );
3604          throwOnInvalidObjectTypeImpl(returnFiber, newChild);
3605        }
3606        return null;
3607      }
3608      function updateSlot(returnFiber, oldFiber, newChild, lanes) {
3609        var key2 = null !== oldFiber ? oldFiber.key : null;
3610        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
3611          return null !== key2 ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
3612        if ("object" === typeof newChild && null !== newChild) {
3613          switch (newChild.$$typeof) {
3614            case REACT_ELEMENT_TYPE:
3615              return newChild.key === key2 ? updateElement(returnFiber, oldFiber, newChild, lanes) : null;
3616            case REACT_PORTAL_TYPE:
3617              return newChild.key === key2 ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
3618            case REACT_LAZY_TYPE:
3619              return newChild = resolveLazy(newChild), updateSlot(returnFiber, oldFiber, newChild, lanes);
3620          }
3621          if (isArrayImpl(newChild) || getIteratorFn(newChild))
3622            return null !== key2 ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
3623          if ("function" === typeof newChild.then)
3624            return updateSlot(
3625              returnFiber,
3626              oldFiber,
3627              unwrapThenable(newChild),
3628              lanes
3629            );
3630          if (newChild.$$typeof === REACT_CONTEXT_TYPE)
3631            return updateSlot(
3632              returnFiber,
3633              oldFiber,
3634              readContextDuringReconciliation(returnFiber, newChild),
3635              lanes
3636            );
3637          throwOnInvalidObjectTypeImpl(returnFiber, newChild);
3638        }
3639        return null;
3640      }
3641      function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
3642        if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
3643          return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
3644        if ("object" === typeof newChild && null !== newChild) {
3645          switch (newChild.$$typeof) {
3646            case REACT_ELEMENT_TYPE:
3647              return existingChildren = existingChildren.get(
3648                null === newChild.key ? newIdx : newChild.key
3649              ) || null, updateElement(returnFiber, existingChildren, newChild, lanes);
3650            case REACT_PORTAL_TYPE:
3651              return existingChildren = existingChildren.get(
3652                null === newChild.key ? newIdx : newChild.key
3653              ) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
3654            case REACT_LAZY_TYPE:
3655              return newChild = resolveLazy(newChild), updateFromMap(
3656                existingChildren,
3657                returnFiber,
3658                newIdx,
3659                newChild,
3660                lanes
3661              );
3662          }
3663          if (isArrayImpl(newChild) || getIteratorFn(newChild))
3664            return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, lanes, null);
3665          if ("function" === typeof newChild.then)
3666            return updateFromMap(
3667              existingChildren,
3668              returnFiber,
3669              newIdx,
3670              unwrapThenable(newChild),
3671              lanes
3672            );
3673          if (newChild.$$typeof === REACT_CONTEXT_TYPE)
3674            return updateFromMap(
3675              existingChildren,
3676              returnFiber,
3677              newIdx,
3678              readContextDuringReconciliation(returnFiber, newChild),
3679              lanes
3680            );
3681          throwOnInvalidObjectTypeImpl(returnFiber, newChild);
3682        }
3683        return null;
3684      }
3685      function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
3686        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
3687          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
3688          var newFiber = updateSlot(
3689            returnFiber,
3690            oldFiber,
3691            newChildren[newIdx],
3692            lanes
3693          );
3694          if (null === newFiber) {
3695            null === oldFiber && (oldFiber = nextOldFiber);
3696            break;
3697          }
3698          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
3699          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
3700          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
3701          previousNewFiber = newFiber;
3702          oldFiber = nextOldFiber;
3703        }
3704        if (newIdx === newChildren.length)
3705          return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
3706        if (null === oldFiber) {
3707          for (; newIdx < newChildren.length; newIdx++)
3708            oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (currentFirstChild = placeChild(
3709              oldFiber,
3710              currentFirstChild,
3711              newIdx
3712            ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
3713          isHydrating && pushTreeFork(returnFiber, newIdx);
3714          return resultingFirstChild;
3715        }
3716        for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++)
3717          nextOldFiber = updateFromMap(
3718            oldFiber,
3719            returnFiber,
3720            newIdx,
3721            newChildren[newIdx],
3722            lanes
3723          ), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
3724            null === nextOldFiber.key ? newIdx : nextOldFiber.key
3725          ), currentFirstChild = placeChild(
3726            nextOldFiber,
3727            currentFirstChild,
3728            newIdx
3729          ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
3730        shouldTrackSideEffects && oldFiber.forEach(function(child) {
3731          return deleteChild(returnFiber, child);
3732        });
3733        isHydrating && pushTreeFork(returnFiber, newIdx);
3734        return resultingFirstChild;
3735      }
3736      function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
3737        if (null == newChildren) throw Error(formatProdErrorMessage(151));
3738        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
3739          oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
3740          var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
3741          if (null === newFiber) {
3742            null === oldFiber && (oldFiber = nextOldFiber);
3743            break;
3744          }
3745          shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
3746          currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
3747          null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
3748          previousNewFiber = newFiber;
3749          oldFiber = nextOldFiber;
3750        }
3751        if (step.done)
3752          return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
3753        if (null === oldFiber) {
3754          for (; !step.done; newIdx++, step = newChildren.next())
3755            step = createChild(returnFiber, step.value, lanes), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
3756          isHydrating && pushTreeFork(returnFiber, newIdx);
3757          return resultingFirstChild;
3758        }
3759        for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next())
3760          step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
3761        shouldTrackSideEffects && oldFiber.forEach(function(child) {
3762          return deleteChild(returnFiber, child);
3763        });
3764        isHydrating && pushTreeFork(returnFiber, newIdx);
3765        return resultingFirstChild;
3766      }
3767      function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
3768        "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (newChild = newChild.props.children);
3769        if ("object" === typeof newChild && null !== newChild) {
3770          switch (newChild.$$typeof) {
3771            case REACT_ELEMENT_TYPE:
3772              a: {
3773                for (var key2 = newChild.key; null !== currentFirstChild; ) {
3774                  if (currentFirstChild.key === key2) {
3775                    key2 = newChild.type;
3776                    if (key2 === REACT_FRAGMENT_TYPE) {
3777                      if (7 === currentFirstChild.tag) {
3778                        deleteRemainingChildren(
3779                          returnFiber,
3780                          currentFirstChild.sibling
3781                        );
3782                        lanes = useFiber(
3783                          currentFirstChild,
3784                          newChild.props.children
3785                        );
3786                        lanes.return = returnFiber;
3787                        returnFiber = lanes;
3788                        break a;
3789                      }
3790                    } else if (currentFirstChild.elementType === key2 || "object" === typeof key2 && null !== key2 && key2.$$typeof === REACT_LAZY_TYPE && resolveLazy(key2) === currentFirstChild.type) {
3791                      deleteRemainingChildren(
3792                        returnFiber,
3793                        currentFirstChild.sibling
3794                      );
3795                      lanes = useFiber(currentFirstChild, newChild.props);
3796                      coerceRef(lanes, newChild);
3797                      lanes.return = returnFiber;
3798                      returnFiber = lanes;
3799                      break a;
3800                    }
3801                    deleteRemainingChildren(returnFiber, currentFirstChild);
3802                    break;
3803                  } else deleteChild(returnFiber, currentFirstChild);
3804                  currentFirstChild = currentFirstChild.sibling;
3805                }
3806                newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(
3807                  newChild.props.children,
3808                  returnFiber.mode,
3809                  lanes,
3810                  newChild.key
3811                ), lanes.return = returnFiber, returnFiber = lanes) : (lanes = createFiberFromTypeAndProps(
3812                  newChild.type,
3813                  newChild.key,
3814                  newChild.props,
3815                  null,
3816                  returnFiber.mode,
3817                  lanes
3818                ), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = lanes);
3819              }
3820              return placeSingleChild(returnFiber);
3821            case REACT_PORTAL_TYPE:
3822              a: {
3823                for (key2 = newChild.key; null !== currentFirstChild; ) {
3824                  if (currentFirstChild.key === key2)
3825                    if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
3826                      deleteRemainingChildren(
3827                        returnFiber,
3828                        currentFirstChild.sibling
3829                      );
3830                      lanes = useFiber(currentFirstChild, newChild.children || []);
3831                      lanes.return = returnFiber;
3832                      returnFiber = lanes;
3833                      break a;
3834                    } else {
3835                      deleteRemainingChildren(returnFiber, currentFirstChild);
3836                      break;
3837                    }
3838                  else deleteChild(returnFiber, currentFirstChild);
3839                  currentFirstChild = currentFirstChild.sibling;
3840                }
3841                lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);
3842                lanes.return = returnFiber;
3843                returnFiber = lanes;
3844              }
3845              return placeSingleChild(returnFiber);
3846            case REACT_LAZY_TYPE:
3847              return newChild = resolveLazy(newChild), reconcileChildFibersImpl(
3848                returnFiber,
3849                currentFirstChild,
3850                newChild,
3851                lanes
3852              );
3853          }
3854          if (isArrayImpl(newChild))
3855            return reconcileChildrenArray(
3856              returnFiber,
3857              currentFirstChild,
3858              newChild,
3859              lanes
3860            );
3861          if (getIteratorFn(newChild)) {
3862            key2 = getIteratorFn(newChild);
3863            if ("function" !== typeof key2) throw Error(formatProdErrorMessage(150));
3864            newChild = key2.call(newChild);
3865            return reconcileChildrenIterator(
3866              returnFiber,
3867              currentFirstChild,
3868              newChild,
3869              lanes
3870            );
3871          }
3872          if ("function" === typeof newChild.then)
3873            return reconcileChildFibersImpl(
3874              returnFiber,
3875              currentFirstChild,
3876              unwrapThenable(newChild),
3877              lanes
3878            );
3879          if (newChild.$$typeof === REACT_CONTEXT_TYPE)
3880            return reconcileChildFibersImpl(
3881              returnFiber,
3882              currentFirstChild,
3883              readContextDuringReconciliation(returnFiber, newChild),
3884              lanes
3885            );
3886          throwOnInvalidObjectTypeImpl(returnFiber, newChild);
3887        }
3888        return "string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild ? (newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, newChild), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(newChild, returnFiber.mode, lanes), lanes.return = returnFiber, returnFiber = lanes), placeSingleChild(returnFiber)) : deleteRemainingChildren(returnFiber, currentFirstChild);
3889      }
3890      return function(returnFiber, currentFirstChild, newChild, lanes) {
3891        try {
3892          thenableIndexCounter$1 = 0;
3893          var firstChildFiber = reconcileChildFibersImpl(
3894            returnFiber,
3895            currentFirstChild,
3896            newChild,
3897            lanes
3898          );
3899          thenableState$1 = null;
3900          return firstChildFiber;
3901        } catch (x) {
3902          if (x === SuspenseException || x === SuspenseActionException) throw x;
3903          var fiber = createFiberImplClass(29, x, null, returnFiber.mode);
3904          fiber.lanes = lanes;
3905          fiber.return = returnFiber;
3906          return fiber;
3907        } finally {
3908        }
3909      };
3910    }
3911    var reconcileChildFibers = createChildReconciler(true), mountChildFibers = createChildReconciler(false), hasForceUpdate = false;
3912    function initializeUpdateQueue(fiber) {
3913      fiber.updateQueue = {
3914        baseState: fiber.memoizedState,
3915        firstBaseUpdate: null,
3916        lastBaseUpdate: null,
3917        shared: { pending: null, lanes: 0, hiddenCallbacks: null },
3918        callbacks: null
3919      };
3920    }
3921    function cloneUpdateQueue(current, workInProgress2) {
3922      current = current.updateQueue;
3923      workInProgress2.updateQueue === current && (workInProgress2.updateQueue = {
3924        baseState: current.baseState,
3925        firstBaseUpdate: current.firstBaseUpdate,
3926        lastBaseUpdate: current.lastBaseUpdate,
3927        shared: current.shared,
3928        callbacks: null
3929      });
3930    }
3931    function createUpdate(lane) {
3932      return { lane, tag: 0, payload: null, callback: null, next: null };
3933    }
3934    function enqueueUpdate(fiber, update, lane) {
3935      var updateQueue = fiber.updateQueue;
3936      if (null === updateQueue) return null;
3937      updateQueue = updateQueue.shared;
3938      if (0 !== (executionContext & 2)) {
3939        var pending = updateQueue.pending;
3940        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
3941        updateQueue.pending = update;
3942        update = getRootForUpdatedFiber(fiber);
3943        markUpdateLaneFromFiberToRoot(fiber, null, lane);
3944        return update;
3945      }
3946      enqueueUpdate$1(fiber, updateQueue, update, lane);
3947      return getRootForUpdatedFiber(fiber);
3948    }
3949    function entangleTransitions(root2, fiber, lane) {
3950      fiber = fiber.updateQueue;
3951      if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
3952        var queueLanes = fiber.lanes;
3953        queueLanes &= root2.pendingLanes;
3954        lane |= queueLanes;
3955        fiber.lanes = lane;
3956        markRootEntangled(root2, lane);
3957      }
3958    }
3959    function enqueueCapturedUpdate(workInProgress2, capturedUpdate) {
3960      var queue2 = workInProgress2.updateQueue, current = workInProgress2.alternate;
3961      if (null !== current && (current = current.updateQueue, queue2 === current)) {
3962        var newFirst = null, newLast = null;
3963        queue2 = queue2.firstBaseUpdate;
3964        if (null !== queue2) {
3965          do {
3966            var clone = {
3967              lane: queue2.lane,
3968              tag: queue2.tag,
3969              payload: queue2.payload,
3970              callback: null,
3971              next: null
3972            };
3973            null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
3974            queue2 = queue2.next;
3975          } while (null !== queue2);
3976          null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
3977        } else newFirst = newLast = capturedUpdate;
3978        queue2 = {
3979          baseState: current.baseState,
3980          firstBaseUpdate: newFirst,
3981          lastBaseUpdate: newLast,
3982          shared: current.shared,
3983          callbacks: current.callbacks
3984        };
3985        workInProgress2.updateQueue = queue2;
3986        return;
3987      }
3988      workInProgress2 = queue2.lastBaseUpdate;
3989      null === workInProgress2 ? queue2.firstBaseUpdate = capturedUpdate : workInProgress2.next = capturedUpdate;
3990      queue2.lastBaseUpdate = capturedUpdate;
3991    }
3992    var didReadFromEntangledAsyncAction = false;
3993    function suspendIfUpdateReadFromEntangledAsyncAction() {
3994      if (didReadFromEntangledAsyncAction) {
3995        var entangledActionThenable = currentEntangledActionThenable;
3996        if (null !== entangledActionThenable) throw entangledActionThenable;
3997      }
3998    }
3999    function processUpdateQueue(workInProgress$jscomp$0, props, instance$jscomp$0, renderLanes2) {
4000      didReadFromEntangledAsyncAction = false;
4001      var queue2 = workInProgress$jscomp$0.updateQueue;
4002      hasForceUpdate = false;
4003      var firstBaseUpdate = queue2.firstBaseUpdate, lastBaseUpdate = queue2.lastBaseUpdate, pendingQueue = queue2.shared.pending;
4004      if (null !== pendingQueue) {
4005        queue2.shared.pending = null;
4006        var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
4007        lastPendingUpdate.next = null;
4008        null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
4009        lastBaseUpdate = lastPendingUpdate;
4010        var current = workInProgress$jscomp$0.alternate;
4011        null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
4012      }
4013      if (null !== firstBaseUpdate) {
4014        var newState = queue2.baseState;
4015        lastBaseUpdate = 0;
4016        current = firstPendingUpdate = lastPendingUpdate = null;
4017        pendingQueue = firstBaseUpdate;
4018        do {
4019          var updateLane = pendingQueue.lane & -536870913, isHiddenUpdate = updateLane !== pendingQueue.lane;
4020          if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes2 & updateLane) === updateLane) {
4021            0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = true);
4022            null !== current && (current = current.next = {
4023              lane: 0,
4024              tag: pendingQueue.tag,
4025              payload: pendingQueue.payload,
4026              callback: null,
4027              next: null
4028            });
4029            a: {
4030              var workInProgress2 = workInProgress$jscomp$0, update = pendingQueue;
4031              updateLane = props;
4032              var instance = instance$jscomp$0;
4033              switch (update.tag) {
4034                case 1:
4035                  workInProgress2 = update.payload;
4036                  if ("function" === typeof workInProgress2) {
4037                    newState = workInProgress2.call(instance, newState, updateLane);
4038                    break a;
4039                  }
4040                  newState = workInProgress2;
4041                  break a;
4042                case 3:
4043                  workInProgress2.flags = workInProgress2.flags & -65537 | 128;
4044                case 0:
4045                  workInProgress2 = update.payload;
4046                  updateLane = "function" === typeof workInProgress2 ? workInProgress2.call(instance, newState, updateLane) : workInProgress2;
4047                  if (null === updateLane || void 0 === updateLane) break a;
4048                  newState = assign({}, newState, updateLane);
4049                  break a;
4050                case 2:
4051                  hasForceUpdate = true;
4052              }
4053            }
4054            updateLane = pendingQueue.callback;
4055            null !== updateLane && (workInProgress$jscomp$0.flags |= 64, isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192), isHiddenUpdate = queue2.callbacks, null === isHiddenUpdate ? queue2.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
4056          } else
4057            isHiddenUpdate = {
4058              lane: updateLane,
4059              tag: pendingQueue.tag,
4060              payload: pendingQueue.payload,
4061              callback: pendingQueue.callback,
4062              next: null
4063            }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
4064          pendingQueue = pendingQueue.next;

vendor: 14,013 bytes, lines 4065-4353

4065          if (null === pendingQueue)
4066            if (pendingQueue = queue2.shared.pending, null === pendingQueue)
4067              break;
4068            else
4069              isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue2.lastBaseUpdate = isHiddenUpdate, queue2.shared.pending = null;
4070        } while (1);
4071        null === current && (lastPendingUpdate = newState);
4072        queue2.baseState = lastPendingUpdate;
4073        queue2.firstBaseUpdate = firstPendingUpdate;
4074        queue2.lastBaseUpdate = current;
4075        null === firstBaseUpdate && (queue2.shared.lanes = 0);
4076        workInProgressRootSkippedLanes |= lastBaseUpdate;
4077        workInProgress$jscomp$0.lanes = lastBaseUpdate;
4078        workInProgress$jscomp$0.memoizedState = newState;
4079      }
4080    }
4081    function callCallback(callback, context) {
4082      if ("function" !== typeof callback)
4083        throw Error(formatProdErrorMessage(191, callback));
4084      callback.call(context);
4085    }
4086    function commitCallbacks(updateQueue, context) {
4087      var callbacks = updateQueue.callbacks;
4088      if (null !== callbacks)
4089        for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++)
4090          callCallback(callbacks[updateQueue], context);
4091    }
4092    var currentTreeHiddenStackCursor = createCursor(null), prevEntangledRenderLanesCursor = createCursor(0);
4093    function pushHiddenContext(fiber, context) {
4094      fiber = entangledRenderLanes;
4095      push(prevEntangledRenderLanesCursor, fiber);
4096      push(currentTreeHiddenStackCursor, context);
4097      entangledRenderLanes = fiber | context.baseLanes;
4098    }
4099    function reuseHiddenContextOnStack() {
4100      push(prevEntangledRenderLanesCursor, entangledRenderLanes);
4101      push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
4102    }
4103    function popHiddenContext() {
4104      entangledRenderLanes = prevEntangledRenderLanesCursor.current;
4105      pop(currentTreeHiddenStackCursor);
4106      pop(prevEntangledRenderLanesCursor);
4107    }
4108    var suspenseHandlerStackCursor = createCursor(null), shellBoundary = null;
4109    function pushPrimaryTreeSuspenseHandler(handler) {
4110      var current = handler.alternate;
4111      push(suspenseStackCursor, suspenseStackCursor.current & 1);
4112      push(suspenseHandlerStackCursor, handler);
4113      null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
4114    }
4115    function pushDehydratedActivitySuspenseHandler(fiber) {
4116      push(suspenseStackCursor, suspenseStackCursor.current);
4117      push(suspenseHandlerStackCursor, fiber);
4118      null === shellBoundary && (shellBoundary = fiber);
4119    }
4120    function pushOffscreenSuspenseHandler(fiber) {
4121      22 === fiber.tag ? (push(suspenseStackCursor, suspenseStackCursor.current), push(suspenseHandlerStackCursor, fiber), null === shellBoundary && (shellBoundary = fiber)) : reuseSuspenseHandlerOnStack();
4122    }
4123    function reuseSuspenseHandlerOnStack() {
4124      push(suspenseStackCursor, suspenseStackCursor.current);
4125      push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
4126    }
4127    function popSuspenseHandler(fiber) {
4128      pop(suspenseHandlerStackCursor);
4129      shellBoundary === fiber && (shellBoundary = null);
4130      pop(suspenseStackCursor);
4131    }
4132    var suspenseStackCursor = createCursor(0);
4133    function findFirstSuspended(row) {
4134      for (var node2 = row; null !== node2; ) {
4135        if (13 === node2.tag) {
4136          var state2 = node2.memoizedState;
4137          if (null !== state2 && (state2 = state2.dehydrated, null === state2 || isSuspenseInstancePending(state2) || isSuspenseInstanceFallback(state2)))
4138            return node2;
4139        } else if (19 === node2.tag && ("forwards" === node2.memoizedProps.revealOrder || "backwards" === node2.memoizedProps.revealOrder || "unstable_legacy-backwards" === node2.memoizedProps.revealOrder || "together" === node2.memoizedProps.revealOrder)) {
4140          if (0 !== (node2.flags & 128)) return node2;
4141        } else if (null !== node2.child) {
4142          node2.child.return = node2;
4143          node2 = node2.child;
4144          continue;
4145        }
4146        if (node2 === row) break;
4147        for (; null === node2.sibling; ) {
4148          if (null === node2.return || node2.return === row) return null;
4149          node2 = node2.return;
4150        }
4151        node2.sibling.return = node2.return;
4152        node2 = node2.sibling;
4153      }
4154      return null;
4155    }
4156    var renderLanes = 0, currentlyRenderingFiber = null, currentHook = null, workInProgressHook = null, didScheduleRenderPhaseUpdate = false, didScheduleRenderPhaseUpdateDuringThisPass = false, shouldDoubleInvokeUserFnsInHooksDEV = false, localIdCounter = 0, thenableIndexCounter = 0, thenableState = null, globalClientIdCounter = 0;
4157    function throwInvalidHookError() {
4158      throw Error(formatProdErrorMessage(321));
4159    }
4160    function areHookInputsEqual(nextDeps, prevDeps) {
4161      if (null === prevDeps) return false;
4162      for (var i2 = 0; i2 < prevDeps.length && i2 < nextDeps.length; i2++)
4163        if (!objectIs2(nextDeps[i2], prevDeps[i2])) return false;
4164      return true;
4165    }
4166    function renderWithHooks(current, workInProgress2, Component, props, secondArg, nextRenderLanes) {
4167      renderLanes = nextRenderLanes;
4168      currentlyRenderingFiber = workInProgress2;
4169      workInProgress2.memoizedState = null;
4170      workInProgress2.updateQueue = null;
4171      workInProgress2.lanes = 0;
4172      ReactSharedInternals.H = null === current || null === current.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
4173      shouldDoubleInvokeUserFnsInHooksDEV = false;
4174      nextRenderLanes = Component(props, secondArg);
4175      shouldDoubleInvokeUserFnsInHooksDEV = false;
4176      didScheduleRenderPhaseUpdateDuringThisPass && (nextRenderLanes = renderWithHooksAgain(
4177        workInProgress2,
4178        Component,
4179        props,
4180        secondArg
4181      ));
4182      finishRenderingHooks(current);
4183      return nextRenderLanes;
4184    }
4185    function finishRenderingHooks(current) {
4186      ReactSharedInternals.H = ContextOnlyDispatcher;
4187      var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
4188      renderLanes = 0;
4189      workInProgressHook = currentHook = currentlyRenderingFiber = null;
4190      didScheduleRenderPhaseUpdate = false;
4191      thenableIndexCounter = 0;
4192      thenableState = null;
4193      if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
4194      null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = true));
4195    }
4196    function renderWithHooksAgain(workInProgress2, Component, props, secondArg) {
4197      currentlyRenderingFiber = workInProgress2;
4198      var numberOfReRenders = 0;
4199      do {
4200        didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
4201        thenableIndexCounter = 0;
4202        didScheduleRenderPhaseUpdateDuringThisPass = false;
4203        if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
4204        numberOfReRenders += 1;
4205        workInProgressHook = currentHook = null;
4206        if (null != workInProgress2.updateQueue) {
4207          var children = workInProgress2.updateQueue;
4208          children.lastEffect = null;
4209          children.events = null;
4210          children.stores = null;
4211          null != children.memoCache && (children.memoCache.index = 0);
4212        }
4213        ReactSharedInternals.H = HooksDispatcherOnRerender;
4214        children = Component(props, secondArg);
4215      } while (didScheduleRenderPhaseUpdateDuringThisPass);
4216      return children;
4217    }
4218    function TransitionAwareHostComponent() {
4219      var dispatcher = ReactSharedInternals.H, maybeThenable = dispatcher.useState()[0];
4220      maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
4221      dispatcher = dispatcher.useState()[0];
4222      (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
4223      return maybeThenable;
4224    }
4225    function checkDidRenderIdHook() {
4226      var didRenderIdHook = 0 !== localIdCounter;
4227      localIdCounter = 0;
4228      return didRenderIdHook;
4229    }
4230    function bailoutHooks(current, workInProgress2, lanes) {
4231      workInProgress2.updateQueue = current.updateQueue;
4232      workInProgress2.flags &= -2053;
4233      current.lanes &= ~lanes;
4234    }
4235    function resetHooksOnUnwind(workInProgress2) {
4236      if (didScheduleRenderPhaseUpdate) {
4237        for (workInProgress2 = workInProgress2.memoizedState; null !== workInProgress2; ) {
4238          var queue2 = workInProgress2.queue;
4239          null !== queue2 && (queue2.pending = null);
4240          workInProgress2 = workInProgress2.next;
4241        }
4242        didScheduleRenderPhaseUpdate = false;
4243      }
4244      renderLanes = 0;
4245      workInProgressHook = currentHook = currentlyRenderingFiber = null;
4246      didScheduleRenderPhaseUpdateDuringThisPass = false;
4247      thenableIndexCounter = localIdCounter = 0;
4248      thenableState = null;
4249    }
4250    function mountWorkInProgressHook() {
4251      var hook = {
4252        memoizedState: null,
4253        baseState: null,
4254        baseQueue: null,
4255        queue: null,
4256        next: null
4257      };
4258      null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
4259      return workInProgressHook;
4260    }
4261    function updateWorkInProgressHook() {
4262      if (null === currentHook) {
4263        var nextCurrentHook = currentlyRenderingFiber.alternate;
4264        nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
4265      } else nextCurrentHook = currentHook.next;
4266      var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
4267      if (null !== nextWorkInProgressHook)
4268        workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;
4269      else {
4270        if (null === nextCurrentHook) {
4271          if (null === currentlyRenderingFiber.alternate)
4272            throw Error(formatProdErrorMessage(467));
4273          throw Error(formatProdErrorMessage(310));
4274        }
4275        currentHook = nextCurrentHook;
4276        nextCurrentHook = {
4277          memoizedState: currentHook.memoizedState,
4278          baseState: currentHook.baseState,
4279          baseQueue: currentHook.baseQueue,
4280          queue: currentHook.queue,
4281          next: null
4282        };
4283        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
4284      }
4285      return workInProgressHook;
4286    }
4287    function createFunctionComponentUpdateQueue() {
4288      return { lastEffect: null, events: null, stores: null, memoCache: null };
4289    }
4290    function useThenable(thenable) {
4291      var index2 = thenableIndexCounter;
4292      thenableIndexCounter += 1;
4293      null === thenableState && (thenableState = []);
4294      thenable = trackUsedThenable(thenableState, thenable, index2);
4295      index2 = currentlyRenderingFiber;
4296      null === (null === workInProgressHook ? index2.memoizedState : workInProgressHook.next) && (index2 = index2.alternate, ReactSharedInternals.H = null === index2 || null === index2.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate);
4297      return thenable;
4298    }
4299    function use(usable) {
4300      if (null !== usable && "object" === typeof usable) {
4301        if ("function" === typeof usable.then) return useThenable(usable);
4302        if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
4303      }
4304      throw Error(formatProdErrorMessage(438, String(usable)));
4305    }
4306    function useMemoCache(size) {
4307      var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
4308      null !== updateQueue && (memoCache = updateQueue.memoCache);
4309      if (null == memoCache) {
4310        var current = currentlyRenderingFiber.alternate;
4311        null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
4312          data: current.data.map(function(array) {
4313            return array.slice();
4314          }),
4315          index: 0
4316        })));
4317      }
4318      null == memoCache && (memoCache = { data: [], index: 0 });
4319      null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
4320      updateQueue.memoCache = memoCache;
4321      updateQueue = memoCache.data[memoCache.index];
4322      if (void 0 === updateQueue)
4323        for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++)
4324          updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
4325      memoCache.index++;
4326      return updateQueue;
4327    }
4328    function basicStateReducer(state2, action) {
4329      return "function" === typeof action ? action(state2) : action;
4330    }
4331    function updateReducer(reducer) {
4332      var hook = updateWorkInProgressHook();
4333      return updateReducerImpl(hook, currentHook, reducer);
4334    }
4335    function updateReducerImpl(hook, current, reducer) {
4336      var queue2 = hook.queue;
4337      if (null === queue2) throw Error(formatProdErrorMessage(311));
4338      queue2.lastRenderedReducer = reducer;
4339      var baseQueue = hook.baseQueue, pendingQueue = queue2.pending;
4340      if (null !== pendingQueue) {
4341        if (null !== baseQueue) {
4342          var baseFirst = baseQueue.next;
4343          baseQueue.next = pendingQueue.next;
4344          pendingQueue.next = baseFirst;
4345        }
4346        current.baseQueue = baseQueue = pendingQueue;
4347        queue2.pending = null;
4348      }
4349      pendingQueue = hook.baseState;
4350      if (null === baseQueue) hook.memoizedState = pendingQueue;
4351      else {
4352        current = baseQueue.next;
4353        var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current, didReadFromEntangledAsyncAction$60 = false;

vendor: 6,413 bytes, lines 4354-4478

4354        do {
4355          var updateLane = update.lane & -536870913;
4356          if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
4357            var revertLane = update.revertLane;
4358            if (0 === revertLane)
4359              null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
4360                lane: 0,
4361                revertLane: 0,
4362                gesture: null,
4363                action: update.action,
4364                hasEagerState: update.hasEagerState,
4365                eagerState: update.eagerState,
4366                next: null
4367              }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = true);
4368            else if ((renderLanes & revertLane) === revertLane) {
4369              update = update.next;
4370              revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = true);
4371              continue;
4372            } else
4373              updateLane = {
4374                lane: 0,
4375                revertLane: update.revertLane,
4376                gesture: null,
4377                action: update.action,
4378                hasEagerState: update.hasEagerState,
4379                eagerState: update.eagerState,
4380                next: null
4381              }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
4382            updateLane = update.action;
4383            shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
4384            pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
4385          } else
4386            revertLane = {
4387              lane: updateLane,
4388              revertLane: update.revertLane,
4389              gesture: update.gesture,
4390              action: update.action,
4391              hasEagerState: update.hasEagerState,
4392              eagerState: update.eagerState,
4393              next: null
4394            }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
4395          update = update.next;
4396        } while (null !== update && update !== current);
4397        null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
4398        if (!objectIs2(pendingQueue, hook.memoizedState) && (didReceiveUpdate = true, didReadFromEntangledAsyncAction$60 && (reducer = currentEntangledActionThenable, null !== reducer)))
4399          throw reducer;
4400        hook.memoizedState = pendingQueue;
4401        hook.baseState = baseFirst;
4402        hook.baseQueue = newBaseQueueLast;
4403        queue2.lastRenderedState = pendingQueue;
4404      }
4405      null === baseQueue && (queue2.lanes = 0);
4406      return [hook.memoizedState, queue2.dispatch];
4407    }
4408    function rerenderReducer(reducer) {
4409      var hook = updateWorkInProgressHook(), queue2 = hook.queue;
4410      if (null === queue2) throw Error(formatProdErrorMessage(311));
4411      queue2.lastRenderedReducer = reducer;
4412      var dispatch = queue2.dispatch, lastRenderPhaseUpdate = queue2.pending, newState = hook.memoizedState;
4413      if (null !== lastRenderPhaseUpdate) {
4414        queue2.pending = null;
4415        var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
4416        do
4417          newState = reducer(newState, update.action), update = update.next;
4418        while (update !== lastRenderPhaseUpdate);
4419        objectIs2(newState, hook.memoizedState) || (didReceiveUpdate = true);
4420        hook.memoizedState = newState;
4421        null === hook.baseQueue && (hook.baseState = newState);
4422        queue2.lastRenderedState = newState;
4423      }
4424      return [newState, dispatch];
4425    }
4426    function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
4427      var fiber = currentlyRenderingFiber, hook = updateWorkInProgressHook(), isHydrating$jscomp$0 = isHydrating;
4428      if (isHydrating$jscomp$0) {
4429        if (void 0 === getServerSnapshot) throw Error(formatProdErrorMessage(407));
4430        getServerSnapshot = getServerSnapshot();
4431      } else getServerSnapshot = getSnapshot();
4432      var snapshotChanged = !objectIs2(
4433        (currentHook || hook).memoizedState,
4434        getServerSnapshot
4435      );
4436      snapshotChanged && (hook.memoizedState = getServerSnapshot, didReceiveUpdate = true);
4437      hook = hook.queue;
4438      updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [
4439        subscribe
4440      ]);
4441      if (hook.getSnapshot !== getSnapshot || snapshotChanged || null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1) {
4442        fiber.flags |= 2048;
4443        pushSimpleEffect(
4444          9,
4445          { destroy: void 0 },
4446          updateStoreInstance.bind(
4447            null,
4448            fiber,
4449            hook,
4450            getServerSnapshot,
4451            getSnapshot
4452          ),
4453          null
4454        );
4455        if (null === workInProgressRoot) throw Error(formatProdErrorMessage(349));
4456        isHydrating$jscomp$0 || 0 !== (renderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
4457      }
4458      return getServerSnapshot;
4459    }
4460    function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
4461      fiber.flags |= 16384;
4462      fiber = { getSnapshot, value: renderedSnapshot };
4463      getSnapshot = currentlyRenderingFiber.updateQueue;
4464      null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
4465    }
4466    function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
4467      inst.value = nextSnapshot;
4468      inst.getSnapshot = getSnapshot;
4469      checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
4470    }
4471    function subscribeToStore(fiber, inst, subscribe) {
4472      return subscribe(function() {
4473        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
4474      });
4475    }
4476    function checkIfSnapshotChanged(inst) {
4477      var latestGetSnapshot = inst.getSnapshot;
4478      inst = inst.value;

vendor: 3,673 bytes, lines 4479-4568

4479      try {
4480        var nextValue = latestGetSnapshot();
4481        return !objectIs2(inst, nextValue);
4482      } catch (error) {
4483        return true;
4484      }
4485    }
4486    function forceStoreRerender(fiber) {
4487      var root2 = enqueueConcurrentRenderForLane(fiber, 2);
4488      null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2);
4489    }
4490    function mountStateImpl(initialState) {
4491      var hook = mountWorkInProgressHook();
4492      if ("function" === typeof initialState) {
4493        var initialStateInitializer = initialState;
4494        initialState = initialStateInitializer();
4495        if (shouldDoubleInvokeUserFnsInHooksDEV) {
4496          setIsStrictModeForDevtools(true);
4497          try {
4498            initialStateInitializer();
4499          } finally {
4500            setIsStrictModeForDevtools(false);
4501          }
4502        }
4503      }
4504      hook.memoizedState = hook.baseState = initialState;
4505      hook.queue = {
4506        pending: null,
4507        lanes: 0,
4508        dispatch: null,
4509        lastRenderedReducer: basicStateReducer,
4510        lastRenderedState: initialState
4511      };
4512      return hook;
4513    }
4514    function updateOptimisticImpl(hook, current, passthrough, reducer) {
4515      hook.baseState = passthrough;
4516      return updateReducerImpl(
4517        hook,
4518        currentHook,
4519        "function" === typeof reducer ? reducer : basicStateReducer
4520      );
4521    }
4522    function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
4523      if (isRenderPhaseUpdate(fiber)) throw Error(formatProdErrorMessage(485));
4524      fiber = actionQueue.action;
4525      if (null !== fiber) {
4526        var actionNode = {
4527          payload,
4528          action: fiber,
4529          next: null,
4530          isTransition: true,
4531          status: "pending",
4532          value: null,
4533          reason: null,
4534          listeners: [],
4535          then: function(listener) {
4536            actionNode.listeners.push(listener);
4537          }
4538        };
4539        null !== ReactSharedInternals.T ? setPendingState(true) : actionNode.isTransition = false;
4540        setState(actionNode);
4541        setPendingState = actionQueue.pending;
4542        null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
4543      }
4544    }
4545    function runActionStateAction(actionQueue, node2) {
4546      var action = node2.action, payload = node2.payload, prevState = actionQueue.state;
4547      if (node2.isTransition) {
4548        var prevTransition = ReactSharedInternals.T, currentTransition = {};
4549        ReactSharedInternals.T = currentTransition;
4550        try {
4551          var returnValue = action(prevState, payload), onStartTransitionFinish = ReactSharedInternals.S;
4552          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
4553          handleActionReturnValue(actionQueue, node2, returnValue);
4554        } catch (error) {
4555          onActionError(actionQueue, node2, error);
4556        } finally {
4557          null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
4558        }
4559      } else
4560        try {
4561          prevTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node2, prevTransition);
4562        } catch (error$66) {
4563          onActionError(actionQueue, node2, error$66);
4564        }
4565    }
4566    function handleActionReturnValue(actionQueue, node2, returnValue) {
4567      null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? returnValue.then(
4568        function(nextState) {

vendor: 3,223 bytes, lines 4569-4638

4569          onActionSuccess(actionQueue, node2, nextState);
4570        },
4571        function(error) {
4572          return onActionError(actionQueue, node2, error);
4573        }
4574      ) : onActionSuccess(actionQueue, node2, returnValue);
4575    }
4576    function onActionSuccess(actionQueue, actionNode, nextState) {
4577      actionNode.status = "fulfilled";
4578      actionNode.value = nextState;
4579      notifyActionListeners(actionNode);
4580      actionQueue.state = nextState;
4581      actionNode = actionQueue.pending;
4582      null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
4583    }
4584    function onActionError(actionQueue, actionNode, error) {
4585      var last = actionQueue.pending;
4586      actionQueue.pending = null;
4587      if (null !== last) {
4588        last = last.next;
4589        do
4590          actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next;
4591        while (actionNode !== last);
4592      }
4593      actionQueue.action = null;
4594    }
4595    function notifyActionListeners(actionNode) {
4596      actionNode = actionNode.listeners;
4597      for (var i2 = 0; i2 < actionNode.length; i2++) (0, actionNode[i2])();
4598    }
4599    function actionStateReducer(oldState, newState) {
4600      return newState;
4601    }
4602    function mountActionState(action, initialStateProp) {
4603      if (isHydrating) {
4604        var ssrFormState = workInProgressRoot.formState;
4605        if (null !== ssrFormState) {
4606          a: {
4607            var JSCompiler_inline_result = currentlyRenderingFiber;
4608            if (isHydrating) {
4609              if (nextHydratableInstance) {
4610                b: {
4611                  var JSCompiler_inline_result$jscomp$0 = nextHydratableInstance;
4612                  for (var inRootOrSingleton = rootOrSingletonContext; 8 !== JSCompiler_inline_result$jscomp$0.nodeType; ) {
4613                    if (!inRootOrSingleton) {
4614                      JSCompiler_inline_result$jscomp$0 = null;
4615                      break b;
4616                    }
4617                    JSCompiler_inline_result$jscomp$0 = getNextHydratable(
4618                      JSCompiler_inline_result$jscomp$0.nextSibling
4619                    );
4620                    if (null === JSCompiler_inline_result$jscomp$0) {
4621                      JSCompiler_inline_result$jscomp$0 = null;
4622                      break b;
4623                    }
4624                  }
4625                  inRootOrSingleton = JSCompiler_inline_result$jscomp$0.data;
4626                  JSCompiler_inline_result$jscomp$0 = "F!" === inRootOrSingleton || "F" === inRootOrSingleton ? JSCompiler_inline_result$jscomp$0 : null;
4627                }
4628                if (JSCompiler_inline_result$jscomp$0) {
4629                  nextHydratableInstance = getNextHydratable(
4630                    JSCompiler_inline_result$jscomp$0.nextSibling
4631                  );
4632                  JSCompiler_inline_result = "F!" === JSCompiler_inline_result$jscomp$0.data;
4633                  break a;
4634                }
4635              }
4636              throwOnHydrationMismatch(JSCompiler_inline_result);
4637            }
4638            JSCompiler_inline_result = false;

vendor: 9,291 bytes, lines 4639-4861

4639          }
4640          JSCompiler_inline_result && (initialStateProp = ssrFormState[0]);
4641        }
4642      }
4643      ssrFormState = mountWorkInProgressHook();
4644      ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;
4645      JSCompiler_inline_result = {
4646        pending: null,
4647        lanes: 0,
4648        dispatch: null,
4649        lastRenderedReducer: actionStateReducer,
4650        lastRenderedState: initialStateProp
4651      };
4652      ssrFormState.queue = JSCompiler_inline_result;
4653      ssrFormState = dispatchSetState.bind(
4654        null,
4655        currentlyRenderingFiber,
4656        JSCompiler_inline_result
4657      );
4658      JSCompiler_inline_result.dispatch = ssrFormState;
4659      JSCompiler_inline_result = mountStateImpl(false);
4660      inRootOrSingleton = dispatchOptimisticSetState.bind(
4661        null,
4662        currentlyRenderingFiber,
4663        false,
4664        JSCompiler_inline_result.queue
4665      );
4666      JSCompiler_inline_result = mountWorkInProgressHook();
4667      JSCompiler_inline_result$jscomp$0 = {
4668        state: initialStateProp,
4669        dispatch: null,
4670        action,
4671        pending: null
4672      };
4673      JSCompiler_inline_result.queue = JSCompiler_inline_result$jscomp$0;
4674      ssrFormState = dispatchActionState.bind(
4675        null,
4676        currentlyRenderingFiber,
4677        JSCompiler_inline_result$jscomp$0,
4678        inRootOrSingleton,
4679        ssrFormState
4680      );
4681      JSCompiler_inline_result$jscomp$0.dispatch = ssrFormState;
4682      JSCompiler_inline_result.memoizedState = action;
4683      return [initialStateProp, ssrFormState, false];
4684    }
4685    function updateActionState(action) {
4686      var stateHook = updateWorkInProgressHook();
4687      return updateActionStateImpl(stateHook, currentHook, action);
4688    }
4689    function updateActionStateImpl(stateHook, currentStateHook, action) {
4690      currentStateHook = updateReducerImpl(
4691        stateHook,
4692        currentStateHook,
4693        actionStateReducer
4694      )[0];
4695      stateHook = updateReducer(basicStateReducer)[0];
4696      if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then)
4697        try {
4698          var state2 = useThenable(currentStateHook);
4699        } catch (x) {
4700          if (x === SuspenseException) throw SuspenseActionException;
4701          throw x;
4702        }
4703      else state2 = currentStateHook;
4704      currentStateHook = updateWorkInProgressHook();
4705      var actionQueue = currentStateHook.queue, dispatch = actionQueue.dispatch;
4706      action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(
4707        9,
4708        { destroy: void 0 },
4709        actionStateActionEffect.bind(null, actionQueue, action),
4710        null
4711      ));
4712      return [state2, dispatch, stateHook];
4713    }
4714    function actionStateActionEffect(actionQueue, action) {
4715      actionQueue.action = action;
4716    }
4717    function rerenderActionState(action) {
4718      var stateHook = updateWorkInProgressHook(), currentStateHook = currentHook;
4719      if (null !== currentStateHook)
4720        return updateActionStateImpl(stateHook, currentStateHook, action);
4721      updateWorkInProgressHook();
4722      stateHook = stateHook.memoizedState;
4723      currentStateHook = updateWorkInProgressHook();
4724      var dispatch = currentStateHook.queue.dispatch;
4725      currentStateHook.memoizedState = action;
4726      return [stateHook, dispatch, false];
4727    }
4728    function pushSimpleEffect(tag, inst, create2, deps) {
4729      tag = { tag, create: create2, deps, inst, next: null };
4730      inst = currentlyRenderingFiber.updateQueue;
4731      null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
4732      create2 = inst.lastEffect;
4733      null === create2 ? inst.lastEffect = tag.next = tag : (deps = create2.next, create2.next = tag, tag.next = deps, inst.lastEffect = tag);
4734      return tag;
4735    }
4736    function updateRef() {
4737      return updateWorkInProgressHook().memoizedState;
4738    }
4739    function mountEffectImpl(fiberFlags, hookFlags, create2, deps) {
4740      var hook = mountWorkInProgressHook();
4741      currentlyRenderingFiber.flags |= fiberFlags;
4742      hook.memoizedState = pushSimpleEffect(
4743        1 | hookFlags,
4744        { destroy: void 0 },
4745        create2,
4746        void 0 === deps ? null : deps
4747      );
4748    }
4749    function updateEffectImpl(fiberFlags, hookFlags, create2, deps) {
4750      var hook = updateWorkInProgressHook();
4751      deps = void 0 === deps ? null : deps;
4752      var inst = hook.memoizedState.inst;
4753      null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create2, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(
4754        1 | hookFlags,
4755        inst,
4756        create2,
4757        deps
4758      ));
4759    }
4760    function mountEffect(create2, deps) {
4761      mountEffectImpl(8390656, 8, create2, deps);
4762    }
4763    function updateEffect(create2, deps) {
4764      updateEffectImpl(2048, 8, create2, deps);
4765    }
4766    function useEffectEventImpl(payload) {
4767      currentlyRenderingFiber.flags |= 4;
4768      var componentUpdateQueue = currentlyRenderingFiber.updateQueue;
4769      if (null === componentUpdateQueue)
4770        componentUpdateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = componentUpdateQueue, componentUpdateQueue.events = [payload];
4771      else {
4772        var events2 = componentUpdateQueue.events;
4773        null === events2 ? componentUpdateQueue.events = [payload] : events2.push(payload);
4774      }
4775    }
4776    function updateEvent(callback) {
4777      var ref2 = updateWorkInProgressHook().memoizedState;
4778      useEffectEventImpl({ ref: ref2, nextImpl: callback });
4779      return function() {
4780        if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
4781        return ref2.impl.apply(void 0, arguments);
4782      };
4783    }
4784    function updateInsertionEffect(create2, deps) {
4785      return updateEffectImpl(4, 2, create2, deps);
4786    }
4787    function updateLayoutEffect(create2, deps) {
4788      return updateEffectImpl(4, 4, create2, deps);
4789    }
4790    function imperativeHandleEffect(create2, ref2) {
4791      if ("function" === typeof ref2) {
4792        create2 = create2();
4793        var refCleanup = ref2(create2);
4794        return function() {
4795          "function" === typeof refCleanup ? refCleanup() : ref2(null);
4796        };
4797      }
4798      if (null !== ref2 && void 0 !== ref2)
4799        return create2 = create2(), ref2.current = create2, function() {
4800          ref2.current = null;
4801        };
4802    }
4803    function updateImperativeHandle(ref2, create2, deps) {
4804      deps = null !== deps && void 0 !== deps ? deps.concat([ref2]) : null;
4805      updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create2, ref2), deps);
4806    }
4807    function mountDebugValue() {
4808    }
4809    function updateCallback(callback, deps) {
4810      var hook = updateWorkInProgressHook();
4811      deps = void 0 === deps ? null : deps;
4812      var prevState = hook.memoizedState;
4813      if (null !== deps && areHookInputsEqual(deps, prevState[1]))
4814        return prevState[0];
4815      hook.memoizedState = [callback, deps];
4816      return callback;
4817    }
4818    function updateMemo(nextCreate, deps) {
4819      var hook = updateWorkInProgressHook();
4820      deps = void 0 === deps ? null : deps;
4821      var prevState = hook.memoizedState;
4822      if (null !== deps && areHookInputsEqual(deps, prevState[1]))
4823        return prevState[0];
4824      prevState = nextCreate();
4825      if (shouldDoubleInvokeUserFnsInHooksDEV) {
4826        setIsStrictModeForDevtools(true);
4827        try {
4828          nextCreate();
4829        } finally {
4830          setIsStrictModeForDevtools(false);
4831        }
4832      }
4833      hook.memoizedState = [prevState, deps];
4834      return prevState;
4835    }
4836    function mountDeferredValueImpl(hook, value, initialValue) {
4837      if (void 0 === initialValue || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
4838        return hook.memoizedState = value;
4839      hook.memoizedState = initialValue;
4840      hook = requestDeferredLane();
4841      currentlyRenderingFiber.lanes |= hook;
4842      workInProgressRootSkippedLanes |= hook;
4843      return initialValue;
4844    }
4845    function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
4846      if (objectIs2(value, prevValue)) return value;
4847      if (null !== currentTreeHiddenStackCursor.current)
4848        return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs2(hook, prevValue) || (didReceiveUpdate = true), hook;
4849      if (0 === (renderLanes & 42) || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
4850        return didReceiveUpdate = true, hook.memoizedState = value;
4851      hook = requestDeferredLane();
4852      currentlyRenderingFiber.lanes |= hook;
4853      workInProgressRootSkippedLanes |= hook;
4854      return prevValue;
4855    }
4856    function startTransition(fiber, queue2, pendingState, finishedState, callback) {
4857      var previousPriority = ReactDOMSharedInternals.p;
4858      ReactDOMSharedInternals.p = 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
4859      var prevTransition = ReactSharedInternals.T, currentTransition = {};
4860      ReactSharedInternals.T = currentTransition;
4861      dispatchOptimisticSetState(fiber, false, queue2, pendingState);

vendor: 4,475 bytes, lines 4862-4992

4862      try {
4863        var returnValue = callback(), onStartTransitionFinish = ReactSharedInternals.S;
4864        null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
4865        if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
4866          var thenableForFinishedState = chainThenableValue(
4867            returnValue,
4868            finishedState
4869          );
4870          dispatchSetStateInternal(
4871            fiber,
4872            queue2,
4873            thenableForFinishedState,
4874            requestUpdateLane(fiber)
4875          );
4876        } else
4877          dispatchSetStateInternal(
4878            fiber,
4879            queue2,
4880            finishedState,
4881            requestUpdateLane(fiber)
4882          );
4883      } catch (error) {
4884        dispatchSetStateInternal(
4885          fiber,
4886          queue2,
4887          { then: function() {
4888          }, status: "rejected", reason: error },
4889          requestUpdateLane()
4890        );
4891      } finally {
4892        ReactDOMSharedInternals.p = previousPriority, null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
4893      }
4894    }
4895    function noop2() {
4896    }
4897    function startHostTransition(formFiber, pendingState, action, formData) {
4898      if (5 !== formFiber.tag) throw Error(formatProdErrorMessage(476));
4899      var queue2 = ensureFormComponentIsStateful(formFiber).queue;
4900      startTransition(
4901        formFiber,
4902        queue2,
4903        pendingState,
4904        sharedNotPendingObject,
4905        null === action ? noop2 : function() {
4906          requestFormReset$1(formFiber);
4907          return action(formData);
4908        }
4909      );
4910    }
4911    function ensureFormComponentIsStateful(formFiber) {
4912      var existingStateHook = formFiber.memoizedState;
4913      if (null !== existingStateHook) return existingStateHook;
4914      existingStateHook = {
4915        memoizedState: sharedNotPendingObject,
4916        baseState: sharedNotPendingObject,
4917        baseQueue: null,
4918        queue: {
4919          pending: null,
4920          lanes: 0,
4921          dispatch: null,
4922          lastRenderedReducer: basicStateReducer,
4923          lastRenderedState: sharedNotPendingObject
4924        },
4925        next: null
4926      };
4927      var initialResetState = {};
4928      existingStateHook.next = {
4929        memoizedState: initialResetState,
4930        baseState: initialResetState,
4931        baseQueue: null,
4932        queue: {
4933          pending: null,
4934          lanes: 0,
4935          dispatch: null,
4936          lastRenderedReducer: basicStateReducer,
4937          lastRenderedState: initialResetState
4938        },
4939        next: null
4940      };
4941      formFiber.memoizedState = existingStateHook;
4942      formFiber = formFiber.alternate;
4943      null !== formFiber && (formFiber.memoizedState = existingStateHook);
4944      return existingStateHook;
4945    }
4946    function requestFormReset$1(formFiber) {
4947      var stateHook = ensureFormComponentIsStateful(formFiber);
4948      null === stateHook.next && (stateHook = formFiber.alternate.memoizedState);
4949      dispatchSetStateInternal(
4950        formFiber,
4951        stateHook.next.queue,
4952        {},
4953        requestUpdateLane()
4954      );
4955    }
4956    function useHostTransitionStatus() {
4957      return readContext(HostTransitionContext);
4958    }
4959    function updateId() {
4960      return updateWorkInProgressHook().memoizedState;
4961    }
4962    function updateRefresh() {
4963      return updateWorkInProgressHook().memoizedState;
4964    }
4965    function refreshCache(fiber) {
4966      for (var provider = fiber.return; null !== provider; ) {
4967        switch (provider.tag) {
4968          case 24:
4969          case 3:
4970            var lane = requestUpdateLane();
4971            fiber = createUpdate(lane);
4972            var root$69 = enqueueUpdate(provider, fiber, lane);
4973            null !== root$69 && (scheduleUpdateOnFiber(root$69, provider, lane), entangleTransitions(root$69, provider, lane));
4974            provider = { cache: createCache() };
4975            fiber.payload = provider;
4976            return;
4977        }
4978        provider = provider.return;
4979      }
4980    }
4981    function dispatchReducerAction(fiber, queue2, action) {
4982      var lane = requestUpdateLane();
4983      action = {
4984        lane,
4985        revertLane: 0,
4986        gesture: null,
4987        action,
4988        hasEagerState: false,
4989        eagerState: null,
4990        next: null
4991      };
4992      isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue2, action) : (action = enqueueConcurrentHookUp

vendor: 6,327 bytes, lines 4992-5162

4992date(fiber, queue2, action, lane), null !== action && (scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue2, lane)));
4993    }
4994    function dispatchSetState(fiber, queue2, action) {
4995      var lane = requestUpdateLane();
4996      dispatchSetStateInternal(fiber, queue2, action, lane);
4997    }
4998    function dispatchSetStateInternal(fiber, queue2, action, lane) {
4999      var update = {
5000        lane,
5001        revertLane: 0,
5002        gesture: null,
5003        action,
5004        hasEagerState: false,
5005        eagerState: null,
5006        next: null
5007      };
5008      if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue2, update);
5009      else {
5010        var alternate = fiber.alternate;
5011        if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue2.lastRenderedReducer, null !== alternate))
5012          try {
5013            var currentState = queue2.lastRenderedState, eagerState = alternate(currentState, action);
5014            update.hasEagerState = true;
5015            update.eagerState = eagerState;
5016            if (objectIs2(eagerState, currentState))
5017              return enqueueUpdate$1(fiber, queue2, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), false;
5018          } catch (error) {
5019          } finally {
5020          }
5021        action = enqueueConcurrentHookUpdate(fiber, queue2, update, lane);
5022        if (null !== action)
5023          return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue2, lane), true;
5024      }
5025      return false;
5026    }
5027    function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue2, action) {
5028      action = {
5029        lane: 2,
5030        revertLane: requestTransitionLane(),
5031        gesture: null,
5032        action,
5033        hasEagerState: false,
5034        eagerState: null,
5035        next: null
5036      };
5037      if (isRenderPhaseUpdate(fiber)) {
5038        if (throwIfDuringRender) throw Error(formatProdErrorMessage(479));
5039      } else
5040        throwIfDuringRender = enqueueConcurrentHookUpdate(
5041          fiber,
5042          queue2,
5043          action,
5044          2
5045        ), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
5046    }
5047    function isRenderPhaseUpdate(fiber) {
5048      var alternate = fiber.alternate;
5049      return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
5050    }
5051    function enqueueRenderPhaseUpdate(queue2, update) {
5052      didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
5053      var pending = queue2.pending;
5054      null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
5055      queue2.pending = update;
5056    }
5057    function entangleTransitionUpdate(root2, queue2, lane) {
5058      if (0 !== (lane & 4194048)) {
5059        var queueLanes = queue2.lanes;
5060        queueLanes &= root2.pendingLanes;
5061        lane |= queueLanes;
5062        queue2.lanes = lane;
5063        markRootEntangled(root2, lane);
5064      }
5065    }
5066    var ContextOnlyDispatcher = {
5067      readContext,
5068      use,
5069      useCallback: throwInvalidHookError,
5070      useContext: throwInvalidHookError,
5071      useEffect: throwInvalidHookError,
5072      useImperativeHandle: throwInvalidHookError,
5073      useLayoutEffect: throwInvalidHookError,
5074      useInsertionEffect: throwInvalidHookError,
5075      useMemo: throwInvalidHookError,
5076      useReducer: throwInvalidHookError,
5077      useRef: throwInvalidHookError,
5078      useState: throwInvalidHookError,
5079      useDebugValue: throwInvalidHookError,
5080      useDeferredValue: throwInvalidHookError,
5081      useTransition: throwInvalidHookError,
5082      useSyncExternalStore: throwInvalidHookError,
5083      useId: throwInvalidHookError,
5084      useHostTransitionStatus: throwInvalidHookError,
5085      useFormState: throwInvalidHookError,
5086      useActionState: throwInvalidHookError,
5087      useOptimistic: throwInvalidHookError,
5088      useMemoCache: throwInvalidHookError,
5089      useCacheRefresh: throwInvalidHookError
5090    };
5091    ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
5092    var HooksDispatcherOnMount = {
5093      readContext,
5094      use,
5095      useCallback: function(callback, deps) {
5096        mountWorkInProgressHook().memoizedState = [
5097          callback,
5098          void 0 === deps ? null : deps
5099        ];
5100        return callback;
5101      },
5102      useContext: readContext,
5103      useEffect: mountEffect,
5104      useImperativeHandle: function(ref2, create2, deps) {
5105        deps = null !== deps && void 0 !== deps ? deps.concat([ref2]) : null;
5106        mountEffectImpl(
5107          4194308,
5108          4,
5109          imperativeHandleEffect.bind(null, create2, ref2),
5110          deps
5111        );
5112      },
5113      useLayoutEffect: function(create2, deps) {
5114        return mountEffectImpl(4194308, 4, create2, deps);
5115      },
5116      useInsertionEffect: function(create2, deps) {
5117        mountEffectImpl(4, 2, create2, deps);
5118      },
5119      useMemo: function(nextCreate, deps) {
5120        var hook = mountWorkInProgressHook();
5121        deps = void 0 === deps ? null : deps;
5122        var nextValue = nextCreate();
5123        if (shouldDoubleInvokeUserFnsInHooksDEV) {
5124          setIsStrictModeForDevtools(true);
5125          try {
5126            nextCreate();
5127          } finally {
5128            setIsStrictModeForDevtools(false);
5129          }
5130        }
5131        hook.memoizedState = [nextValue, deps];
5132        return nextValue;
5133      },
5134      useReducer: function(reducer, initialArg, init) {
5135        var hook = mountWorkInProgressHook();
5136        if (void 0 !== init) {
5137          var initialState = init(initialArg);
5138          if (shouldDoubleInvokeUserFnsInHooksDEV) {
5139            setIsStrictModeForDevtools(true);
5140            try {
5141              init(initialArg);
5142            } finally {
5143              setIsStrictModeForDevtools(false);
5144            }
5145          }
5146        } else initialState = initialArg;
5147        hook.memoizedState = hook.baseState = initialState;
5148        reducer = {
5149          pending: null,
5150          lanes: 0,
5151          dispatch: null,
5152          lastRenderedReducer: reducer,
5153          lastRenderedState: initialState
5154        };
5155        hook.queue = reducer;
5156        reducer = reducer.dispatch = dispatchReducerAction.bind(
5157          null,
5158          currentlyRenderingFiber,
5159          reducer
5160        );
5161        return [hook.memoizedState, reducer];
5162      },

vendor: 4,793 bytes, lines 5163-5287

5163      useRef: function(initialValue) {
5164        var hook = mountWorkInProgressHook();
5165        initialValue = { current: initialValue };
5166        return hook.memoizedState = initialValue;
5167      },
5168      useState: function(initialState) {
5169        initialState = mountStateImpl(initialState);
5170        var queue2 = initialState.queue, dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue2);
5171        queue2.dispatch = dispatch;
5172        return [initialState.memoizedState, dispatch];
5173      },
5174      useDebugValue: mountDebugValue,
5175      useDeferredValue: function(value, initialValue) {
5176        var hook = mountWorkInProgressHook();
5177        return mountDeferredValueImpl(hook, value, initialValue);
5178      },
5179      useTransition: function() {
5180        var stateHook = mountStateImpl(false);
5181        stateHook = startTransition.bind(
5182          null,
5183          currentlyRenderingFiber,
5184          stateHook.queue,
5185          true,
5186          false
5187        );
5188        mountWorkInProgressHook().memoizedState = stateHook;
5189        return [false, stateHook];
5190      },
5191      useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
5192        var fiber = currentlyRenderingFiber, hook = mountWorkInProgressHook();
5193        if (isHydrating) {
5194          if (void 0 === getServerSnapshot)
5195            throw Error(formatProdErrorMessage(407));
5196          getServerSnapshot = getServerSnapshot();
5197        } else {
5198          getServerSnapshot = getSnapshot();
5199          if (null === workInProgressRoot)
5200            throw Error(formatProdErrorMessage(349));
5201          0 !== (workInProgressRootRenderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
5202        }
5203        hook.memoizedState = getServerSnapshot;
5204        var inst = { value: getServerSnapshot, getSnapshot };
5205        hook.queue = inst;
5206        mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [
5207          subscribe
5208        ]);
5209        fiber.flags |= 2048;
5210        pushSimpleEffect(
5211          9,
5212          { destroy: void 0 },
5213          updateStoreInstance.bind(
5214            null,
5215            fiber,
5216            inst,
5217            getServerSnapshot,
5218            getSnapshot
5219          ),
5220          null
5221        );
5222        return getServerSnapshot;
5223      },
5224      useId: function() {
5225        var hook = mountWorkInProgressHook(), identifierPrefix = workInProgressRoot.identifierPrefix;
5226        if (isHydrating) {
5227          var JSCompiler_inline_result = treeContextOverflow;
5228          var idWithLeadingBit = treeContextId;
5229          JSCompiler_inline_result = (idWithLeadingBit & ~(1 << 32 - clz32(idWithLeadingBit) - 1)).toString(32) + JSCompiler_inline_result;
5230          identifierPrefix = "_" + identifierPrefix + "R_" + JSCompiler_inline_result;
5231          JSCompiler_inline_result = localIdCounter++;
5232          0 < JSCompiler_inline_result && (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
5233          identifierPrefix += "_";
5234        } else
5235          JSCompiler_inline_result = globalClientIdCounter++, identifierPrefix = "_" + identifierPrefix + "r_" + JSCompiler_inline_result.toString(32) + "_";
5236        return hook.memoizedState = identifierPrefix;
5237      },
5238      useHostTransitionStatus,
5239      useFormState: mountActionState,
5240      useActionState: mountActionState,
5241      useOptimistic: function(passthrough) {
5242        var hook = mountWorkInProgressHook();
5243        hook.memoizedState = hook.baseState = passthrough;
5244        var queue2 = {
5245          pending: null,
5246          lanes: 0,
5247          dispatch: null,
5248          lastRenderedReducer: null,
5249          lastRenderedState: null
5250        };
5251        hook.queue = queue2;
5252        hook = dispatchOptimisticSetState.bind(
5253          null,
5254          currentlyRenderingFiber,
5255          true,
5256          queue2
5257        );
5258        queue2.dispatch = hook;
5259        return [passthrough, hook];
5260      },
5261      useMemoCache,
5262      useCacheRefresh: function() {
5263        return mountWorkInProgressHook().memoizedState = refreshCache.bind(
5264          null,
5265          currentlyRenderingFiber
5266        );
5267      },
5268      useEffectEvent: function(callback) {
5269        var hook = mountWorkInProgressHook(), ref2 = { impl: callback };
5270        hook.memoizedState = ref2;
5271        return function() {
5272          if (0 !== (executionContext & 2))
5273            throw Error(formatProdErrorMessage(440));
5274          return ref2.impl.apply(void 0, arguments);
5275        };
5276      }
5277    }, HooksDispatcherOnUpdate = {
5278      readContext,
5279      use,
5280      useCallback: updateCallback,
5281      useContext: readContext,
5282      useEffect: updateEffect,
5283      useImperativeHandle: updateImperativeHandle,
5284      useInsertionEffect: updateInsertionEffect,
5285      useLayoutEffect: updateLayoutEffect,
5286      useMemo: updateMemo,
5287      useReducer: updateReducer,

vendor: 5,975 bytes, lines 5288-5413

5288      useRef: updateRef,
5289      useState: function() {
5290        return updateReducer(basicStateReducer);
5291      },
5292      useDebugValue: mountDebugValue,
5293      useDeferredValue: function(value, initialValue) {
5294        var hook = updateWorkInProgressHook();
5295        return updateDeferredValueImpl(
5296          hook,
5297          currentHook.memoizedState,
5298          value,
5299          initialValue
5300        );
5301      },
5302      useTransition: function() {
5303        var booleanOrThenable = updateReducer(basicStateReducer)[0], start = updateWorkInProgressHook().memoizedState;
5304        return [
5305          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
5306          start
5307        ];
5308      },
5309      useSyncExternalStore: updateSyncExternalStore,
5310      useId: updateId,
5311      useHostTransitionStatus,
5312      useFormState: updateActionState,
5313      useActionState: updateActionState,
5314      useOptimistic: function(passthrough, reducer) {
5315        var hook = updateWorkInProgressHook();
5316        return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
5317      },
5318      useMemoCache,
5319      useCacheRefresh: updateRefresh
5320    };
5321    HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
5322    var HooksDispatcherOnRerender = {
5323      readContext,
5324      use,
5325      useCallback: updateCallback,
5326      useContext: readContext,
5327      useEffect: updateEffect,
5328      useImperativeHandle: updateImperativeHandle,
5329      useInsertionEffect: updateInsertionEffect,
5330      useLayoutEffect: updateLayoutEffect,
5331      useMemo: updateMemo,
5332      useReducer: rerenderReducer,
5333      useRef: updateRef,
5334      useState: function() {
5335        return rerenderReducer(basicStateReducer);
5336      },
5337      useDebugValue: mountDebugValue,
5338      useDeferredValue: function(value, initialValue) {
5339        var hook = updateWorkInProgressHook();
5340        return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(
5341          hook,
5342          currentHook.memoizedState,
5343          value,
5344          initialValue
5345        );
5346      },
5347      useTransition: function() {
5348        var booleanOrThenable = rerenderReducer(basicStateReducer)[0], start = updateWorkInProgressHook().memoizedState;
5349        return [
5350          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
5351          start
5352        ];
5353      },
5354      useSyncExternalStore: updateSyncExternalStore,
5355      useId: updateId,
5356      useHostTransitionStatus,
5357      useFormState: rerenderActionState,
5358      useActionState: rerenderActionState,
5359      useOptimistic: function(passthrough, reducer) {
5360        var hook = updateWorkInProgressHook();
5361        if (null !== currentHook)
5362          return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
5363        hook.baseState = passthrough;
5364        return [passthrough, hook.queue.dispatch];
5365      },
5366      useMemoCache,
5367      useCacheRefresh: updateRefresh
5368    };
5369    HooksDispatcherOnRerender.useEffectEvent = updateEvent;
5370    function applyDerivedStateFromProps(workInProgress2, ctor, getDerivedStateFromProps, nextProps) {
5371      ctor = workInProgress2.memoizedState;
5372      getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
5373      getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : assign({}, ctor, getDerivedStateFromProps);
5374      workInProgress2.memoizedState = getDerivedStateFromProps;
5375      0 === workInProgress2.lanes && (workInProgress2.updateQueue.baseState = getDerivedStateFromProps);
5376    }
5377    var classComponentUpdater = {
5378      enqueueSetState: function(inst, payload, callback) {
5379        inst = inst._reactInternals;
5380        var lane = requestUpdateLane(), update = createUpdate(lane);
5381        update.payload = payload;
5382        void 0 !== callback && null !== callback && (update.callback = callback);
5383        payload = enqueueUpdate(inst, update, lane);
5384        null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
5385      },
5386      enqueueReplaceState: function(inst, payload, callback) {
5387        inst = inst._reactInternals;
5388        var lane = requestUpdateLane(), update = createUpdate(lane);
5389        update.tag = 1;
5390        update.payload = payload;
5391        void 0 !== callback && null !== callback && (update.callback = callback);
5392        payload = enqueueUpdate(inst, update, lane);
5393        null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
5394      },
5395      enqueueForceUpdate: function(inst, callback) {
5396        inst = inst._reactInternals;
5397        var lane = requestUpdateLane(), update = createUpdate(lane);
5398        update.tag = 2;
5399        void 0 !== callback && null !== callback && (update.callback = callback);
5400        callback = enqueueUpdate(inst, update, lane);
5401        null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
5402      }
5403    };
5404    function checkShouldComponentUpdate(workInProgress2, ctor, oldProps, newProps, oldState, newState, nextContext) {
5405      workInProgress2 = workInProgress2.stateNode;
5406      return "function" === typeof workInProgress2.shouldComponentUpdate ? workInProgress2.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : true;
5407    }
5408    function callComponentWillReceiveProps(workInProgress2, instance, newProps, nextContext) {
5409      workInProgress2 = instance.state;
5410      "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
5411      "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
5412      instance.state !== workInProgress2 && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
5413    }

vendor: 4,685 bytes, lines 5414-5516

5414    function resolveClassComponentProps(Component, baseProps) {
5415      var newProps = baseProps;
5416      if ("ref" in baseProps) {
5417        newProps = {};
5418        for (var propName in baseProps)
5419          "ref" !== propName && (newProps[propName] = baseProps[propName]);
5420      }
5421      if (Component = Component.defaultProps) {
5422        newProps === baseProps && (newProps = assign({}, newProps));
5423        for (var propName$73 in Component)
5424          void 0 === newProps[propName$73] && (newProps[propName$73] = Component[propName$73]);
5425      }
5426      return newProps;
5427    }
5428    function defaultOnUncaughtError(error) {
5429      reportGlobalError(error);
5430    }
5431    function defaultOnCaughtError(error) {
5432      console.error(error);
5433    }
5434    function defaultOnRecoverableError(error) {
5435      reportGlobalError(error);
5436    }
5437    function logUncaughtError(root2, errorInfo) {
5438      try {
5439        var onUncaughtError = root2.onUncaughtError;
5440        onUncaughtError(errorInfo.value, { componentStack: errorInfo.stack });
5441      } catch (e$74) {
5442        setTimeout(function() {
5443          throw e$74;
5444        });
5445      }
5446    }
5447    function logCaughtError(root2, boundary, errorInfo) {
5448      try {
5449        var onCaughtError = root2.onCaughtError;
5450        onCaughtError(errorInfo.value, {
5451          componentStack: errorInfo.stack,
5452          errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
5453        });
5454      } catch (e$75) {
5455        setTimeout(function() {
5456          throw e$75;
5457        });
5458      }
5459    }
5460    function createRootErrorUpdate(root2, errorInfo, lane) {
5461      lane = createUpdate(lane);
5462      lane.tag = 3;
5463      lane.payload = { element: null };
5464      lane.callback = function() {
5465        logUncaughtError(root2, errorInfo);
5466      };
5467      return lane;
5468    }
5469    function createClassErrorUpdate(lane) {
5470      lane = createUpdate(lane);
5471      lane.tag = 3;
5472      return lane;
5473    }
5474    function initializeClassErrorUpdate(update, root2, fiber, errorInfo) {
5475      var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
5476      if ("function" === typeof getDerivedStateFromError) {
5477        var error = errorInfo.value;
5478        update.payload = function() {
5479          return getDerivedStateFromError(error);
5480        };
5481        update.callback = function() {
5482          logCaughtError(root2, fiber, errorInfo);
5483        };
5484      }
5485      var inst = fiber.stateNode;
5486      null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function() {
5487        logCaughtError(root2, fiber, errorInfo);
5488        "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = /* @__PURE__ */ new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
5489        var stack = errorInfo.stack;
5490        this.componentDidCatch(errorInfo.value, {
5491          componentStack: null !== stack ? stack : ""
5492        });
5493      });
5494    }
5495    function throwException(root2, returnFiber, sourceFiber, value, rootRenderLanes) {
5496      sourceFiber.flags |= 32768;
5497      if (null !== value && "object" === typeof value && "function" === typeof value.then) {
5498        returnFiber = sourceFiber.alternate;
5499        null !== returnFiber && propagateParentContextChanges(
5500          returnFiber,
5501          sourceFiber,
5502          rootRenderLanes,
5503          true
5504        );
5505        sourceFiber = suspenseHandlerStackCursor.current;
5506        if (null !== sourceFiber) {
5507          switch (sourceFiber.tag) {
5508            case 31:
5509            case 13:
5510              return null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === sourceFiber.alternate && 0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 3), sourceFiber.flags &= -257, sourceFiber.flags |= 65536, sourceFiber.lanes = rootRenderLanes, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? sourceFiber.updateQueue = /* @__PURE__ */ new Set([value]) : returnFiber.add(value), attachPingListener(root2, value, rootRenderLanes)), false;
5511            case 22:
5512              return sourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
5513                transitions: null,
5514                markerInstances: null,
5515                retryQueue: /* @__PURE__ */ new Set([value])
5516              }, sourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = /* @__PURE__ */ new Set([value]) : sourceFiber.add(value)), attachPingListener(root2, value, rootRen

vendor: 10,621 bytes, lines 5516-5718

5516derLanes)), false;
5517          }
5518          throw Error(formatProdErrorMessage(435, sourceFiber.tag));
5519        }
5520        attachPingListener(root2, value, rootRenderLanes);
5521        renderDidSuspendDelayIfPossible();
5522        return false;
5523      }
5524      if (isHydrating)
5525        return returnFiber = suspenseHandlerStackCursor.current, null !== returnFiber ? (0 === (returnFiber.flags & 65536) && (returnFiber.flags |= 256), returnFiber.flags |= 65536, returnFiber.lanes = rootRenderLanes, value !== HydrationMismatchException && (root2 = Error(formatProdErrorMessage(422), { cause: value }), queueHydrationError(createCapturedValueAtFiber(root2, sourceFiber)))) : (value !== HydrationMismatchException && (returnFiber = Error(formatProdErrorMessage(423), {
5526          cause: value
5527        }), queueHydrationError(
5528          createCapturedValueAtFiber(returnFiber, sourceFiber)
5529        )), root2 = root2.current.alternate, root2.flags |= 65536, rootRenderLanes &= -rootRenderLanes, root2.lanes |= rootRenderLanes, value = createCapturedValueAtFiber(value, sourceFiber), rootRenderLanes = createRootErrorUpdate(
5530          root2.stateNode,
5531          value,
5532          rootRenderLanes
5533        ), enqueueCapturedUpdate(root2, rootRenderLanes), 4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2)), false;
5534      var wrapperError = Error(formatProdErrorMessage(520), { cause: value });
5535      wrapperError = createCapturedValueAtFiber(wrapperError, sourceFiber);
5536      null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [wrapperError] : workInProgressRootConcurrentErrors.push(wrapperError);
5537      4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2);
5538      if (null === returnFiber) return true;
5539      value = createCapturedValueAtFiber(value, sourceFiber);
5540      sourceFiber = returnFiber;
5541      do {
5542        switch (sourceFiber.tag) {
5543          case 3:
5544            return sourceFiber.flags |= 65536, root2 = rootRenderLanes & -rootRenderLanes, sourceFiber.lanes |= root2, root2 = createRootErrorUpdate(sourceFiber.stateNode, value, root2), enqueueCapturedUpdate(sourceFiber, root2), false;
5545          case 1:
5546            if (returnFiber = sourceFiber.type, wrapperError = sourceFiber.stateNode, 0 === (sourceFiber.flags & 128) && ("function" === typeof returnFiber.getDerivedStateFromError || null !== wrapperError && "function" === typeof wrapperError.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(wrapperError))))
5547              return sourceFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, sourceFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(
5548                rootRenderLanes,
5549                root2,
5550                sourceFiber,
5551                value
5552              ), enqueueCapturedUpdate(sourceFiber, rootRenderLanes), false;
5553        }
5554        sourceFiber = sourceFiber.return;
5555      } while (null !== sourceFiber);
5556      return false;
5557    }
5558    var SelectiveHydrationException = Error(formatProdErrorMessage(461)), didReceiveUpdate = false;
5559    function reconcileChildren(current, workInProgress2, nextChildren, renderLanes2) {
5560      workInProgress2.child = null === current ? mountChildFibers(workInProgress2, null, nextChildren, renderLanes2) : reconcileChildFibers(
5561        workInProgress2,
5562        current.child,
5563        nextChildren,
5564        renderLanes2
5565      );
5566    }
5567    function updateForwardRef(current, workInProgress2, Component, nextProps, renderLanes2) {
5568      Component = Component.render;
5569      var ref2 = workInProgress2.ref;
5570      if ("ref" in nextProps) {
5571        var propsWithoutRef = {};
5572        for (var key2 in nextProps)
5573          "ref" !== key2 && (propsWithoutRef[key2] = nextProps[key2]);
5574      } else propsWithoutRef = nextProps;
5575      prepareToReadContext(workInProgress2);
5576      nextProps = renderWithHooks(
5577        current,
5578        workInProgress2,
5579        Component,
5580        propsWithoutRef,
5581        ref2,
5582        renderLanes2
5583      );
5584      key2 = checkDidRenderIdHook();
5585      if (null !== current && !didReceiveUpdate)
5586        return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
5587      isHydrating && key2 && pushMaterializedTreeId(workInProgress2);
5588      workInProgress2.flags |= 1;
5589      reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
5590      return workInProgress2.child;
5591    }
5592    function updateMemoComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
5593      if (null === current) {
5594        var type2 = Component.type;
5595        if ("function" === typeof type2 && !shouldConstruct(type2) && void 0 === type2.defaultProps && null === Component.compare)
5596          return workInProgress2.tag = 15, workInProgress2.type = type2, updateSimpleMemoComponent(
5597            current,
5598            workInProgress2,
5599            type2,
5600            nextProps,
5601            renderLanes2
5602          );
5603        current = createFiberFromTypeAndProps(
5604          Component.type,
5605          null,
5606          nextProps,
5607          workInProgress2,
5608          workInProgress2.mode,
5609          renderLanes2
5610        );
5611        current.ref = workInProgress2.ref;
5612        current.return = workInProgress2;
5613        return workInProgress2.child = current;
5614      }
5615      type2 = current.child;
5616      if (!checkScheduledUpdateOrContext(current, renderLanes2)) {
5617        var prevProps = type2.memoizedProps;
5618        Component = Component.compare;
5619        Component = null !== Component ? Component : shallowEqual;
5620        if (Component(prevProps, nextProps) && current.ref === workInProgress2.ref)
5621          return bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
5622      }
5623      workInProgress2.flags |= 1;
5624      current = createWorkInProgress(type2, nextProps);
5625      current.ref = workInProgress2.ref;
5626      current.return = workInProgress2;
5627      return workInProgress2.child = current;
5628    }
5629    function updateSimpleMemoComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
5630      if (null !== current) {
5631        var prevProps = current.memoizedProps;
5632        if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress2.ref)
5633          if (didReceiveUpdate = false, workInProgress2.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes2))
5634            0 !== (current.flags & 131072) && (didReceiveUpdate = true);
5635          else
5636            return workInProgress2.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
5637      }
5638      return updateFunctionComponent(
5639        current,
5640        workInProgress2,
5641        Component,
5642        nextProps,
5643        renderLanes2
5644      );
5645    }
5646    function updateOffscreenComponent(current, workInProgress2, renderLanes2, nextProps) {
5647      var nextChildren = nextProps.children, prevState = null !== current ? current.memoizedState : null;
5648      null === current && null === workInProgress2.stateNode && (workInProgress2.stateNode = {
5649        _visibility: 1,
5650        _pendingMarkers: null,
5651        _retryCache: null,
5652        _transitions: null
5653      });
5654      if ("hidden" === nextProps.mode) {
5655        if (0 !== (workInProgress2.flags & 128)) {
5656          prevState = null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2;
5657          if (null !== current) {
5658            nextProps = workInProgress2.child = current.child;
5659            for (nextChildren = 0; null !== nextProps; )
5660              nextChildren = nextChildren | nextProps.lanes | nextProps.childLanes, nextProps = nextProps.sibling;
5661            nextProps = nextChildren & ~prevState;
5662          } else nextProps = 0, workInProgress2.child = null;
5663          return deferHiddenOffscreenComponent(
5664            current,
5665            workInProgress2,
5666            prevState,
5667            renderLanes2,
5668            nextProps
5669          );
5670        }
5671        if (0 !== (renderLanes2 & 536870912))
5672          workInProgress2.memoizedState = { baseLanes: 0, cachePool: null }, null !== current && pushTransition(
5673            workInProgress2,
5674            null !== prevState ? prevState.cachePool : null
5675          ), null !== prevState ? pushHiddenContext(workInProgress2, prevState) : reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress2);
5676        else
5677          return nextProps = workInProgress2.lanes = 536870912, deferHiddenOffscreenComponent(
5678            current,
5679            workInProgress2,
5680            null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2,
5681            renderLanes2,
5682            nextProps
5683          );
5684      } else
5685        null !== prevState ? (pushTransition(workInProgress2, prevState.cachePool), pushHiddenContext(workInProgress2, prevState), reuseSuspenseHandlerOnStack(), workInProgress2.memoizedState = null) : (null !== current && pushTransition(workInProgress2, null), reuseHiddenContextOnStack(), reuseSuspenseHandlerOnStack());
5686      reconcileChildren(current, workInProgress2, nextChildren, renderLanes2);
5687      return workInProgress2.child;
5688    }
5689    function bailoutOffscreenComponent(current, workInProgress2) {
5690      null !== current && 22 === current.tag || null !== workInProgress2.stateNode || (workInProgress2.stateNode = {
5691        _visibility: 1,
5692        _pendingMarkers: null,
5693        _retryCache: null,
5694        _transitions: null
5695      });
5696      return workInProgress2.sibling;
5697    }
5698    function deferHiddenOffscreenComponent(current, workInProgress2, nextBaseLanes, renderLanes2, remainingChildLanes) {
5699      var JSCompiler_inline_result = peekCacheFromPool();
5700      JSCompiler_inline_result = null === JSCompiler_inline_result ? null : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
5701      workInProgress2.memoizedState = {
5702        baseLanes: nextBaseLanes,
5703        cachePool: JSCompiler_inline_result
5704      };
5705      null !== current && pushTransition(workInProgress2, null);
5706      reuseHiddenContextOnStack();
5707      pushOffscreenSuspenseHandler(workInProgress2);
5708      null !== current && propagateParentContextChanges(current, workInProgress2, renderLanes2, true);
5709      workInProgress2.childLanes = remainingChildLanes;
5710      return null;
5711    }
5712    function mountActivityChildren(workInProgress2, nextProps) {
5713      nextProps = mountWorkInProgressOffscreenFiber(
5714        { mode: nextProps.mode, children: nextProps.children },
5715        workInProgress2.mode
5716      );
5717      nextProps.ref = workInProgress2.ref;
5718      workInProgress2.child = nextProps;

vendor: 8,633 bytes, lines 5719-5867

5719      nextProps.return = workInProgress2;
5720      return nextProps;
5721    }
5722    function retryActivityComponentWithoutHydrating(current, workInProgress2, renderLanes2) {
5723      reconcileChildFibers(workInProgress2, current.child, null, renderLanes2);
5724      current = mountActivityChildren(workInProgress2, workInProgress2.pendingProps);
5725      current.flags |= 2;
5726      popSuspenseHandler(workInProgress2);
5727      workInProgress2.memoizedState = null;
5728      return current;
5729    }
5730    function updateActivityComponent(current, workInProgress2, renderLanes2) {
5731      var nextProps = workInProgress2.pendingProps, didSuspend = 0 !== (workInProgress2.flags & 128);
5732      workInProgress2.flags &= -129;
5733      if (null === current) {
5734        if (isHydrating) {
5735          if ("hidden" === nextProps.mode)
5736            return current = mountActivityChildren(workInProgress2, nextProps), workInProgress2.lanes = 536870912, bailoutOffscreenComponent(null, current);
5737          pushDehydratedActivitySuspenseHandler(workInProgress2);
5738          (current = nextHydratableInstance) ? (current = canHydrateHydrationBoundary(
5739            current,
5740            rootOrSingletonContext
5741          ), current = null !== current && "&" === current.data ? current : null, null !== current && (workInProgress2.memoizedState = {
5742            dehydrated: current,
5743            treeContext: null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null,
5744            retryLane: 536870912,
5745            hydrationErrors: null
5746          }, renderLanes2 = createFiberFromDehydratedFragment(current), renderLanes2.return = workInProgress2, workInProgress2.child = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : current = null;
5747          if (null === current) throw throwOnHydrationMismatch(workInProgress2);
5748          workInProgress2.lanes = 536870912;
5749          return null;
5750        }
5751        return mountActivityChildren(workInProgress2, nextProps);
5752      }
5753      var prevState = current.memoizedState;
5754      if (null !== prevState) {
5755        var dehydrated = prevState.dehydrated;
5756        pushDehydratedActivitySuspenseHandler(workInProgress2);
5757        if (didSuspend)
5758          if (workInProgress2.flags & 256)
5759            workInProgress2.flags &= -257, workInProgress2 = retryActivityComponentWithoutHydrating(
5760              current,
5761              workInProgress2,
5762              renderLanes2
5763            );
5764          else if (null !== workInProgress2.memoizedState)
5765            workInProgress2.child = current.child, workInProgress2.flags |= 128, workInProgress2 = null;
5766          else throw Error(formatProdErrorMessage(558));
5767        else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress2, renderLanes2, false), didSuspend = 0 !== (renderLanes2 & current.childLanes), didReceiveUpdate || didSuspend) {
5768          nextProps = workInProgressRoot;
5769          if (null !== nextProps && (dehydrated = getBumpedLaneForHydration(nextProps, renderLanes2), 0 !== dehydrated && dehydrated !== prevState.retryLane))
5770            throw prevState.retryLane = dehydrated, enqueueConcurrentRenderForLane(current, dehydrated), scheduleUpdateOnFiber(nextProps, current, dehydrated), SelectiveHydrationException;
5771          renderDidSuspendDelayIfPossible();
5772          workInProgress2 = retryActivityComponentWithoutHydrating(
5773            current,
5774            workInProgress2,
5775            renderLanes2
5776          );
5777        } else
5778          current = prevState.treeContext, nextHydratableInstance = getNextHydratable(dehydrated.nextSibling), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, rootOrSingletonContext = false, null !== current && restoreSuspendedTreeContext(workInProgress2, current), workInProgress2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.flags |= 4096;
5779        return workInProgress2;
5780      }
5781      current = createWorkInProgress(current.child, {
5782        mode: nextProps.mode,
5783        children: nextProps.children
5784      });
5785      current.ref = workInProgress2.ref;
5786      workInProgress2.child = current;
5787      current.return = workInProgress2;
5788      return current;
5789    }
5790    function markRef(current, workInProgress2) {
5791      var ref2 = workInProgress2.ref;
5792      if (null === ref2)
5793        null !== current && null !== current.ref && (workInProgress2.flags |= 4194816);
5794      else {
5795        if ("function" !== typeof ref2 && "object" !== typeof ref2)
5796          throw Error(formatProdErrorMessage(284));
5797        if (null === current || current.ref !== ref2)
5798          workInProgress2.flags |= 4194816;
5799      }
5800    }
5801    function updateFunctionComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
5802      prepareToReadContext(workInProgress2);
5803      Component = renderWithHooks(
5804        current,
5805        workInProgress2,
5806        Component,
5807        nextProps,
5808        void 0,
5809        renderLanes2
5810      );
5811      nextProps = checkDidRenderIdHook();
5812      if (null !== current && !didReceiveUpdate)
5813        return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
5814      isHydrating && nextProps && pushMaterializedTreeId(workInProgress2);
5815      workInProgress2.flags |= 1;
5816      reconcileChildren(current, workInProgress2, Component, renderLanes2);
5817      return workInProgress2.child;
5818    }
5819    function replayFunctionComponent(current, workInProgress2, nextProps, Component, secondArg, renderLanes2) {
5820      prepareToReadContext(workInProgress2);
5821      workInProgress2.updateQueue = null;
5822      nextProps = renderWithHooksAgain(
5823        workInProgress2,
5824        Component,
5825        nextProps,
5826        secondArg
5827      );
5828      finishRenderingHooks(current);
5829      Component = checkDidRenderIdHook();
5830      if (null !== current && !didReceiveUpdate)
5831        return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
5832      isHydrating && Component && pushMaterializedTreeId(workInProgress2);
5833      workInProgress2.flags |= 1;
5834      reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
5835      return workInProgress2.child;
5836    }
5837    function updateClassComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
5838      prepareToReadContext(workInProgress2);
5839      if (null === workInProgress2.stateNode) {
5840        var context = emptyContextObject, contextType = Component.contextType;
5841        "object" === typeof contextType && null !== contextType && (context = readContext(contextType));
5842        context = new Component(nextProps, context);
5843        workInProgress2.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
5844        context.updater = classComponentUpdater;
5845        workInProgress2.stateNode = context;
5846        context._reactInternals = workInProgress2;
5847        context = workInProgress2.stateNode;
5848        context.props = nextProps;
5849        context.state = workInProgress2.memoizedState;
5850        context.refs = {};
5851        initializeUpdateQueue(workInProgress2);
5852        contextType = Component.contextType;
5853        context.context = "object" === typeof contextType && null !== contextType ? readContext(contextType) : emptyContextObject;
5854        context.state = workInProgress2.memoizedState;
5855        contextType = Component.getDerivedStateFromProps;
5856        "function" === typeof contextType && (applyDerivedStateFromProps(
5857          workInProgress2,
5858          Component,
5859          contextType,
5860          nextProps
5861        ), context.state = workInProgress2.memoizedState);
5862        "function" === typeof Component.getDerivedStateFromProps || "function" === typeof context.getSnapshotBeforeUpdate || "function" !== typeof context.UNSAFE_componentWillMount && "function" !== typeof context.componentWillMount || (contextType = context.state, "function" === typeof context.componentWillMount && context.componentWillMount(), "function" === typeof context.UNSAFE_componentWillMount && context.UNSAFE_componentWillMount(), contextType !== context.state && classComponentUpdater.enqueueReplaceState(context, context.state, null), processUpdateQueue(workInProgress2, nextProps, context, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction(), context.state = workInProgress2.memoizedState);
5863        "function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308);
5864        nextProps = true;
5865      } else if (null === current) {
5866        context = workInProgress2.stateNode;
5867        var unresolvedOldProps = workInProgress2.memoizedProps, oldProps = resolve

vendor: 15,560 bytes, lines 5867-6094

5867ClassComponentProps(Component, unresolvedOldProps);
5868        context.props = oldProps;
5869        var oldContext = context.context, contextType$jscomp$0 = Component.contextType;
5870        contextType = emptyContextObject;
5871        "object" === typeof contextType$jscomp$0 && null !== contextType$jscomp$0 && (contextType = readContext(contextType$jscomp$0));
5872        var getDerivedStateFromProps = Component.getDerivedStateFromProps;
5873        contextType$jscomp$0 = "function" === typeof getDerivedStateFromProps || "function" === typeof context.getSnapshotBeforeUpdate;
5874        unresolvedOldProps = workInProgress2.pendingProps !== unresolvedOldProps;
5875        contextType$jscomp$0 || "function" !== typeof context.UNSAFE_componentWillReceiveProps && "function" !== typeof context.componentWillReceiveProps || (unresolvedOldProps || oldContext !== contextType) && callComponentWillReceiveProps(
5876          workInProgress2,
5877          context,
5878          nextProps,
5879          contextType
5880        );
5881        hasForceUpdate = false;
5882        var oldState = workInProgress2.memoizedState;
5883        context.state = oldState;
5884        processUpdateQueue(workInProgress2, nextProps, context, renderLanes2);
5885        suspendIfUpdateReadFromEntangledAsyncAction();
5886        oldContext = workInProgress2.memoizedState;
5887        unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(
5888          workInProgress2,
5889          Component,
5890          getDerivedStateFromProps,
5891          nextProps
5892        ), oldContext = workInProgress2.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(
5893          workInProgress2,
5894          Component,
5895          oldProps,
5896          nextProps,
5897          oldState,
5898          oldContext,
5899          contextType
5900        )) ? (contextType$jscomp$0 || "function" !== typeof context.UNSAFE_componentWillMount && "function" !== typeof context.componentWillMount || ("function" === typeof context.componentWillMount && context.componentWillMount(), "function" === typeof context.UNSAFE_componentWillMount && context.UNSAFE_componentWillMount()), "function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308)) : ("function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = oldContext), context.props = nextProps, context.state = oldContext, context.context = contextType, nextProps = oldProps) : ("function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308), nextProps = false);
5901      } else {
5902        context = workInProgress2.stateNode;
5903        cloneUpdateQueue(current, workInProgress2);
5904        contextType = workInProgress2.memoizedProps;
5905        contextType$jscomp$0 = resolveClassComponentProps(Component, contextType);
5906        context.props = contextType$jscomp$0;
5907        getDerivedStateFromProps = workInProgress2.pendingProps;
5908        oldState = context.context;
5909        oldContext = Component.contextType;
5910        oldProps = emptyContextObject;
5911        "object" === typeof oldContext && null !== oldContext && (oldProps = readContext(oldContext));
5912        unresolvedOldProps = Component.getDerivedStateFromProps;
5913        (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof context.getSnapshotBeforeUpdate) || "function" !== typeof context.UNSAFE_componentWillReceiveProps && "function" !== typeof context.componentWillReceiveProps || (contextType !== getDerivedStateFromProps || oldState !== oldProps) && callComponentWillReceiveProps(
5914          workInProgress2,
5915          context,
5916          nextProps,
5917          oldProps
5918        );
5919        hasForceUpdate = false;
5920        oldState = workInProgress2.memoizedState;
5921        context.state = oldState;
5922        processUpdateQueue(workInProgress2, nextProps, context, renderLanes2);
5923        suspendIfUpdateReadFromEntangledAsyncAction();
5924        var newState = workInProgress2.memoizedState;
5925        contextType !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(
5926          workInProgress2,
5927          Component,
5928          unresolvedOldProps,
5929          nextProps
5930        ), newState = workInProgress2.memoizedState), (contextType$jscomp$0 = hasForceUpdate || checkShouldComponentUpdate(
5931          workInProgress2,
5932          Component,
5933          contextType$jscomp$0,
5934          nextProps,
5935          oldState,
5936          newState,
5937          oldProps
5938        ) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof context.UNSAFE_componentWillUpdate && "function" !== typeof context.componentWillUpdate || ("function" === typeof context.componentWillUpdate && context.componentWillUpdate(nextProps, newState, oldProps), "function" === typeof context.UNSAFE_componentWillUpdate && context.UNSAFE_componentWillUpdate(
5939          nextProps,
5940          newState,
5941          oldProps
5942        )), "function" === typeof context.componentDidUpdate && (workInProgress2.flags |= 4), "function" === typeof context.getSnapshotBeforeUpdate && (workInProgress2.flags |= 1024)) : ("function" !== typeof context.componentDidUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof context.getSnapshotBeforeUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 1024), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = newState), context.props = nextProps, context.state = newState, context.context = oldProps, nextProps = contextType$jscomp$0) : ("function" !== typeof context.componentDidUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof context.getSnapshotBeforeUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 1024), nextProps = false);
5943      }
5944      context = nextProps;
5945      markRef(current, workInProgress2);
5946      nextProps = 0 !== (workInProgress2.flags & 128);
5947      context || nextProps ? (context = workInProgress2.stateNode, Component = nextProps && "function" !== typeof Component.getDerivedStateFromError ? null : context.render(), workInProgress2.flags |= 1, null !== current && nextProps ? (workInProgress2.child = reconcileChildFibers(
5948        workInProgress2,
5949        current.child,
5950        null,
5951        renderLanes2
5952      ), workInProgress2.child = reconcileChildFibers(
5953        workInProgress2,
5954        null,
5955        Component,
5956        renderLanes2
5957      )) : reconcileChildren(current, workInProgress2, Component, renderLanes2), workInProgress2.memoizedState = context.state, current = workInProgress2.child) : current = bailoutOnAlreadyFinishedWork(
5958        current,
5959        workInProgress2,
5960        renderLanes2
5961      );
5962      return current;
5963    }
5964    function mountHostRootWithoutHydrating(current, workInProgress2, nextChildren, renderLanes2) {
5965      resetHydrationState();
5966      workInProgress2.flags |= 256;
5967      reconcileChildren(current, workInProgress2, nextChildren, renderLanes2);
5968      return workInProgress2.child;
5969    }
5970    var SUSPENDED_MARKER = {
5971      dehydrated: null,
5972      treeContext: null,
5973      retryLane: 0,
5974      hydrationErrors: null
5975    };
5976    function mountSuspenseOffscreenState(renderLanes2) {
5977      return { baseLanes: renderLanes2, cachePool: getSuspendedCache() };
5978    }
5979    function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes2) {
5980      current = null !== current ? current.childLanes & ~renderLanes2 : 0;
5981      primaryTreeDidDefer && (current |= workInProgressDeferredLane);
5982      return current;
5983    }
5984    function updateSuspenseComponent(current, workInProgress2, renderLanes2) {
5985      var nextProps = workInProgress2.pendingProps, showFallback = false, didSuspend = 0 !== (workInProgress2.flags & 128), JSCompiler_temp;
5986      (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? false : 0 !== (suspenseStackCursor.current & 2));
5987      JSCompiler_temp && (showFallback = true, workInProgress2.flags &= -129);
5988      JSCompiler_temp = 0 !== (workInProgress2.flags & 32);
5989      workInProgress2.flags &= -33;
5990      if (null === current) {
5991        if (isHydrating) {
5992          showFallback ? pushPrimaryTreeSuspenseHandler(workInProgress2) : reuseSuspenseHandlerOnStack();
5993          (current = nextHydratableInstance) ? (current = canHydrateHydrationBoundary(
5994            current,
5995            rootOrSingletonContext
5996          ), current = null !== current && "&" !== current.data ? current : null, null !== current && (workInProgress2.memoizedState = {
5997            dehydrated: current,
5998            treeContext: null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null,
5999            retryLane: 536870912,
6000            hydrationErrors: null
6001          }, renderLanes2 = createFiberFromDehydratedFragment(current), renderLanes2.return = workInProgress2, workInProgress2.child = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : current = null;
6002          if (null === current) throw throwOnHydrationMismatch(workInProgress2);
6003          isSuspenseInstanceFallback(current) ? workInProgress2.lanes = 32 : workInProgress2.lanes = 536870912;
6004          return null;
6005        }
6006        var nextPrimaryChildren = nextProps.children;
6007        nextProps = nextProps.fallback;
6008        if (showFallback)
6009          return reuseSuspenseHandlerOnStack(), showFallback = workInProgress2.mode, nextPrimaryChildren = mountWorkInProgressOffscreenFiber(
6010            { mode: "hidden", children: nextPrimaryChildren },
6011            showFallback
6012          ), nextProps = createFiberFromFragment(
6013            nextProps,
6014            showFallback,
6015            renderLanes2,
6016            null
6017          ), nextPrimaryChildren.return = workInProgress2, nextProps.return = workInProgress2, nextPrimaryChildren.sibling = nextProps, workInProgress2.child = nextPrimaryChildren, nextProps = workInProgress2.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes2), nextProps.childLanes = getRemainingWorkInPrimaryTree(
6018            current,
6019            JSCompiler_temp,
6020            renderLanes2
6021          ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(null, nextProps);
6022        pushPrimaryTreeSuspenseHandler(workInProgress2);
6023        return mountSuspensePrimaryChildren(workInProgress2, nextPrimaryChildren);
6024      }
6025      var prevState = current.memoizedState;
6026      if (null !== prevState && (nextPrimaryChildren = prevState.dehydrated, null !== nextPrimaryChildren)) {
6027        if (didSuspend)
6028          workInProgress2.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags &= -257, workInProgress2 = retrySuspenseComponentWithoutHydrating(
6029            current,
6030            workInProgress2,
6031            renderLanes2
6032          )) : null !== workInProgress2.memoizedState ? (reuseSuspenseHandlerOnStack(), workInProgress2.child = current.child, workInProgress2.flags |= 128, workInProgress2 = null) : (reuseSuspenseHandlerOnStack(), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress2.mode, nextProps = mountWorkInProgressOffscreenFiber(
6033            { mode: "visible", children: nextProps.children },
6034            showFallback
6035          ), nextPrimaryChildren = createFiberFromFragment(
6036            nextPrimaryChildren,
6037            showFallback,
6038            renderLanes2,
6039            null
6040          ), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress2, nextPrimaryChildren.return = workInProgress2, nextProps.sibling = nextPrimaryChildren, workInProgress2.child = nextProps, reconcileChildFibers(
6041            workInProgress2,
6042            current.child,
6043            null,
6044            renderLanes2
6045          ), nextProps = workInProgress2.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes2), nextProps.childLanes = getRemainingWorkInPrimaryTree(
6046            current,
6047            JSCompiler_temp,
6048            renderLanes2
6049          ), workInProgress2.memoizedState = SUSPENDED_MARKER, workInProgress2 = bailoutOffscreenComponent(null, nextProps));
6050        else if (pushPrimaryTreeSuspenseHandler(workInProgress2), isSuspenseInstanceFallback(nextPrimaryChildren)) {
6051          JSCompiler_temp = nextPrimaryChildren.nextSibling && nextPrimaryChildren.nextSibling.dataset;
6052          if (JSCompiler_temp) var digest = JSCompiler_temp.dgst;
6053          JSCompiler_temp = digest;
6054          nextProps = Error(formatProdErrorMessage(419));
6055          nextProps.stack = "";
6056          nextProps.digest = JSCompiler_temp;
6057          queueHydrationError({ value: nextProps, source: null, stack: null });
6058          workInProgress2 = retrySuspenseComponentWithoutHydrating(
6059            current,
6060            workInProgress2,
6061            renderLanes2
6062          );
6063        } else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress2, renderLanes2, false), JSCompiler_temp = 0 !== (renderLanes2 & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
6064          JSCompiler_temp = workInProgressRoot;
6065          if (null !== JSCompiler_temp && (nextProps = getBumpedLaneForHydration(JSCompiler_temp, renderLanes2), 0 !== nextProps && nextProps !== prevState.retryLane))
6066            throw prevState.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
6067          isSuspenseInstancePending(nextPrimaryChildren) || renderDidSuspendDelayIfPossible();
6068          workInProgress2 = retrySuspenseComponentWithoutHydrating(
6069            current,
6070            workInProgress2,
6071            renderLanes2
6072          );
6073        } else
6074          isSuspenseInstancePending(nextPrimaryChildren) ? (workInProgress2.flags |= 192, workInProgress2.child = current.child, workInProgress2 = null) : (current = prevState.treeContext, nextHydratableInstance = getNextHydratable(
6075            nextPrimaryChildren.nextSibling
6076          ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, rootOrSingletonContext = false, null !== current && restoreSuspendedTreeContext(workInProgress2, current), workInProgress2 = mountSuspensePrimaryChildren(
6077            workInProgress2,
6078            nextProps.children
6079          ), workInProgress2.flags |= 4096);
6080        return workInProgress2;
6081      }
6082      if (showFallback)
6083        return reuseSuspenseHandlerOnStack(), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress2.mode, prevState = current.child, digest = prevState.sibling, nextProps = createWorkInProgress(prevState, {
6084          mode: "hidden",
6085          children: nextProps.children
6086        }), nextProps.subtreeFlags = prevState.subtreeFlags & 65011712, null !== digest ? nextPrimaryChildren = createWorkInProgress(
6087          digest,
6088          nextPrimaryChildren
6089        ) : (nextPrimaryChildren = createFiberFromFragment(
6090          nextPrimaryChildren,
6091          showFallback,
6092          renderLanes2,
6093          null
6094        ), nextPrimaryChildren.flags |= 2), nextPrimaryChildren.return = w

vendor: 31,241 bytes, lines 6094-6748

6094orkInProgress2, nextProps.return = workInProgress2, nextProps.sibling = nextPrimaryChildren, workInProgress2.child = nextProps, bailoutOffscreenComponent(null, nextProps), nextProps = workInProgress2.child, nextPrimaryChildren = current.child.memoizedState, null === nextPrimaryChildren ? nextPrimaryChildren = mountSuspenseOffscreenState(renderLanes2) : (showFallback = nextPrimaryChildren.cachePool, null !== showFallback ? (prevState = CacheContext._currentValue, showFallback = showFallback.parent !== prevState ? { parent: prevState, pool: prevState } : showFallback) : showFallback = getSuspendedCache(), nextPrimaryChildren = {
6095          baseLanes: nextPrimaryChildren.baseLanes | renderLanes2,
6096          cachePool: showFallback
6097        }), nextProps.memoizedState = nextPrimaryChildren, nextProps.childLanes = getRemainingWorkInPrimaryTree(
6098          current,
6099          JSCompiler_temp,
6100          renderLanes2
6101        ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(current.child, nextProps);
6102      pushPrimaryTreeSuspenseHandler(workInProgress2);
6103      renderLanes2 = current.child;
6104      current = renderLanes2.sibling;
6105      renderLanes2 = createWorkInProgress(renderLanes2, {
6106        mode: "visible",
6107        children: nextProps.children
6108      });
6109      renderLanes2.return = workInProgress2;
6110      renderLanes2.sibling = null;
6111      null !== current && (JSCompiler_temp = workInProgress2.deletions, null === JSCompiler_temp ? (workInProgress2.deletions = [current], workInProgress2.flags |= 16) : JSCompiler_temp.push(current));
6112      workInProgress2.child = renderLanes2;
6113      workInProgress2.memoizedState = null;
6114      return renderLanes2;
6115    }
6116    function mountSuspensePrimaryChildren(workInProgress2, primaryChildren) {
6117      primaryChildren = mountWorkInProgressOffscreenFiber(
6118        { mode: "visible", children: primaryChildren },
6119        workInProgress2.mode
6120      );
6121      primaryChildren.return = workInProgress2;
6122      return workInProgress2.child = primaryChildren;
6123    }
6124    function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
6125      offscreenProps = createFiberImplClass(22, offscreenProps, null, mode);
6126      offscreenProps.lanes = 0;
6127      return offscreenProps;
6128    }
6129    function retrySuspenseComponentWithoutHydrating(current, workInProgress2, renderLanes2) {
6130      reconcileChildFibers(workInProgress2, current.child, null, renderLanes2);
6131      current = mountSuspensePrimaryChildren(
6132        workInProgress2,
6133        workInProgress2.pendingProps.children
6134      );
6135      current.flags |= 2;
6136      workInProgress2.memoizedState = null;
6137      return current;
6138    }
6139    function scheduleSuspenseWorkOnFiber(fiber, renderLanes2, propagationRoot) {
6140      fiber.lanes |= renderLanes2;
6141      var alternate = fiber.alternate;
6142      null !== alternate && (alternate.lanes |= renderLanes2);
6143      scheduleContextWorkOnParentPath(fiber.return, renderLanes2, propagationRoot);
6144    }
6145    function initSuspenseListRenderState(workInProgress2, isBackwards, tail, lastContentRow, tailMode, treeForkCount2) {
6146      var renderState = workInProgress2.memoizedState;
6147      null === renderState ? workInProgress2.memoizedState = {
6148        isBackwards,
6149        rendering: null,
6150        renderingStartTime: 0,
6151        last: lastContentRow,
6152        tail,
6153        tailMode,
6154        treeForkCount: treeForkCount2
6155      } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
6156    }
6157    function updateSuspenseListComponent(current, workInProgress2, renderLanes2) {
6158      var nextProps = workInProgress2.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail;
6159      nextProps = nextProps.children;
6160      var suspenseContext = suspenseStackCursor.current, shouldForceFallback = 0 !== (suspenseContext & 2);
6161      shouldForceFallback ? (suspenseContext = suspenseContext & 1 | 2, workInProgress2.flags |= 128) : suspenseContext &= 1;
6162      push(suspenseStackCursor, suspenseContext);
6163      reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
6164      nextProps = isHydrating ? treeForkCount : 0;
6165      if (!shouldForceFallback && null !== current && 0 !== (current.flags & 128))
6166        a: for (current = workInProgress2.child; null !== current; ) {
6167          if (13 === current.tag)
6168            null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes2, workInProgress2);
6169          else if (19 === current.tag)
6170            scheduleSuspenseWorkOnFiber(current, renderLanes2, workInProgress2);
6171          else if (null !== current.child) {
6172            current.child.return = current;
6173            current = current.child;
6174            continue;
6175          }
6176          if (current === workInProgress2) break a;
6177          for (; null === current.sibling; ) {
6178            if (null === current.return || current.return === workInProgress2)
6179              break a;
6180            current = current.return;
6181          }
6182          current.sibling.return = current.return;
6183          current = current.sibling;
6184        }
6185      switch (revealOrder) {
6186        case "forwards":
6187          renderLanes2 = workInProgress2.child;
6188          for (revealOrder = null; null !== renderLanes2; )
6189            current = renderLanes2.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes2), renderLanes2 = renderLanes2.sibling;
6190          renderLanes2 = revealOrder;
6191          null === renderLanes2 ? (revealOrder = workInProgress2.child, workInProgress2.child = null) : (revealOrder = renderLanes2.sibling, renderLanes2.sibling = null);
6192          initSuspenseListRenderState(
6193            workInProgress2,
6194            false,
6195            revealOrder,
6196            renderLanes2,
6197            tailMode,
6198            nextProps
6199          );
6200          break;
6201        case "backwards":
6202        case "unstable_legacy-backwards":
6203          renderLanes2 = null;
6204          revealOrder = workInProgress2.child;
6205          for (workInProgress2.child = null; null !== revealOrder; ) {
6206            current = revealOrder.alternate;
6207            if (null !== current && null === findFirstSuspended(current)) {
6208              workInProgress2.child = revealOrder;
6209              break;
6210            }
6211            current = revealOrder.sibling;
6212            revealOrder.sibling = renderLanes2;
6213            renderLanes2 = revealOrder;
6214            revealOrder = current;
6215          }
6216          initSuspenseListRenderState(
6217            workInProgress2,
6218            true,
6219            renderLanes2,
6220            null,
6221            tailMode,
6222            nextProps
6223          );
6224          break;
6225        case "together":
6226          initSuspenseListRenderState(
6227            workInProgress2,
6228            false,
6229            null,
6230            null,
6231            void 0,
6232            nextProps
6233          );
6234          break;
6235        default:
6236          workInProgress2.memoizedState = null;
6237      }
6238      return workInProgress2.child;
6239    }
6240    function bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2) {
6241      null !== current && (workInProgress2.dependencies = current.dependencies);
6242      workInProgressRootSkippedLanes |= workInProgress2.lanes;
6243      if (0 === (renderLanes2 & workInProgress2.childLanes))
6244        if (null !== current) {
6245          if (propagateParentContextChanges(
6246            current,
6247            workInProgress2,
6248            renderLanes2,
6249            false
6250          ), 0 === (renderLanes2 & workInProgress2.childLanes))
6251            return null;
6252        } else return null;
6253      if (null !== current && workInProgress2.child !== current.child)
6254        throw Error(formatProdErrorMessage(153));
6255      if (null !== workInProgress2.child) {
6256        current = workInProgress2.child;
6257        renderLanes2 = createWorkInProgress(current, current.pendingProps);
6258        workInProgress2.child = renderLanes2;
6259        for (renderLanes2.return = workInProgress2; null !== current.sibling; )
6260          current = current.sibling, renderLanes2 = renderLanes2.sibling = createWorkInProgress(current, current.pendingProps), renderLanes2.return = workInProgress2;
6261        renderLanes2.sibling = null;
6262      }
6263      return workInProgress2.child;
6264    }
6265    function checkScheduledUpdateOrContext(current, renderLanes2) {
6266      if (0 !== (current.lanes & renderLanes2)) return true;
6267      current = current.dependencies;
6268      return null !== current && checkIfContextChanged(current) ? true : false;
6269    }
6270    function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress2, renderLanes2) {
6271      switch (workInProgress2.tag) {
6272        case 3:
6273          pushHostContainer(workInProgress2, workInProgress2.stateNode.containerInfo);
6274          pushProvider(workInProgress2, CacheContext, current.memoizedState.cache);
6275          resetHydrationState();
6276          break;
6277        case 27:
6278        case 5:
6279          pushHostContext(workInProgress2);
6280          break;
6281        case 4:
6282          pushHostContainer(workInProgress2, workInProgress2.stateNode.containerInfo);
6283          break;
6284        case 10:
6285          pushProvider(
6286            workInProgress2,
6287            workInProgress2.type,
6288            workInProgress2.memoizedProps.value
6289          );
6290          break;
6291        case 31:
6292          if (null !== workInProgress2.memoizedState)
6293            return workInProgress2.flags |= 128, pushDehydratedActivitySuspenseHandler(workInProgress2), null;
6294          break;
6295        case 13:
6296          var state$102 = workInProgress2.memoizedState;
6297          if (null !== state$102) {
6298            if (null !== state$102.dehydrated)
6299              return pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags |= 128, null;
6300            if (0 !== (renderLanes2 & workInProgress2.child.childLanes))
6301              return updateSuspenseComponent(current, workInProgress2, renderLanes2);
6302            pushPrimaryTreeSuspenseHandler(workInProgress2);
6303            current = bailoutOnAlreadyFinishedWork(
6304              current,
6305              workInProgress2,
6306              renderLanes2
6307            );
6308            return null !== current ? current.sibling : null;
6309          }
6310          pushPrimaryTreeSuspenseHandler(workInProgress2);
6311          break;
6312        case 19:
6313          var didSuspendBefore = 0 !== (current.flags & 128);
6314          state$102 = 0 !== (renderLanes2 & workInProgress2.childLanes);
6315          state$102 || (propagateParentContextChanges(
6316            current,
6317            workInProgress2,
6318            renderLanes2,
6319            false
6320          ), state$102 = 0 !== (renderLanes2 & workInProgress2.childLanes));
6321          if (didSuspendBefore) {
6322            if (state$102)
6323              return updateSuspenseListComponent(
6324                current,
6325                workInProgress2,
6326                renderLanes2
6327              );
6328            workInProgress2.flags |= 128;
6329          }
6330          didSuspendBefore = workInProgress2.memoizedState;
6331          null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
6332          push(suspenseStackCursor, suspenseStackCursor.current);
6333          if (state$102) break;
6334          else return null;
6335        case 22:
6336          return workInProgress2.lanes = 0, updateOffscreenComponent(
6337            current,
6338            workInProgress2,
6339            renderLanes2,
6340            workInProgress2.pendingProps
6341          );
6342        case 24:
6343          pushProvider(workInProgress2, CacheContext, current.memoizedState.cache);
6344      }
6345      return bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
6346    }
6347    function beginWork(current, workInProgress2, renderLanes2) {
6348      if (null !== current)
6349        if (current.memoizedProps !== workInProgress2.pendingProps)
6350          didReceiveUpdate = true;
6351        else {
6352          if (!checkScheduledUpdateOrContext(current, renderLanes2) && 0 === (workInProgress2.flags & 128))
6353            return didReceiveUpdate = false, attemptEarlyBailoutIfNoScheduledUpdate(
6354              current,
6355              workInProgress2,
6356              renderLanes2
6357            );
6358          didReceiveUpdate = 0 !== (current.flags & 131072) ? true : false;
6359        }
6360      else
6361        didReceiveUpdate = false, isHydrating && 0 !== (workInProgress2.flags & 1048576) && pushTreeId(workInProgress2, treeForkCount, workInProgress2.index);
6362      workInProgress2.lanes = 0;
6363      switch (workInProgress2.tag) {
6364        case 16:
6365          a: {
6366            var props = workInProgress2.pendingProps;
6367            current = resolveLazy(workInProgress2.elementType);
6368            workInProgress2.type = current;
6369            if ("function" === typeof current)
6370              shouldConstruct(current) ? (props = resolveClassComponentProps(current, props), workInProgress2.tag = 1, workInProgress2 = updateClassComponent(
6371                null,
6372                workInProgress2,
6373                current,
6374                props,
6375                renderLanes2
6376              )) : (workInProgress2.tag = 0, workInProgress2 = updateFunctionComponent(
6377                null,
6378                workInProgress2,
6379                current,
6380                props,
6381                renderLanes2
6382              ));
6383            else {
6384              if (void 0 !== current && null !== current) {
6385                var $$typeof = current.$$typeof;
6386                if ($$typeof === REACT_FORWARD_REF_TYPE) {
6387                  workInProgress2.tag = 11;
6388                  workInProgress2 = updateForwardRef(
6389                    null,
6390                    workInProgress2,
6391                    current,
6392                    props,
6393                    renderLanes2
6394                  );
6395                  break a;
6396                } else if ($$typeof === REACT_MEMO_TYPE) {
6397                  workInProgress2.tag = 14;
6398                  workInProgress2 = updateMemoComponent(
6399                    null,
6400                    workInProgress2,
6401                    current,
6402                    props,
6403                    renderLanes2
6404                  );
6405                  break a;
6406                }
6407              }
6408              workInProgress2 = getComponentNameFromType(current) || current;
6409              throw Error(formatProdErrorMessage(306, workInProgress2, ""));
6410            }
6411          }
6412          return workInProgress2;
6413        case 0:
6414          return updateFunctionComponent(
6415            current,
6416            workInProgress2,
6417            workInProgress2.type,
6418            workInProgress2.pendingProps,
6419            renderLanes2
6420          );
6421        case 1:
6422          return props = workInProgress2.type, $$typeof = resolveClassComponentProps(
6423            props,
6424            workInProgress2.pendingProps
6425          ), updateClassComponent(
6426            current,
6427            workInProgress2,
6428            props,
6429            $$typeof,
6430            renderLanes2
6431          );
6432        case 3:
6433          a: {
6434            pushHostContainer(
6435              workInProgress2,
6436              workInProgress2.stateNode.containerInfo
6437            );
6438            if (null === current) throw Error(formatProdErrorMessage(387));
6439            props = workInProgress2.pendingProps;
6440            var prevState = workInProgress2.memoizedState;
6441            $$typeof = prevState.element;
6442            cloneUpdateQueue(current, workInProgress2);
6443            processUpdateQueue(workInProgress2, props, null, renderLanes2);
6444            var nextState = workInProgress2.memoizedState;
6445            props = nextState.cache;
6446            pushProvider(workInProgress2, CacheContext, props);
6447            props !== prevState.cache && propagateContextChanges(
6448              workInProgress2,
6449              [CacheContext],
6450              renderLanes2,
6451              true
6452            );
6453            suspendIfUpdateReadFromEntangledAsyncAction();
6454            props = nextState.element;
6455            if (prevState.isDehydrated)
6456              if (prevState = {
6457                element: props,
6458                isDehydrated: false,
6459                cache: nextState.cache
6460              }, workInProgress2.updateQueue.baseState = prevState, workInProgress2.memoizedState = prevState, workInProgress2.flags & 256) {
6461                workInProgress2 = mountHostRootWithoutHydrating(
6462                  current,
6463                  workInProgress2,
6464                  props,
6465                  renderLanes2
6466                );
6467                break a;
6468              } else if (props !== $$typeof) {
6469                $$typeof = createCapturedValueAtFiber(
6470                  Error(formatProdErrorMessage(424)),
6471                  workInProgress2
6472                );
6473                queueHydrationError($$typeof);
6474                workInProgress2 = mountHostRootWithoutHydrating(
6475                  current,
6476                  workInProgress2,
6477                  props,
6478                  renderLanes2
6479                );
6480                break a;
6481              } else {
6482                current = workInProgress2.stateNode.containerInfo;
6483                switch (current.nodeType) {
6484                  case 9:
6485                    current = current.body;
6486                    break;
6487                  default:
6488                    current = "HTML" === current.nodeName ? current.ownerDocument.body : current;
6489                }
6490                nextHydratableInstance = getNextHydratable(current.firstChild);
6491                hydrationParentFiber = workInProgress2;
6492                isHydrating = true;
6493                hydrationErrors = null;
6494                rootOrSingletonContext = true;
6495                renderLanes2 = mountChildFibers(
6496                  workInProgress2,
6497                  null,
6498                  props,
6499                  renderLanes2
6500                );
6501                for (workInProgress2.child = renderLanes2; renderLanes2; )
6502                  renderLanes2.flags = renderLanes2.flags & -3 | 4096, renderLanes2 = renderLanes2.sibling;
6503              }
6504            else {
6505              resetHydrationState();
6506              if (props === $$typeof) {
6507                workInProgress2 = bailoutOnAlreadyFinishedWork(
6508                  current,
6509                  workInProgress2,
6510                  renderLanes2
6511                );
6512                break a;
6513              }
6514              reconcileChildren(current, workInProgress2, props, renderLanes2);
6515            }
6516            workInProgress2 = workInProgress2.child;
6517          }
6518          return workInProgress2;
6519        case 26:
6520          return markRef(current, workInProgress2), null === current ? (renderLanes2 = getResource(
6521            workInProgress2.type,
6522            null,
6523            workInProgress2.pendingProps,
6524            null
6525          )) ? workInProgress2.memoizedState = renderLanes2 : isHydrating || (renderLanes2 = workInProgress2.type, current = workInProgress2.pendingProps, props = getOwnerDocumentFromRootContainer(
6526            rootInstanceStackCursor.current
6527          ).createElement(renderLanes2), props[internalInstanceKey] = workInProgress2, props[internalPropsKey] = current, setInitialProperties(props, renderLanes2, current), markNodeAsHoistable(props), workInProgress2.stateNode = props) : workInProgress2.memoizedState = getResource(
6528            workInProgress2.type,
6529            current.memoizedProps,
6530            workInProgress2.pendingProps,
6531            current.memoizedState
6532          ), null;
6533        case 27:
6534          return pushHostContext(workInProgress2), null === current && isHydrating && (props = workInProgress2.stateNode = resolveSingletonInstance(
6535            workInProgress2.type,
6536            workInProgress2.pendingProps,
6537            rootInstanceStackCursor.current
6538          ), hydrationParentFiber = workInProgress2, rootOrSingletonContext = true, $$typeof = nextHydratableInstance, isSingletonScope(workInProgress2.type) ? (previousHydratableOnEnteringScopedSingleton = $$typeof, nextHydratableInstance = getNextHydratable(props.firstChild)) : nextHydratableInstance = $$typeof), reconcileChildren(
6539            current,
6540            workInProgress2,
6541            workInProgress2.pendingProps.children,
6542            renderLanes2
6543          ), markRef(current, workInProgress2), null === current && (workInProgress2.flags |= 4194304), workInProgress2.child;
6544        case 5:
6545          if (null === current && isHydrating) {
6546            if ($$typeof = props = nextHydratableInstance)
6547              props = canHydrateInstance(
6548                props,
6549                workInProgress2.type,
6550                workInProgress2.pendingProps,
6551                rootOrSingletonContext
6552              ), null !== props ? (workInProgress2.stateNode = props, hydrationParentFiber = workInProgress2, nextHydratableInstance = getNextHydratable(props.firstChild), rootOrSingletonContext = false, $$typeof = true) : $$typeof = false;
6553            $$typeof || throwOnHydrationMismatch(workInProgress2);
6554          }
6555          pushHostContext(workInProgress2);
6556          $$typeof = workInProgress2.type;
6557          prevState = workInProgress2.pendingProps;
6558          nextState = null !== current ? current.memoizedProps : null;
6559          props = prevState.children;
6560          shouldSetTextContent($$typeof, prevState) ? props = null : null !== nextState && shouldSetTextContent($$typeof, nextState) && (workInProgress2.flags |= 32);
6561          null !== workInProgress2.memoizedState && ($$typeof = renderWithHooks(
6562            current,
6563            workInProgress2,
6564            TransitionAwareHostComponent,
6565            null,
6566            null,
6567            renderLanes2
6568          ), HostTransitionContext._currentValue = $$typeof);
6569          markRef(current, workInProgress2);
6570          reconcileChildren(current, workInProgress2, props, renderLanes2);
6571          return workInProgress2.child;
6572        case 6:
6573          if (null === current && isHydrating) {
6574            if (current = renderLanes2 = nextHydratableInstance)
6575              renderLanes2 = canHydrateTextInstance(
6576                renderLanes2,
6577                workInProgress2.pendingProps,
6578                rootOrSingletonContext
6579              ), null !== renderLanes2 ? (workInProgress2.stateNode = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null, current = true) : current = false;
6580            current || throwOnHydrationMismatch(workInProgress2);
6581          }
6582          return null;
6583        case 13:
6584          return updateSuspenseComponent(current, workInProgress2, renderLanes2);
6585        case 4:
6586          return pushHostContainer(
6587            workInProgress2,
6588            workInProgress2.stateNode.containerInfo
6589          ), props = workInProgress2.pendingProps, null === current ? workInProgress2.child = reconcileChildFibers(
6590            workInProgress2,
6591            null,
6592            props,
6593            renderLanes2
6594          ) : reconcileChildren(current, workInProgress2, props, renderLanes2), workInProgress2.child;
6595        case 11:
6596          return updateForwardRef(
6597            current,
6598            workInProgress2,
6599            workInProgress2.type,
6600            workInProgress2.pendingProps,
6601            renderLanes2
6602          );
6603        case 7:
6604          return reconcileChildren(
6605            current,
6606            workInProgress2,
6607            workInProgress2.pendingProps,
6608            renderLanes2
6609          ), workInProgress2.child;
6610        case 8:
6611          return reconcileChildren(
6612            current,
6613            workInProgress2,
6614            workInProgress2.pendingProps.children,
6615            renderLanes2
6616          ), workInProgress2.child;
6617        case 12:
6618          return reconcileChildren(
6619            current,
6620            workInProgress2,
6621            workInProgress2.pendingProps.children,
6622            renderLanes2
6623          ), workInProgress2.child;
6624        case 10:
6625          return props = workInProgress2.pendingProps, pushProvider(workInProgress2, workInProgress2.type, props.value), reconcileChildren(current, workInProgress2, props.children, renderLanes2), workInProgress2.child;
6626        case 9:
6627          return $$typeof = workInProgress2.type._context, props = workInProgress2.pendingProps.children, prepareToReadContext(workInProgress2), $$typeof = readContext($$typeof), props = props($$typeof), workInProgress2.flags |= 1, reconcileChildren(current, workInProgress2, props, renderLanes2), workInProgress2.child;
6628        case 14:
6629          return updateMemoComponent(
6630            current,
6631            workInProgress2,
6632            workInProgress2.type,
6633            workInProgress2.pendingProps,
6634            renderLanes2
6635          );
6636        case 15:
6637          return updateSimpleMemoComponent(
6638            current,
6639            workInProgress2,
6640            workInProgress2.type,
6641            workInProgress2.pendingProps,
6642            renderLanes2
6643          );
6644        case 19:
6645          return updateSuspenseListComponent(current, workInProgress2, renderLanes2);
6646        case 31:
6647          return updateActivityComponent(current, workInProgress2, renderLanes2);
6648        case 22:
6649          return updateOffscreenComponent(
6650            current,
6651            workInProgress2,
6652            renderLanes2,
6653            workInProgress2.pendingProps
6654          );
6655        case 24:
6656          return prepareToReadContext(workInProgress2), props = readContext(CacheContext), null === current ? ($$typeof = peekCacheFromPool(), null === $$typeof && ($$typeof = workInProgressRoot, prevState = createCache(), $$typeof.pooledCache = prevState, prevState.refCount++, null !== prevState && ($$typeof.pooledCacheLanes |= renderLanes2), $$typeof = prevState), workInProgress2.memoizedState = { parent: props, cache: $$typeof }, initializeUpdateQueue(workInProgress2), pushProvider(workInProgress2, CacheContext, $$typeof)) : (0 !== (current.lanes & renderLanes2) && (cloneUpdateQueue(current, workInProgress2), processUpdateQueue(workInProgress2, null, null, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction()), $$typeof = current.memoizedState, prevState = workInProgress2.memoizedState, $$typeof.parent !== props ? ($$typeof = { parent: props, cache: props }, workInProgress2.memoizedState = $$typeof, 0 === workInProgress2.lanes && (workInProgress2.memoizedState = workInProgress2.updateQueue.baseState = $$typeof), pushProvider(workInProgress2, CacheContext, props)) : (props = prevState.cache, pushProvider(workInProgress2, CacheContext, props), props !== $$typeof.cache && propagateContextChanges(
6657            workInProgress2,
6658            [CacheContext],
6659            renderLanes2,
6660            true
6661          ))), reconcileChildren(
6662            current,
6663            workInProgress2,
6664            workInProgress2.pendingProps.children,
6665            renderLanes2
6666          ), workInProgress2.child;
6667        case 29:
6668          throw workInProgress2.pendingProps;
6669      }
6670      throw Error(formatProdErrorMessage(156, workInProgress2.tag));
6671    }
6672    function markUpdate(workInProgress2) {
6673      workInProgress2.flags |= 4;
6674    }
6675    function preloadInstanceAndSuspendIfNeeded(workInProgress2, type2, oldProps, newProps, renderLanes2) {
6676      if (type2 = 0 !== (workInProgress2.mode & 32)) type2 = false;
6677      if (type2) {
6678        if (workInProgress2.flags |= 16777216, (renderLanes2 & 335544128) === renderLanes2)
6679          if (workInProgress2.stateNode.complete) workInProgress2.flags |= 8192;
6680          else if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
6681          else
6682            throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
6683      } else workInProgress2.flags &= -16777217;
6684    }
6685    function preloadResourceAndSuspendIfNeeded(workInProgress2, resource) {
6686      if ("stylesheet" !== resource.type || 0 !== (resource.state.loading & 4))
6687        workInProgress2.flags &= -16777217;
6688      else if (workInProgress2.flags |= 16777216, !preloadResource(resource))
6689        if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
6690        else
6691          throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
6692    }
6693    function scheduleRetryEffect(workInProgress2, retryQueue) {
6694      null !== retryQueue && (workInProgress2.flags |= 4);
6695      workInProgress2.flags & 16384 && (retryQueue = 22 !== workInProgress2.tag ? claimNextRetryLane() : 536870912, workInProgress2.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
6696    }
6697    function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
6698      if (!isHydrating)
6699        switch (renderState.tailMode) {
6700          case "hidden":
6701            hasRenderedATailFallback = renderState.tail;
6702            for (var lastTailNode = null; null !== hasRenderedATailFallback; )
6703              null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
6704            null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
6705            break;
6706          case "collapsed":
6707            lastTailNode = renderState.tail;
6708            for (var lastTailNode$106 = null; null !== lastTailNode; )
6709              null !== lastTailNode.alternate && (lastTailNode$106 = lastTailNode), lastTailNode = lastTailNode.sibling;
6710            null === lastTailNode$106 ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : lastTailNode$106.sibling = null;
6711        }
6712    }
6713    function bubbleProperties(completedWork) {
6714      var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child, newChildLanes = 0, subtreeFlags = 0;
6715      if (didBailout)
6716        for (var child$107 = completedWork.child; null !== child$107; )
6717          newChildLanes |= child$107.lanes | child$107.childLanes, subtreeFlags |= child$107.subtreeFlags & 65011712, subtreeFlags |= child$107.flags & 65011712, child$107.return = completedWork, child$107 = child$107.sibling;
6718      else
6719        for (child$107 = completedWork.child; null !== child$107; )
6720          newChildLanes |= child$107.lanes | child$107.childLanes, subtreeFlags |= child$107.subtreeFlags, subtreeFlags |= child$107.flags, child$107.return = completedWork, child$107 = child$107.sibling;
6721      completedWork.subtreeFlags |= subtreeFlags;
6722      completedWork.childLanes = newChildLanes;
6723      return didBailout;
6724    }
6725    function completeWork(current, workInProgress2, renderLanes2) {
6726      var newProps = workInProgress2.pendingProps;
6727      popTreeContext(workInProgress2);
6728      switch (workInProgress2.tag) {
6729        case 16:
6730        case 15:
6731        case 0:
6732        case 11:
6733        case 7:
6734        case 8:
6735        case 12:
6736        case 9:
6737        case 14:
6738          return bubbleProperties(workInProgress2), null;
6739        case 1:
6740          return bubbleProperties(workInProgress2), null;
6741        case 3:
6742          renderLanes2 = workInProgress2.stateNode;
6743          newProps = null;
6744          null !== current && (newProps = current.memoizedState.cache);
6745          workInProgress2.memoizedState.cache !== newProps && (workInProgress2.flags |= 2048);
6746          popProvider(CacheContext);
6747          popHostContainer();
6748          renderLanes2.pendingContext && (renderLanes2.context = renderLanes2.pendingContext, renderLanes2.pen

vendor: 6,774 bytes, lines 6748-6881

6748dingContext = null);
6749          if (null === current || null === current.child)
6750            popHydrationState(workInProgress2) ? markUpdate(workInProgress2) : null === current || current.memoizedState.isDehydrated && 0 === (workInProgress2.flags & 256) || (workInProgress2.flags |= 1024, upgradeHydrationErrorsToRecoverable());
6751          bubbleProperties(workInProgress2);
6752          return null;
6753        case 26:
6754          var type2 = workInProgress2.type, nextResource = workInProgress2.memoizedState;
6755          null === current ? (markUpdate(workInProgress2), null !== nextResource ? (bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(workInProgress2, nextResource)) : (bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
6756            workInProgress2,
6757            type2,
6758            null,
6759            newProps,
6760            renderLanes2
6761          ))) : nextResource ? nextResource !== current.memoizedState ? (markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(workInProgress2, nextResource)) : (bubbleProperties(workInProgress2), workInProgress2.flags &= -16777217) : (current = current.memoizedProps, current !== newProps && markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
6762            workInProgress2,
6763            type2,
6764            current,
6765            newProps,
6766            renderLanes2
6767          ));
6768          return null;
6769        case 27:
6770          popHostContext(workInProgress2);
6771          renderLanes2 = rootInstanceStackCursor.current;
6772          type2 = workInProgress2.type;
6773          if (null !== current && null != workInProgress2.stateNode)
6774            current.memoizedProps !== newProps && markUpdate(workInProgress2);
6775          else {
6776            if (!newProps) {
6777              if (null === workInProgress2.stateNode)
6778                throw Error(formatProdErrorMessage(166));
6779              bubbleProperties(workInProgress2);
6780              return null;
6781            }
6782            current = contextStackCursor.current;
6783            popHydrationState(workInProgress2) ? prepareToHydrateHostInstance(workInProgress2) : (current = resolveSingletonInstance(type2, newProps, renderLanes2), workInProgress2.stateNode = current, markUpdate(workInProgress2));
6784          }
6785          bubbleProperties(workInProgress2);
6786          return null;
6787        case 5:
6788          popHostContext(workInProgress2);
6789          type2 = workInProgress2.type;
6790          if (null !== current && null != workInProgress2.stateNode)
6791            current.memoizedProps !== newProps && markUpdate(workInProgress2);
6792          else {
6793            if (!newProps) {
6794              if (null === workInProgress2.stateNode)
6795                throw Error(formatProdErrorMessage(166));
6796              bubbleProperties(workInProgress2);
6797              return null;
6798            }
6799            nextResource = contextStackCursor.current;
6800            if (popHydrationState(workInProgress2))
6801              prepareToHydrateHostInstance(workInProgress2);
6802            else {
6803              var ownerDocument = getOwnerDocumentFromRootContainer(
6804                rootInstanceStackCursor.current
6805              );
6806              switch (nextResource) {
6807                case 1:
6808                  nextResource = ownerDocument.createElementNS(
6809                    "http://www.w3.org/2000/svg",
6810                    type2
6811                  );
6812                  break;
6813                case 2:
6814                  nextResource = ownerDocument.createElementNS(
6815                    "http://www.w3.org/1998/Math/MathML",
6816                    type2
6817                  );
6818                  break;
6819                default:
6820                  switch (type2) {
6821                    case "svg":
6822                      nextResource = ownerDocument.createElementNS(
6823                        "http://www.w3.org/2000/svg",
6824                        type2
6825                      );
6826                      break;
6827                    case "math":
6828                      nextResource = ownerDocument.createElementNS(
6829                        "http://www.w3.org/1998/Math/MathML",
6830                        type2
6831                      );
6832                      break;
6833                    case "script":
6834                      nextResource = ownerDocument.createElement("div");
6835                      nextResource.innerHTML = "<script><\/script>";
6836                      nextResource = nextResource.removeChild(
6837                        nextResource.firstChild
6838                      );
6839                      break;
6840                    case "select":
6841                      nextResource = "string" === typeof newProps.is ? ownerDocument.createElement("select", {
6842                        is: newProps.is
6843                      }) : ownerDocument.createElement("select");
6844                      newProps.multiple ? nextResource.multiple = true : newProps.size && (nextResource.size = newProps.size);
6845                      break;
6846                    default:
6847                      nextResource = "string" === typeof newProps.is ? ownerDocument.createElement(type2, { is: newProps.is }) : ownerDocument.createElement(type2);
6848                  }
6849              }
6850              nextResource[internalInstanceKey] = workInProgress2;
6851              nextResource[internalPropsKey] = newProps;
6852              a: for (ownerDocument = workInProgress2.child; null !== ownerDocument; ) {
6853                if (5 === ownerDocument.tag || 6 === ownerDocument.tag)
6854                  nextResource.appendChild(ownerDocument.stateNode);
6855                else if (4 !== ownerDocument.tag && 27 !== ownerDocument.tag && null !== ownerDocument.child) {
6856                  ownerDocument.child.return = ownerDocument;
6857                  ownerDocument = ownerDocument.child;
6858                  continue;
6859                }
6860                if (ownerDocument === workInProgress2) break a;
6861                for (; null === ownerDocument.sibling; ) {
6862                  if (null === ownerDocument.return || ownerDocument.return === workInProgress2)
6863                    break a;
6864                  ownerDocument = ownerDocument.return;
6865                }
6866                ownerDocument.sibling.return = ownerDocument.return;
6867                ownerDocument = ownerDocument.sibling;
6868              }
6869              workInProgress2.stateNode = nextResource;
6870              a: switch (setInitialProperties(nextResource, type2, newProps), type2) {
6871                case "button":
6872                case "input":
6873                case "select":
6874                case "textarea":
6875                  newProps = !!newProps.autoFocus;
6876                  break a;
6877                case "img":
6878                  newProps = true;
6879                  break a;
6880                default:
6881                  newProps = false;

vendor: 61,078 bytes, lines 6882-8131

6882              }
6883              newProps && markUpdate(workInProgress2);
6884            }
6885          }
6886          bubbleProperties(workInProgress2);
6887          preloadInstanceAndSuspendIfNeeded(
6888            workInProgress2,
6889            workInProgress2.type,
6890            null === current ? null : current.memoizedProps,
6891            workInProgress2.pendingProps,
6892            renderLanes2
6893          );
6894          return null;
6895        case 6:
6896          if (current && null != workInProgress2.stateNode)
6897            current.memoizedProps !== newProps && markUpdate(workInProgress2);
6898          else {
6899            if ("string" !== typeof newProps && null === workInProgress2.stateNode)
6900              throw Error(formatProdErrorMessage(166));
6901            current = rootInstanceStackCursor.current;
6902            if (popHydrationState(workInProgress2)) {
6903              current = workInProgress2.stateNode;
6904              renderLanes2 = workInProgress2.memoizedProps;
6905              newProps = null;
6906              type2 = hydrationParentFiber;
6907              if (null !== type2)
6908                switch (type2.tag) {
6909                  case 27:
6910                  case 5:
6911                    newProps = type2.memoizedProps;
6912                }
6913              current[internalInstanceKey] = workInProgress2;
6914              current = current.nodeValue === renderLanes2 || null !== newProps && true === newProps.suppressHydrationWarning || checkForUnmatchedText(current.nodeValue, renderLanes2) ? true : false;
6915              current || throwOnHydrationMismatch(workInProgress2, true);
6916            } else
6917              current = getOwnerDocumentFromRootContainer(current).createTextNode(
6918                newProps
6919              ), current[internalInstanceKey] = workInProgress2, workInProgress2.stateNode = current;
6920          }
6921          bubbleProperties(workInProgress2);
6922          return null;
6923        case 31:
6924          renderLanes2 = workInProgress2.memoizedState;
6925          if (null === current || null !== current.memoizedState) {
6926            newProps = popHydrationState(workInProgress2);
6927            if (null !== renderLanes2) {
6928              if (null === current) {
6929                if (!newProps) throw Error(formatProdErrorMessage(318));
6930                current = workInProgress2.memoizedState;
6931                current = null !== current ? current.dehydrated : null;
6932                if (!current) throw Error(formatProdErrorMessage(557));
6933                current[internalInstanceKey] = workInProgress2;
6934              } else
6935                resetHydrationState(), 0 === (workInProgress2.flags & 128) && (workInProgress2.memoizedState = null), workInProgress2.flags |= 4;
6936              bubbleProperties(workInProgress2);
6937              current = false;
6938            } else
6939              renderLanes2 = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = renderLanes2), current = true;
6940            if (!current) {
6941              if (workInProgress2.flags & 256)
6942                return popSuspenseHandler(workInProgress2), workInProgress2;
6943              popSuspenseHandler(workInProgress2);
6944              return null;
6945            }
6946            if (0 !== (workInProgress2.flags & 128))
6947              throw Error(formatProdErrorMessage(558));
6948          }
6949          bubbleProperties(workInProgress2);
6950          return null;
6951        case 13:
6952          newProps = workInProgress2.memoizedState;
6953          if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
6954            type2 = popHydrationState(workInProgress2);
6955            if (null !== newProps && null !== newProps.dehydrated) {
6956              if (null === current) {
6957                if (!type2) throw Error(formatProdErrorMessage(318));
6958                type2 = workInProgress2.memoizedState;
6959                type2 = null !== type2 ? type2.dehydrated : null;
6960                if (!type2) throw Error(formatProdErrorMessage(317));
6961                type2[internalInstanceKey] = workInProgress2;
6962              } else
6963                resetHydrationState(), 0 === (workInProgress2.flags & 128) && (workInProgress2.memoizedState = null), workInProgress2.flags |= 4;
6964              bubbleProperties(workInProgress2);
6965              type2 = false;
6966            } else
6967              type2 = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = type2), type2 = true;
6968            if (!type2) {
6969              if (workInProgress2.flags & 256)
6970                return popSuspenseHandler(workInProgress2), workInProgress2;
6971              popSuspenseHandler(workInProgress2);
6972              return null;
6973            }
6974          }
6975          popSuspenseHandler(workInProgress2);
6976          if (0 !== (workInProgress2.flags & 128))
6977            return workInProgress2.lanes = renderLanes2, workInProgress2;
6978          renderLanes2 = null !== newProps;
6979          current = null !== current && null !== current.memoizedState;
6980          renderLanes2 && (newProps = workInProgress2.child, type2 = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (type2 = newProps.alternate.memoizedState.cachePool.pool), nextResource = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (nextResource = newProps.memoizedState.cachePool.pool), nextResource !== type2 && (newProps.flags |= 2048));
6981          renderLanes2 !== current && renderLanes2 && (workInProgress2.child.flags |= 8192);
6982          scheduleRetryEffect(workInProgress2, workInProgress2.updateQueue);
6983          bubbleProperties(workInProgress2);
6984          return null;
6985        case 4:
6986          return popHostContainer(), null === current && listenToAllSupportedEvents(workInProgress2.stateNode.containerInfo), bubbleProperties(workInProgress2), null;
6987        case 10:
6988          return popProvider(workInProgress2.type), bubbleProperties(workInProgress2), null;
6989        case 19:
6990          pop(suspenseStackCursor);
6991          newProps = workInProgress2.memoizedState;
6992          if (null === newProps) return bubbleProperties(workInProgress2), null;
6993          type2 = 0 !== (workInProgress2.flags & 128);
6994          nextResource = newProps.rendering;
6995          if (null === nextResource)
6996            if (type2) cutOffTailIfNeeded(newProps, false);
6997            else {
6998              if (0 !== workInProgressRootExitStatus || null !== current && 0 !== (current.flags & 128))
6999                for (current = workInProgress2.child; null !== current; ) {
7000                  nextResource = findFirstSuspended(current);
7001                  if (null !== nextResource) {
7002                    workInProgress2.flags |= 128;
7003                    cutOffTailIfNeeded(newProps, false);
7004                    current = nextResource.updateQueue;
7005                    workInProgress2.updateQueue = current;
7006                    scheduleRetryEffect(workInProgress2, current);
7007                    workInProgress2.subtreeFlags = 0;
7008                    current = renderLanes2;
7009                    for (renderLanes2 = workInProgress2.child; null !== renderLanes2; )
7010                      resetWorkInProgress(renderLanes2, current), renderLanes2 = renderLanes2.sibling;
7011                    push(
7012                      suspenseStackCursor,
7013                      suspenseStackCursor.current & 1 | 2
7014                    );
7015                    isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount);
7016                    return workInProgress2.child;
7017                  }
7018                  current = current.sibling;
7019                }
7020              null !== newProps.tail && now() > workInProgressRootRenderTargetTime && (workInProgress2.flags |= 128, type2 = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
7021            }
7022          else {
7023            if (!type2)
7024              if (current = findFirstSuspended(nextResource), null !== current) {
7025                if (workInProgress2.flags |= 128, type2 = true, current = current.updateQueue, workInProgress2.updateQueue = current, scheduleRetryEffect(workInProgress2, current), cutOffTailIfNeeded(newProps, true), null === newProps.tail && "hidden" === newProps.tailMode && !nextResource.alternate && !isHydrating)
7026                  return bubbleProperties(workInProgress2), null;
7027              } else
7028                2 * now() - newProps.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes2 && (workInProgress2.flags |= 128, type2 = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
7029            newProps.isBackwards ? (nextResource.sibling = workInProgress2.child, workInProgress2.child = nextResource) : (current = newProps.last, null !== current ? current.sibling = nextResource : workInProgress2.child = nextResource, newProps.last = nextResource);
7030          }
7031          if (null !== newProps.tail)
7032            return current = newProps.tail, newProps.rendering = current, newProps.tail = current.sibling, newProps.renderingStartTime = now(), current.sibling = null, renderLanes2 = suspenseStackCursor.current, push(
7033              suspenseStackCursor,
7034              type2 ? renderLanes2 & 1 | 2 : renderLanes2 & 1
7035            ), isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount), current;
7036          bubbleProperties(workInProgress2);
7037          return null;
7038        case 22:
7039        case 23:
7040          return popSuspenseHandler(workInProgress2), popHiddenContext(), newProps = null !== workInProgress2.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress2.flags |= 8192) : newProps && (workInProgress2.flags |= 8192), newProps ? 0 !== (renderLanes2 & 536870912) && 0 === (workInProgress2.flags & 128) && (bubbleProperties(workInProgress2), workInProgress2.subtreeFlags & 6 && (workInProgress2.flags |= 8192)) : bubbleProperties(workInProgress2), renderLanes2 = workInProgress2.updateQueue, null !== renderLanes2 && scheduleRetryEffect(workInProgress2, renderLanes2.retryQueue), renderLanes2 = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (renderLanes2 = current.memoizedState.cachePool.pool), newProps = null, null !== workInProgress2.memoizedState && null !== workInProgress2.memoizedState.cachePool && (newProps = workInProgress2.memoizedState.cachePool.pool), newProps !== renderLanes2 && (workInProgress2.flags |= 2048), null !== current && pop(resumedCache), null;
7041        case 24:
7042          return renderLanes2 = null, null !== current && (renderLanes2 = current.memoizedState.cache), workInProgress2.memoizedState.cache !== renderLanes2 && (workInProgress2.flags |= 2048), popProvider(CacheContext), bubbleProperties(workInProgress2), null;
7043        case 25:
7044          return null;
7045        case 30:
7046          return null;
7047      }
7048      throw Error(formatProdErrorMessage(156, workInProgress2.tag));
7049    }
7050    function unwindWork(current, workInProgress2) {
7051      popTreeContext(workInProgress2);
7052      switch (workInProgress2.tag) {
7053        case 1:
7054          return current = workInProgress2.flags, current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
7055        case 3:
7056          return popProvider(CacheContext), popHostContainer(), current = workInProgress2.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
7057        case 26:
7058        case 27:
7059        case 5:
7060          return popHostContext(workInProgress2), null;
7061        case 31:
7062          if (null !== workInProgress2.memoizedState) {
7063            popSuspenseHandler(workInProgress2);
7064            if (null === workInProgress2.alternate)
7065              throw Error(formatProdErrorMessage(340));
7066            resetHydrationState();
7067          }
7068          current = workInProgress2.flags;
7069          return current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
7070        case 13:
7071          popSuspenseHandler(workInProgress2);
7072          current = workInProgress2.memoizedState;
7073          if (null !== current && null !== current.dehydrated) {
7074            if (null === workInProgress2.alternate)
7075              throw Error(formatProdErrorMessage(340));
7076            resetHydrationState();
7077          }
7078          current = workInProgress2.flags;
7079          return current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
7080        case 19:
7081          return pop(suspenseStackCursor), null;
7082        case 4:
7083          return popHostContainer(), null;
7084        case 10:
7085          return popProvider(workInProgress2.type), null;
7086        case 22:
7087        case 23:
7088          return popSuspenseHandler(workInProgress2), popHiddenContext(), null !== current && pop(resumedCache), current = workInProgress2.flags, current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
7089        case 24:
7090          return popProvider(CacheContext), null;
7091        case 25:
7092          return null;
7093        default:
7094          return null;
7095      }
7096    }
7097    function unwindInterruptedWork(current, interruptedWork) {
7098      popTreeContext(interruptedWork);
7099      switch (interruptedWork.tag) {
7100        case 3:
7101          popProvider(CacheContext);
7102          popHostContainer();
7103          break;
7104        case 26:
7105        case 27:
7106        case 5:
7107          popHostContext(interruptedWork);
7108          break;
7109        case 4:
7110          popHostContainer();
7111          break;
7112        case 31:
7113          null !== interruptedWork.memoizedState && popSuspenseHandler(interruptedWork);
7114          break;
7115        case 13:
7116          popSuspenseHandler(interruptedWork);
7117          break;
7118        case 19:
7119          pop(suspenseStackCursor);
7120          break;
7121        case 10:
7122          popProvider(interruptedWork.type);
7123          break;
7124        case 22:
7125        case 23:
7126          popSuspenseHandler(interruptedWork);
7127          popHiddenContext();
7128          null !== current && pop(resumedCache);
7129          break;
7130        case 24:
7131          popProvider(CacheContext);
7132      }
7133    }
7134    function commitHookEffectListMount(flags, finishedWork) {
7135      try {
7136        var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
7137        if (null !== lastEffect) {
7138          var firstEffect = lastEffect.next;
7139          updateQueue = firstEffect;
7140          do {
7141            if ((updateQueue.tag & flags) === flags) {
7142              lastEffect = void 0;
7143              var create2 = updateQueue.create, inst = updateQueue.inst;
7144              lastEffect = create2();
7145              inst.destroy = lastEffect;
7146            }
7147            updateQueue = updateQueue.next;
7148          } while (updateQueue !== firstEffect);
7149        }
7150      } catch (error) {
7151        captureCommitPhaseError(finishedWork, finishedWork.return, error);
7152      }
7153    }
7154    function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor$jscomp$0) {
7155      try {
7156        var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
7157        if (null !== lastEffect) {
7158          var firstEffect = lastEffect.next;
7159          updateQueue = firstEffect;
7160          do {
7161            if ((updateQueue.tag & flags) === flags) {
7162              var inst = updateQueue.inst, destroy = inst.destroy;
7163              if (void 0 !== destroy) {
7164                inst.destroy = void 0;
7165                lastEffect = finishedWork;
7166                var nearestMountedAncestor = nearestMountedAncestor$jscomp$0, destroy_ = destroy;
7167                try {
7168                  destroy_();
7169                } catch (error) {
7170                  captureCommitPhaseError(
7171                    lastEffect,
7172                    nearestMountedAncestor,
7173                    error
7174                  );
7175                }
7176              }
7177            }
7178            updateQueue = updateQueue.next;
7179          } while (updateQueue !== firstEffect);
7180        }
7181      } catch (error) {
7182        captureCommitPhaseError(finishedWork, finishedWork.return, error);
7183      }
7184    }
7185    function commitClassCallbacks(finishedWork) {
7186      var updateQueue = finishedWork.updateQueue;
7187      if (null !== updateQueue) {
7188        var instance = finishedWork.stateNode;
7189        try {
7190          commitCallbacks(updateQueue, instance);
7191        } catch (error) {
7192          captureCommitPhaseError(finishedWork, finishedWork.return, error);
7193        }
7194      }
7195    }
7196    function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
7197      instance.props = resolveClassComponentProps(
7198        current.type,
7199        current.memoizedProps
7200      );
7201      instance.state = current.memoizedState;
7202      try {
7203        instance.componentWillUnmount();
7204      } catch (error) {
7205        captureCommitPhaseError(current, nearestMountedAncestor, error);
7206      }
7207    }
7208    function safelyAttachRef(current, nearestMountedAncestor) {
7209      try {
7210        var ref2 = current.ref;
7211        if (null !== ref2) {
7212          switch (current.tag) {
7213            case 26:
7214            case 27:
7215            case 5:
7216              var instanceToUse = current.stateNode;
7217              break;
7218            case 30:
7219              instanceToUse = current.stateNode;
7220              break;
7221            default:
7222              instanceToUse = current.stateNode;
7223          }
7224          "function" === typeof ref2 ? current.refCleanup = ref2(instanceToUse) : ref2.current = instanceToUse;
7225        }
7226      } catch (error) {
7227        captureCommitPhaseError(current, nearestMountedAncestor, error);
7228      }
7229    }
7230    function safelyDetachRef(current, nearestMountedAncestor) {
7231      var ref2 = current.ref, refCleanup = current.refCleanup;
7232      if (null !== ref2)
7233        if ("function" === typeof refCleanup)
7234          try {
7235            refCleanup();
7236          } catch (error) {
7237            captureCommitPhaseError(current, nearestMountedAncestor, error);
7238          } finally {
7239            current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
7240          }
7241        else if ("function" === typeof ref2)
7242          try {
7243            ref2(null);
7244          } catch (error$140) {
7245            captureCommitPhaseError(current, nearestMountedAncestor, error$140);
7246          }
7247        else ref2.current = null;
7248    }
7249    function commitHostMount(finishedWork) {
7250      var type2 = finishedWork.type, props = finishedWork.memoizedProps, instance = finishedWork.stateNode;
7251      try {
7252        a: switch (type2) {
7253          case "button":
7254          case "input":
7255          case "select":
7256          case "textarea":
7257            props.autoFocus && instance.focus();
7258            break a;
7259          case "img":
7260            props.src ? instance.src = props.src : props.srcSet && (instance.srcset = props.srcSet);
7261        }
7262      } catch (error) {
7263        captureCommitPhaseError(finishedWork, finishedWork.return, error);
7264      }
7265    }
7266    function commitHostUpdate(finishedWork, newProps, oldProps) {
7267      try {
7268        var domElement = finishedWork.stateNode;
7269        updateProperties(domElement, finishedWork.type, oldProps, newProps);
7270        domElement[internalPropsKey] = newProps;
7271      } catch (error) {
7272        captureCommitPhaseError(finishedWork, finishedWork.return, error);
7273      }
7274    }
7275    function isHostParent(fiber) {
7276      return 5 === fiber.tag || 3 === fiber.tag || 26 === fiber.tag || 27 === fiber.tag && isSingletonScope(fiber.type) || 4 === fiber.tag;
7277    }
7278    function getHostSibling(fiber) {
7279      a: for (; ; ) {
7280        for (; null === fiber.sibling; ) {
7281          if (null === fiber.return || isHostParent(fiber.return)) return null;
7282          fiber = fiber.return;
7283        }
7284        fiber.sibling.return = fiber.return;
7285        for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag; ) {
7286          if (27 === fiber.tag && isSingletonScope(fiber.type)) continue a;
7287          if (fiber.flags & 2) continue a;
7288          if (null === fiber.child || 4 === fiber.tag) continue a;
7289          else fiber.child.return = fiber, fiber = fiber.child;
7290        }
7291        if (!(fiber.flags & 2)) return fiber.stateNode;
7292      }
7293    }
7294    function insertOrAppendPlacementNodeIntoContainer(node2, before, parent) {
7295      var tag = node2.tag;
7296      if (5 === tag || 6 === tag)
7297        node2 = node2.stateNode, before ? (9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent).insertBefore(node2, before) : (before = 9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent, before.appendChild(node2), parent = parent._reactRootContainer, null !== parent && void 0 !== parent || null !== before.onclick || (before.onclick = noop$12));
7298      else if (4 !== tag && (27 === tag && isSingletonScope(node2.type) && (parent = node2.stateNode, before = null), node2 = node2.child, null !== node2))
7299        for (insertOrAppendPlacementNodeIntoContainer(node2, before, parent), node2 = node2.sibling; null !== node2; )
7300          insertOrAppendPlacementNodeIntoContainer(node2, before, parent), node2 = node2.sibling;
7301    }
7302    function insertOrAppendPlacementNode(node2, before, parent) {
7303      var tag = node2.tag;
7304      if (5 === tag || 6 === tag)
7305        node2 = node2.stateNode, before ? parent.insertBefore(node2, before) : parent.appendChild(node2);
7306      else if (4 !== tag && (27 === tag && isSingletonScope(node2.type) && (parent = node2.stateNode), node2 = node2.child, null !== node2))
7307        for (insertOrAppendPlacementNode(node2, before, parent), node2 = node2.sibling; null !== node2; )
7308          insertOrAppendPlacementNode(node2, before, parent), node2 = node2.sibling;
7309    }
7310    function commitHostSingletonAcquisition(finishedWork) {
7311      var singleton = finishedWork.stateNode, props = finishedWork.memoizedProps;
7312      try {
7313        for (var type2 = finishedWork.type, attributes = singleton.attributes; attributes.length; )
7314          singleton.removeAttributeNode(attributes[0]);
7315        setInitialProperties(singleton, type2, props);
7316        singleton[internalInstanceKey] = finishedWork;
7317        singleton[internalPropsKey] = props;
7318      } catch (error) {
7319        captureCommitPhaseError(finishedWork, finishedWork.return, error);
7320      }
7321    }
7322    var offscreenSubtreeIsHidden = false, offscreenSubtreeWasHidden = false, needsFormReset = false, PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set, nextEffect = null;
7323    function commitBeforeMutationEffects(root2, firstChild) {
7324      root2 = root2.containerInfo;
7325      eventsEnabled = _enabled;
7326      root2 = getActiveElementDeep(root2);
7327      if (hasSelectionCapabilities(root2)) {
7328        if ("selectionStart" in root2)
7329          var JSCompiler_temp = {
7330            start: root2.selectionStart,
7331            end: root2.selectionEnd
7332          };
7333        else
7334          a: {
7335            JSCompiler_temp = (JSCompiler_temp = root2.ownerDocument) && JSCompiler_temp.defaultView || window;
7336            var selection = JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
7337            if (selection && 0 !== selection.rangeCount) {
7338              JSCompiler_temp = selection.anchorNode;
7339              var anchorOffset = selection.anchorOffset, focusNode = selection.focusNode;
7340              selection = selection.focusOffset;
7341              try {
7342                JSCompiler_temp.nodeType, focusNode.nodeType;
7343              } catch (e$20) {
7344                JSCompiler_temp = null;
7345                break a;
7346              }
7347              var length = 0, start = -1, end = -1, indexWithinAnchor = 0, indexWithinFocus = 0, node2 = root2, parentNode = null;
7348              b: for (; ; ) {
7349                for (var next; ; ) {
7350                  node2 !== JSCompiler_temp || 0 !== anchorOffset && 3 !== node2.nodeType || (start = length + anchorOffset);
7351                  node2 !== focusNode || 0 !== selection && 3 !== node2.nodeType || (end = length + selection);
7352                  3 === node2.nodeType && (length += node2.nodeValue.length);
7353                  if (null === (next = node2.firstChild)) break;
7354                  parentNode = node2;
7355                  node2 = next;
7356                }
7357                for (; ; ) {
7358                  if (node2 === root2) break b;
7359                  parentNode === JSCompiler_temp && ++indexWithinAnchor === anchorOffset && (start = length);
7360                  parentNode === focusNode && ++indexWithinFocus === selection && (end = length);
7361                  if (null !== (next = node2.nextSibling)) break;
7362                  node2 = parentNode;
7363                  parentNode = node2.parentNode;
7364                }
7365                node2 = next;
7366              }
7367              JSCompiler_temp = -1 === start || -1 === end ? null : { start, end };
7368            } else JSCompiler_temp = null;
7369          }
7370        JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
7371      } else JSCompiler_temp = null;
7372      selectionInformation = { focusedElem: root2, selectionRange: JSCompiler_temp };
7373      _enabled = false;
7374      for (nextEffect = firstChild; null !== nextEffect; )
7375        if (firstChild = nextEffect, root2 = firstChild.child, 0 !== (firstChild.subtreeFlags & 1028) && null !== root2)
7376          root2.return = firstChild, nextEffect = root2;
7377        else
7378          for (; null !== nextEffect; ) {
7379            firstChild = nextEffect;
7380            focusNode = firstChild.alternate;
7381            root2 = firstChild.flags;
7382            switch (firstChild.tag) {
7383              case 0:
7384                if (0 !== (root2 & 4) && (root2 = firstChild.updateQueue, root2 = null !== root2 ? root2.events : null, null !== root2))
7385                  for (JSCompiler_temp = 0; JSCompiler_temp < root2.length; JSCompiler_temp++)
7386                    anchorOffset = root2[JSCompiler_temp], anchorOffset.ref.impl = anchorOffset.nextImpl;
7387                break;
7388              case 11:
7389              case 15:
7390                break;
7391              case 1:
7392                if (0 !== (root2 & 1024) && null !== focusNode) {
7393                  root2 = void 0;
7394                  JSCompiler_temp = firstChild;
7395                  anchorOffset = focusNode.memoizedProps;
7396                  focusNode = focusNode.memoizedState;
7397                  selection = JSCompiler_temp.stateNode;
7398                  try {
7399                    var resolvedPrevProps = resolveClassComponentProps(
7400                      JSCompiler_temp.type,
7401                      anchorOffset
7402                    );
7403                    root2 = selection.getSnapshotBeforeUpdate(
7404                      resolvedPrevProps,
7405                      focusNode
7406                    );
7407                    selection.__reactInternalSnapshotBeforeUpdate = root2;
7408                  } catch (error) {
7409                    captureCommitPhaseError(
7410                      JSCompiler_temp,
7411                      JSCompiler_temp.return,
7412                      error
7413                    );
7414                  }
7415                }
7416                break;
7417              case 3:
7418                if (0 !== (root2 & 1024)) {
7419                  if (root2 = firstChild.stateNode.containerInfo, JSCompiler_temp = root2.nodeType, 9 === JSCompiler_temp)
7420                    clearContainerSparingly(root2);
7421                  else if (1 === JSCompiler_temp)
7422                    switch (root2.nodeName) {
7423                      case "HEAD":
7424                      case "HTML":
7425                      case "BODY":
7426                        clearContainerSparingly(root2);
7427                        break;
7428                      default:
7429                        root2.textContent = "";
7430                    }
7431                }
7432                break;
7433              case 5:
7434              case 26:
7435              case 27:
7436              case 6:
7437              case 4:
7438              case 17:
7439                break;
7440              default:
7441                if (0 !== (root2 & 1024)) throw Error(formatProdErrorMessage(163));
7442            }
7443            root2 = firstChild.sibling;
7444            if (null !== root2) {
7445              root2.return = firstChild.return;
7446              nextEffect = root2;
7447              break;
7448            }
7449            nextEffect = firstChild.return;
7450          }
7451    }
7452    function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
7453      var flags = finishedWork.flags;
7454      switch (finishedWork.tag) {
7455        case 0:
7456        case 11:
7457        case 15:
7458          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7459          flags & 4 && commitHookEffectListMount(5, finishedWork);
7460          break;
7461        case 1:
7462          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7463          if (flags & 4)
7464            if (finishedRoot = finishedWork.stateNode, null === current)
7465              try {
7466                finishedRoot.componentDidMount();
7467              } catch (error) {
7468                captureCommitPhaseError(finishedWork, finishedWork.return, error);
7469              }
7470            else {
7471              var prevProps = resolveClassComponentProps(
7472                finishedWork.type,
7473                current.memoizedProps
7474              );
7475              current = current.memoizedState;
7476              try {
7477                finishedRoot.componentDidUpdate(
7478                  prevProps,
7479                  current,
7480                  finishedRoot.__reactInternalSnapshotBeforeUpdate
7481                );
7482              } catch (error$139) {
7483                captureCommitPhaseError(
7484                  finishedWork,
7485                  finishedWork.return,
7486                  error$139
7487                );
7488              }
7489            }
7490          flags & 64 && commitClassCallbacks(finishedWork);
7491          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
7492          break;
7493        case 3:
7494          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7495          if (flags & 64 && (finishedRoot = finishedWork.updateQueue, null !== finishedRoot)) {
7496            current = null;
7497            if (null !== finishedWork.child)
7498              switch (finishedWork.child.tag) {
7499                case 27:
7500                case 5:
7501                  current = finishedWork.child.stateNode;
7502                  break;
7503                case 1:
7504                  current = finishedWork.child.stateNode;
7505              }
7506            try {
7507              commitCallbacks(finishedRoot, current);
7508            } catch (error) {
7509              captureCommitPhaseError(finishedWork, finishedWork.return, error);
7510            }
7511          }
7512          break;
7513        case 27:
7514          null === current && flags & 4 && commitHostSingletonAcquisition(finishedWork);
7515        case 26:
7516        case 5:
7517          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7518          null === current && flags & 4 && commitHostMount(finishedWork);
7519          flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
7520          break;
7521        case 12:
7522          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7523          break;
7524        case 31:
7525          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7526          flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
7527          break;
7528        case 13:
7529          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7530          flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
7531          flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot && (finishedWork = retryDehydratedSuspenseBoundary.bind(
7532            null,
7533            finishedWork
7534          ), registerSuspenseInstanceRetry(finishedRoot, finishedWork))));
7535          break;
7536        case 22:
7537          flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden;
7538          if (!flags) {
7539            current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
7540            prevProps = offscreenSubtreeIsHidden;
7541            var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
7542            offscreenSubtreeIsHidden = flags;
7543            (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(
7544              finishedRoot,
7545              finishedWork,
7546              0 !== (finishedWork.subtreeFlags & 8772)
7547            ) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7548            offscreenSubtreeIsHidden = prevProps;
7549            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
7550          }
7551          break;
7552        case 30:
7553          break;
7554        default:
7555          recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
7556      }
7557    }
7558    function detachFiberAfterEffects(fiber) {
7559      var alternate = fiber.alternate;
7560      null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
7561      fiber.child = null;
7562      fiber.deletions = null;
7563      fiber.sibling = null;
7564      5 === fiber.tag && (alternate = fiber.stateNode, null !== alternate && detachDeletedInstance(alternate));
7565      fiber.stateNode = null;
7566      fiber.return = null;
7567      fiber.dependencies = null;
7568      fiber.memoizedProps = null;
7569      fiber.memoizedState = null;
7570      fiber.pendingProps = null;
7571      fiber.stateNode = null;
7572      fiber.updateQueue = null;
7573    }
7574    var hostParent = null, hostParentIsContainer = false;
7575    function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
7576      for (parent = parent.child; null !== parent; )
7577        commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
7578    }
7579    function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
7580      if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
7581        try {
7582          injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
7583        } catch (err) {
7584        }
7585      switch (deletedFiber.tag) {
7586        case 26:
7587          offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
7588          recursivelyTraverseDeletionEffects(
7589            finishedRoot,
7590            nearestMountedAncestor,
7591            deletedFiber
7592          );
7593          deletedFiber.memoizedState ? deletedFiber.memoizedState.count-- : deletedFiber.stateNode && (deletedFiber = deletedFiber.stateNode, deletedFiber.parentNode.removeChild(deletedFiber));
7594          break;
7595        case 27:
7596          offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
7597          var prevHostParent = hostParent, prevHostParentIsContainer = hostParentIsContainer;
7598          isSingletonScope(deletedFiber.type) && (hostParent = deletedFiber.stateNode, hostParentIsContainer = false);
7599          recursivelyTraverseDeletionEffects(
7600            finishedRoot,
7601            nearestMountedAncestor,
7602            deletedFiber
7603          );
7604          releaseSingletonInstance(deletedFiber.stateNode);
7605          hostParent = prevHostParent;
7606          hostParentIsContainer = prevHostParentIsContainer;
7607          break;
7608        case 5:
7609          offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
7610        case 6:
7611          prevHostParent = hostParent;
7612          prevHostParentIsContainer = hostParentIsContainer;
7613          hostParent = null;
7614          recursivelyTraverseDeletionEffects(
7615            finishedRoot,
7616            nearestMountedAncestor,
7617            deletedFiber
7618          );
7619          hostParent = prevHostParent;
7620          hostParentIsContainer = prevHostParentIsContainer;
7621          if (null !== hostParent)
7622            if (hostParentIsContainer)
7623              try {
7624                (9 === hostParent.nodeType ? hostParent.body : "HTML" === hostParent.nodeName ? hostParent.ownerDocument.body : hostParent).removeChild(deletedFiber.stateNode);
7625              } catch (error) {
7626                captureCommitPhaseError(
7627                  deletedFiber,
7628                  nearestMountedAncestor,
7629                  error
7630                );
7631              }
7632            else
7633              try {
7634                hostParent.removeChild(deletedFiber.stateNode);
7635              } catch (error) {
7636                captureCommitPhaseError(
7637                  deletedFiber,
7638                  nearestMountedAncestor,
7639                  error
7640                );
7641              }
7642          break;
7643        case 18:
7644          null !== hostParent && (hostParentIsContainer ? (finishedRoot = hostParent, clearHydrationBoundary(
7645            9 === finishedRoot.nodeType ? finishedRoot.body : "HTML" === finishedRoot.nodeName ? finishedRoot.ownerDocument.body : finishedRoot,
7646            deletedFiber.stateNode
7647          ), retryIfBlockedOn(finishedRoot)) : clearHydrationBoundary(hostParent, deletedFiber.stateNode));
7648          break;
7649        case 4:
7650          prevHostParent = hostParent;
7651          prevHostParentIsContainer = hostParentIsContainer;
7652          hostParent = deletedFiber.stateNode.containerInfo;
7653          hostParentIsContainer = true;
7654          recursivelyTraverseDeletionEffects(
7655            finishedRoot,
7656            nearestMountedAncestor,
7657            deletedFiber
7658          );
7659          hostParent = prevHostParent;
7660          hostParentIsContainer = prevHostParentIsContainer;
7661          break;
7662        case 0:
7663        case 11:
7664        case 14:
7665        case 15:
7666          commitHookEffectListUnmount(2, deletedFiber, nearestMountedAncestor);
7667          offscreenSubtreeWasHidden || commitHookEffectListUnmount(4, deletedFiber, nearestMountedAncestor);
7668          recursivelyTraverseDeletionEffects(
7669            finishedRoot,
7670            nearestMountedAncestor,
7671            deletedFiber
7672          );
7673          break;
7674        case 1:
7675          offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), prevHostParent = deletedFiber.stateNode, "function" === typeof prevHostParent.componentWillUnmount && safelyCallComponentWillUnmount(
7676            deletedFiber,
7677            nearestMountedAncestor,
7678            prevHostParent
7679          ));
7680          recursivelyTraverseDeletionEffects(
7681            finishedRoot,
7682            nearestMountedAncestor,
7683            deletedFiber
7684          );
7685          break;
7686        case 21:
7687          recursivelyTraverseDeletionEffects(
7688            finishedRoot,
7689            nearestMountedAncestor,
7690            deletedFiber
7691          );
7692          break;
7693        case 22:
7694          offscreenSubtreeWasHidden = (prevHostParent = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState;
7695          recursivelyTraverseDeletionEffects(
7696            finishedRoot,
7697            nearestMountedAncestor,
7698            deletedFiber
7699          );
7700          offscreenSubtreeWasHidden = prevHostParent;
7701          break;
7702        default:
7703          recursivelyTraverseDeletionEffects(
7704            finishedRoot,
7705            nearestMountedAncestor,
7706            deletedFiber
7707          );
7708      }
7709    }
7710    function commitActivityHydrationCallbacks(finishedRoot, finishedWork) {
7711      if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot))) {
7712        finishedRoot = finishedRoot.dehydrated;
7713        try {
7714          retryIfBlockedOn(finishedRoot);
7715        } catch (error) {
7716          captureCommitPhaseError(finishedWork, finishedWork.return, error);
7717        }
7718      }
7719    }
7720    function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
7721      if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot))))
7722        try {
7723          retryIfBlockedOn(finishedRoot);
7724        } catch (error) {
7725          captureCommitPhaseError(finishedWork, finishedWork.return, error);
7726        }
7727    }
7728    function getRetryCache(finishedWork) {
7729      switch (finishedWork.tag) {
7730        case 31:
7731        case 13:
7732        case 19:
7733          var retryCache = finishedWork.stateNode;
7734          null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
7735          return retryCache;
7736        case 22:
7737          return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
7738        default:
7739          throw Error(formatProdErrorMessage(435, finishedWork.tag));
7740      }
7741    }
7742    function attachSuspenseRetryListeners(finishedWork, wakeables) {
7743      var retryCache = getRetryCache(finishedWork);
7744      wakeables.forEach(function(wakeable) {
7745        if (!retryCache.has(wakeable)) {
7746          retryCache.add(wakeable);
7747          var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
7748          wakeable.then(retry, retry);
7749        }
7750      });
7751    }
7752    function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
7753      var deletions = parentFiber.deletions;
7754      if (null !== deletions)
7755        for (var i2 = 0; i2 < deletions.length; i2++) {
7756          var childToDelete = deletions[i2], root2 = root$jscomp$0, returnFiber = parentFiber, parent = returnFiber;
7757          a: for (; null !== parent; ) {
7758            switch (parent.tag) {
7759              case 27:
7760                if (isSingletonScope(parent.type)) {
7761                  hostParent = parent.stateNode;
7762                  hostParentIsContainer = false;
7763                  break a;
7764                }
7765                break;
7766              case 5:
7767                hostParent = parent.stateNode;
7768                hostParentIsContainer = false;
7769                break a;
7770              case 3:
7771              case 4:
7772                hostParent = parent.stateNode.containerInfo;
7773                hostParentIsContainer = true;
7774                break a;
7775            }
7776            parent = parent.return;
7777          }
7778          if (null === hostParent) throw Error(formatProdErrorMessage(160));
7779          commitDeletionEffectsOnFiber(root2, returnFiber, childToDelete);
7780          hostParent = null;
7781          hostParentIsContainer = false;
7782          root2 = childToDelete.alternate;
7783          null !== root2 && (root2.return = null);
7784          childToDelete.return = null;
7785        }
7786      if (parentFiber.subtreeFlags & 13886)
7787        for (parentFiber = parentFiber.child; null !== parentFiber; )
7788          commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
7789    }
7790    var currentHoistableRoot = null;
7791    function commitMutationEffectsOnFiber(finishedWork, root2) {
7792      var current = finishedWork.alternate, flags = finishedWork.flags;
7793      switch (finishedWork.tag) {
7794        case 0:
7795        case 11:
7796        case 14:
7797        case 15:
7798          recursivelyTraverseMutationEffects(root2, finishedWork);
7799          commitReconciliationEffects(finishedWork);
7800          flags & 4 && (commitHookEffectListUnmount(3, finishedWork, finishedWork.return), commitHookEffectListMount(3, finishedWork), commitHookEffectListUnmount(5, finishedWork, finishedWork.return));
7801          break;
7802        case 1:
7803          recursivelyTraverseMutationEffects(root2, finishedWork);
7804          commitReconciliationEffects(finishedWork);
7805          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
7806          flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (flags = finishedWork.callbacks, null !== flags && (current = finishedWork.shared.hiddenCallbacks, finishedWork.shared.hiddenCallbacks = null === current ? flags : current.concat(flags))));
7807          break;
7808        case 26:
7809          var hoistableRoot = currentHoistableRoot;
7810          recursivelyTraverseMutationEffects(root2, finishedWork);
7811          commitReconciliationEffects(finishedWork);
7812          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
7813          if (flags & 4) {
7814            var currentResource = null !== current ? current.memoizedState : null;
7815            flags = finishedWork.memoizedState;
7816            if (null === current)
7817              if (null === flags)
7818                if (null === finishedWork.stateNode) {
7819                  a: {
7820                    flags = finishedWork.type;
7821                    current = finishedWork.memoizedProps;
7822                    hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
7823                    b: switch (flags) {
7824                      case "title":
7825                        currentResource = hoistableRoot.getElementsByTagName("title")[0];
7826                        if (!currentResource || currentResource[internalHoistableMarker] || currentResource[internalInstanceKey] || "http://www.w3.org/2000/svg" === currentResource.namespaceURI || currentResource.hasAttribute("itemprop"))
7827                          currentResource = hoistableRoot.createElement(flags), hoistableRoot.head.insertBefore(
7828                            currentResource,
7829                            hoistableRoot.querySelector("head > title")
7830                          );
7831                        setInitialProperties(currentResource, flags, current);
7832                        currentResource[internalInstanceKey] = finishedWork;
7833                        markNodeAsHoistable(currentResource);
7834                        flags = currentResource;
7835                        break a;
7836                      case "link":
7837                        var maybeNodes = getHydratableHoistableCache(
7838                          "link",
7839                          "href",
7840                          hoistableRoot
7841                        ).get(flags + (current.href || ""));
7842                        if (maybeNodes) {
7843                          for (var i2 = 0; i2 < maybeNodes.length; i2++)
7844                            if (currentResource = maybeNodes[i2], currentResource.getAttribute("href") === (null == current.href || "" === current.href ? null : current.href) && currentResource.getAttribute("rel") === (null == current.rel ? null : current.rel) && currentResource.getAttribute("title") === (null == current.title ? null : current.title) && currentResource.getAttribute("crossorigin") === (null == current.crossOrigin ? null : current.crossOrigin)) {
7845                              maybeNodes.splice(i2, 1);
7846                              break b;
7847                            }
7848                        }
7849                        currentResource = hoistableRoot.createElement(flags);
7850                        setInitialProperties(currentResource, flags, current);
7851                        hoistableRoot.head.appendChild(currentResource);
7852                        break;
7853                      case "meta":
7854                        if (maybeNodes = getHydratableHoistableCache(
7855                          "meta",
7856                          "content",
7857                          hoistableRoot
7858                        ).get(flags + (current.content || ""))) {
7859                          for (i2 = 0; i2 < maybeNodes.length; i2++)
7860                            if (currentResource = maybeNodes[i2], currentResource.getAttribute("content") === (null == current.content ? null : "" + current.content) && currentResource.getAttribute("name") === (null == current.name ? null : current.name) && currentResource.getAttribute("property") === (null == current.property ? null : current.property) && currentResource.getAttribute("http-equiv") === (null == current.httpEquiv ? null : current.httpEquiv) && currentResource.getAttribute("charset") === (null == current.charSet ? null : current.charSet)) {
7861                              maybeNodes.splice(i2, 1);
7862                              break b;
7863                            }
7864                        }
7865                        currentResource = hoistableRoot.createElement(flags);
7866                        setInitialProperties(currentResource, flags, current);
7867                        hoistableRoot.head.appendChild(currentResource);
7868                        break;
7869                      default:
7870                        throw Error(formatProdErrorMessage(468, flags));
7871                    }
7872                    currentResource[internalInstanceKey] = finishedWork;
7873                    markNodeAsHoistable(currentResource);
7874                    flags = currentResource;
7875                  }
7876                  finishedWork.stateNode = flags;
7877                } else
7878                  mountHoistable(
7879                    hoistableRoot,
7880                    finishedWork.type,
7881                    finishedWork.stateNode
7882                  );
7883              else
7884                finishedWork.stateNode = acquireResource(
7885                  hoistableRoot,
7886                  flags,
7887                  finishedWork.memoizedProps
7888                );
7889            else
7890              currentResource !== flags ? (null === currentResource ? null !== current.stateNode && (current = current.stateNode, current.parentNode.removeChild(current)) : currentResource.count--, null === flags ? mountHoistable(
7891                hoistableRoot,
7892                finishedWork.type,
7893                finishedWork.stateNode
7894              ) : acquireResource(
7895                hoistableRoot,
7896                flags,
7897                finishedWork.memoizedProps
7898              )) : null === flags && null !== finishedWork.stateNode && commitHostUpdate(
7899                finishedWork,
7900                finishedWork.memoizedProps,
7901                current.memoizedProps
7902              );
7903          }
7904          break;
7905        case 27:
7906          recursivelyTraverseMutationEffects(root2, finishedWork);
7907          commitReconciliationEffects(finishedWork);
7908          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
7909          null !== current && flags & 4 && commitHostUpdate(
7910            finishedWork,
7911            finishedWork.memoizedProps,
7912            current.memoizedProps
7913          );
7914          break;
7915        case 5:
7916          recursivelyTraverseMutationEffects(root2, finishedWork);
7917          commitReconciliationEffects(finishedWork);
7918          flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
7919          if (finishedWork.flags & 32) {
7920            hoistableRoot = finishedWork.stateNode;
7921            try {
7922              setTextContent(hoistableRoot, "");
7923            } catch (error) {
7924              captureCommitPhaseError(finishedWork, finishedWork.return, error);
7925            }
7926          }
7927          flags & 4 && null != finishedWork.stateNode && (hoistableRoot = finishedWork.memoizedProps, commitHostUpdate(
7928            finishedWork,
7929            hoistableRoot,
7930            null !== current ? current.memoizedProps : hoistableRoot
7931          ));
7932          flags & 1024 && (needsFormReset = true);
7933          break;
7934        case 6:
7935          recursivelyTraverseMutationEffects(root2, finishedWork);
7936          commitReconciliationEffects(finishedWork);
7937          if (flags & 4) {
7938            if (null === finishedWork.stateNode)
7939              throw Error(formatProdErrorMessage(162));
7940            flags = finishedWork.memoizedProps;
7941            current = finishedWork.stateNode;
7942            try {
7943              current.nodeValue = flags;
7944            } catch (error) {
7945              captureCommitPhaseError(finishedWork, finishedWork.return, error);
7946            }
7947          }
7948          break;
7949        case 3:
7950          tagCaches = null;
7951          hoistableRoot = currentHoistableRoot;
7952          currentHoistableRoot = getHoistableRoot(root2.containerInfo);
7953          recursivelyTraverseMutationEffects(root2, finishedWork);
7954          currentHoistableRoot = hoistableRoot;
7955          commitReconciliationEffects(finishedWork);
7956          if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
7957            try {
7958              retryIfBlockedOn(root2.containerInfo);
7959            } catch (error) {
7960              captureCommitPhaseError(finishedWork, finishedWork.return, error);
7961            }
7962          needsFormReset && (needsFormReset = false, recursivelyResetForms(finishedWork));
7963          break;
7964        case 4:
7965          flags = currentHoistableRoot;
7966          currentHoistableRoot = getHoistableRoot(
7967            finishedWork.stateNode.containerInfo
7968          );
7969          recursivelyTraverseMutationEffects(root2, finishedWork);
7970          commitReconciliationEffects(finishedWork);
7971          currentHoistableRoot = flags;
7972          break;
7973        case 12:
7974          recursivelyTraverseMutationEffects(root2, finishedWork);
7975          commitReconciliationEffects(finishedWork);
7976          break;
7977        case 31:
7978          recursivelyTraverseMutationEffects(root2, finishedWork);
7979          commitReconciliationEffects(finishedWork);
7980          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
7981          break;
7982        case 13:
7983          recursivelyTraverseMutationEffects(root2, finishedWork);
7984          commitReconciliationEffects(finishedWork);
7985          finishedWork.child.flags & 8192 && null !== finishedWork.memoizedState !== (null !== current && null !== current.memoizedState) && (globalMostRecentFallbackTime = now());
7986          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
7987          break;
7988        case 22:
7989          hoistableRoot = null !== finishedWork.memoizedState;
7990          var wasHidden = null !== current && null !== current.memoizedState, prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden, prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
7991          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || hoistableRoot;
7992          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
7993          recursivelyTraverseMutationEffects(root2, finishedWork);
7994          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
7995          offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
7996          commitReconciliationEffects(finishedWork);
7997          if (flags & 8192)
7998            a: for (root2 = finishedWork.stateNode, root2._visibility = hoistableRoot ? root2._visibility & -2 : root2._visibility | 1, hoistableRoot && (null === current || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || recursivelyTraverseDisappearLayoutEffects(finishedWork)), current = null, root2 = finishedWork; ; ) {
7999              if (5 === root2.tag || 26 === root2.tag) {
8000                if (null === current) {
8001                  wasHidden = current = root2;
8002                  try {
8003                    if (currentResource = wasHidden.stateNode, hoistableRoot)
8004                      maybeNodes = currentResource.style, "function" === typeof maybeNodes.setProperty ? maybeNodes.setProperty("display", "none", "important") : maybeNodes.display = "none";
8005                    else {
8006                      i2 = wasHidden.stateNode;
8007                      var styleProp = wasHidden.memoizedProps.style, display = void 0 !== styleProp && null !== styleProp && styleProp.hasOwnProperty("display") ? styleProp.display : null;
8008                      i2.style.display = null == display || "boolean" === typeof display ? "" : ("" + display).trim();
8009                    }
8010                  } catch (error) {
8011                    captureCommitPhaseError(wasHidden, wasHidden.return, error);
8012                  }
8013                }
8014              } else if (6 === root2.tag) {
8015                if (null === current) {
8016                  wasHidden = root2;
8017                  try {
8018                    wasHidden.stateNode.nodeValue = hoistableRoot ? "" : wasHidden.memoizedProps;
8019                  } catch (error) {
8020                    captureCommitPhaseError(wasHidden, wasHidden.return, error);
8021                  }
8022                }
8023              } else if (18 === root2.tag) {
8024                if (null === current) {
8025                  wasHidden = root2;
8026                  try {
8027                    var instance = wasHidden.stateNode;
8028                    hoistableRoot ? hideOrUnhideDehydratedBoundary(instance, true) : hideOrUnhideDehydratedBoundary(wasHidden.stateNode, false);
8029                  } catch (error) {
8030                    captureCommitPhaseError(wasHidden, wasHidden.return, error);
8031                  }
8032                }
8033              } else if ((22 !== root2.tag && 23 !== root2.tag || null === root2.memoizedState || root2 === finishedWork) && null !== root2.child) {
8034                root2.child.return = root2;
8035                root2 = root2.child;
8036                continue;
8037              }
8038              if (root2 === finishedWork) break a;
8039              for (; null === root2.sibling; ) {
8040                if (null === root2.return || root2.return === finishedWork) break a;
8041                current === root2 && (current = null);
8042                root2 = root2.return;
8043              }
8044              current === root2 && (current = null);
8045              root2.sibling.return = root2.return;
8046              root2 = root2.sibling;
8047            }
8048          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (current = flags.retryQueue, null !== current && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, current))));
8049          break;
8050        case 19:
8051          recursivelyTraverseMutationEffects(root2, finishedWork);
8052          commitReconciliationEffects(finishedWork);
8053          flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
8054          break;
8055        case 30:
8056          break;
8057        case 21:
8058          break;
8059        default:
8060          recursivelyTraverseMutationEffects(root2, finishedWork), commitReconciliationEffects(finishedWork);
8061      }
8062    }
8063    function commitReconciliationEffects(finishedWork) {
8064      var flags = finishedWork.flags;
8065      if (flags & 2) {
8066        try {
8067          for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber; ) {
8068            if (isHostParent(parentFiber)) {
8069              hostParentFiber = parentFiber;
8070              break;
8071            }
8072            parentFiber = parentFiber.return;
8073          }
8074          if (null == hostParentFiber) throw Error(formatProdErrorMessage(160));
8075          switch (hostParentFiber.tag) {
8076            case 27:
8077              var parent = hostParentFiber.stateNode, before = getHostSibling(finishedWork);
8078              insertOrAppendPlacementNode(finishedWork, before, parent);
8079              break;
8080            case 5:
8081              var parent$141 = hostParentFiber.stateNode;
8082              hostParentFiber.flags & 32 && (setTextContent(parent$141, ""), hostParentFiber.flags &= -33);
8083              var before$142 = getHostSibling(finishedWork);
8084              insertOrAppendPlacementNode(finishedWork, before$142, parent$141);
8085              break;
8086            case 3:
8087            case 4:
8088              var parent$143 = hostParentFiber.stateNode.containerInfo, before$144 = getHostSibling(finishedWork);
8089              insertOrAppendPlacementNodeIntoContainer(
8090                finishedWork,
8091                before$144,
8092                parent$143
8093              );
8094              break;
8095            default:
8096              throw Error(formatProdErrorMessage(161));
8097          }
8098        } catch (error) {
8099          captureCommitPhaseError(finishedWork, finishedWork.return, error);
8100        }
8101        finishedWork.flags &= -3;
8102      }
8103      flags & 4096 && (finishedWork.flags &= -4097);
8104    }
8105    function recursivelyResetForms(parentFiber) {
8106      if (parentFiber.subtreeFlags & 1024)
8107        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
8108          var fiber = parentFiber;
8109          recursivelyResetForms(fiber);
8110          5 === fiber.tag && fiber.flags & 1024 && fiber.stateNode.reset();
8111          parentFiber = parentFiber.sibling;
8112        }
8113    }
8114    function recursivelyTraverseLayoutEffects(root2, parentFiber) {
8115      if (parentFiber.subtreeFlags & 8772)
8116        for (parentFiber = parentFiber.child; null !== parentFiber; )
8117          commitLayoutEffectOnFiber(root2, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
8118    }
8119    function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
8120      for (parentFiber = parentFiber.child; null !== parentFiber; ) {
8121        var finishedWork = parentFiber;
8122        switch (finishedWork.tag) {
8123          case 0:
8124          case 11:
8125          case 14:
8126          case 15:
8127            commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
8128            recursivelyTraverseDisappearLayoutEffects(finishedWork);
8129            break;
8130          case 1:
8131            safelyDetachRef(finishedWork, finishedWork.return);

vendor: 5,907 bytes, lines 8132-8269

8132            var instance = finishedWork.stateNode;
8133            "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(
8134              finishedWork,
8135              finishedWork.return,
8136              instance
8137            );
8138            recursivelyTraverseDisappearLayoutEffects(finishedWork);
8139            break;
8140          case 27:
8141            releaseSingletonInstance(finishedWork.stateNode);
8142          case 26:
8143          case 5:
8144            safelyDetachRef(finishedWork, finishedWork.return);
8145            recursivelyTraverseDisappearLayoutEffects(finishedWork);
8146            break;
8147          case 22:
8148            null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
8149            break;
8150          case 30:
8151            recursivelyTraverseDisappearLayoutEffects(finishedWork);
8152            break;
8153          default:
8154            recursivelyTraverseDisappearLayoutEffects(finishedWork);
8155        }
8156        parentFiber = parentFiber.sibling;
8157      }
8158    }
8159    function recursivelyTraverseReappearLayoutEffects(finishedRoot$jscomp$0, parentFiber, includeWorkInProgressEffects) {
8160      includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
8161      for (parentFiber = parentFiber.child; null !== parentFiber; ) {
8162        var current = parentFiber.alternate, finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, flags = finishedWork.flags;
8163        switch (finishedWork.tag) {
8164          case 0:
8165          case 11:
8166          case 15:
8167            recursivelyTraverseReappearLayoutEffects(
8168              finishedRoot,
8169              finishedWork,
8170              includeWorkInProgressEffects
8171            );
8172            commitHookEffectListMount(4, finishedWork);
8173            break;
8174          case 1:
8175            recursivelyTraverseReappearLayoutEffects(
8176              finishedRoot,
8177              finishedWork,
8178              includeWorkInProgressEffects
8179            );
8180            current = finishedWork;
8181            finishedRoot = current.stateNode;
8182            if ("function" === typeof finishedRoot.componentDidMount)
8183              try {
8184                finishedRoot.componentDidMount();
8185              } catch (error) {
8186                captureCommitPhaseError(current, current.return, error);
8187              }
8188            current = finishedWork;
8189            finishedRoot = current.updateQueue;
8190            if (null !== finishedRoot) {
8191              var instance = current.stateNode;
8192              try {
8193                var hiddenCallbacks = finishedRoot.shared.hiddenCallbacks;
8194                if (null !== hiddenCallbacks)
8195                  for (finishedRoot.shared.hiddenCallbacks = null, finishedRoot = 0; finishedRoot < hiddenCallbacks.length; finishedRoot++)
8196                    callCallback(hiddenCallbacks[finishedRoot], instance);
8197              } catch (error) {
8198                captureCommitPhaseError(current, current.return, error);
8199              }
8200            }
8201            includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
8202            safelyAttachRef(finishedWork, finishedWork.return);
8203            break;
8204          case 27:
8205            commitHostSingletonAcquisition(finishedWork);
8206          case 26:
8207          case 5:
8208            recursivelyTraverseReappearLayoutEffects(
8209              finishedRoot,
8210              finishedWork,
8211              includeWorkInProgressEffects
8212            );
8213            includeWorkInProgressEffects && null === current && flags & 4 && commitHostMount(finishedWork);
8214            safelyAttachRef(finishedWork, finishedWork.return);
8215            break;
8216          case 12:
8217            recursivelyTraverseReappearLayoutEffects(
8218              finishedRoot,
8219              finishedWork,
8220              includeWorkInProgressEffects
8221            );
8222            break;
8223          case 31:
8224            recursivelyTraverseReappearLayoutEffects(
8225              finishedRoot,
8226              finishedWork,
8227              includeWorkInProgressEffects
8228            );
8229            includeWorkInProgressEffects && flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
8230            break;
8231          case 13:
8232            recursivelyTraverseReappearLayoutEffects(
8233              finishedRoot,
8234              finishedWork,
8235              includeWorkInProgressEffects
8236            );
8237            includeWorkInProgressEffects && flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
8238            break;
8239          case 22:
8240            null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(
8241              finishedRoot,
8242              finishedWork,
8243              includeWorkInProgressEffects
8244            );
8245            safelyAttachRef(finishedWork, finishedWork.return);
8246            break;
8247          case 30:
8248            break;
8249          default:
8250            recursivelyTraverseReappearLayoutEffects(
8251              finishedRoot,
8252              finishedWork,
8253              includeWorkInProgressEffects
8254            );
8255        }
8256        parentFiber = parentFiber.sibling;
8257      }
8258    }
8259    function commitOffscreenPassiveMountEffects(current, finishedWork) {
8260      var previousCache = null;
8261      null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
8262      current = null;
8263      null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
8264      current !== previousCache && (null != current && current.refCount++, null != previousCache && releaseCache(previousCache));
8265    }
8266    function commitCachePassiveMountEffect(current, finishedWork) {
8267      current = null;
8268      null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
8269      finishedWork = finishedWork.memoizedState.cache;

vendor: 13,492 bytes, lines 8270-8610

8270      finishedWork !== current && (finishedWork.refCount++, null != current && releaseCache(current));
8271    }
8272    function recursivelyTraversePassiveMountEffects(root2, parentFiber, committedLanes, committedTransitions) {
8273      if (parentFiber.subtreeFlags & 10256)
8274        for (parentFiber = parentFiber.child; null !== parentFiber; )
8275          commitPassiveMountOnFiber(
8276            root2,
8277            parentFiber,
8278            committedLanes,
8279            committedTransitions
8280          ), parentFiber = parentFiber.sibling;
8281    }
8282    function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
8283      var flags = finishedWork.flags;
8284      switch (finishedWork.tag) {
8285        case 0:
8286        case 11:
8287        case 15:
8288          recursivelyTraversePassiveMountEffects(
8289            finishedRoot,
8290            finishedWork,
8291            committedLanes,
8292            committedTransitions
8293          );
8294          flags & 2048 && commitHookEffectListMount(9, finishedWork);
8295          break;
8296        case 1:
8297          recursivelyTraversePassiveMountEffects(
8298            finishedRoot,
8299            finishedWork,
8300            committedLanes,
8301            committedTransitions
8302          );
8303          break;
8304        case 3:
8305          recursivelyTraversePassiveMountEffects(
8306            finishedRoot,
8307            finishedWork,
8308            committedLanes,
8309            committedTransitions
8310          );
8311          flags & 2048 && (finishedRoot = null, null !== finishedWork.alternate && (finishedRoot = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== finishedRoot && (finishedWork.refCount++, null != finishedRoot && releaseCache(finishedRoot)));
8312          break;
8313        case 12:
8314          if (flags & 2048) {
8315            recursivelyTraversePassiveMountEffects(
8316              finishedRoot,
8317              finishedWork,
8318              committedLanes,
8319              committedTransitions
8320            );
8321            finishedRoot = finishedWork.stateNode;
8322            try {
8323              var _finishedWork$memoize2 = finishedWork.memoizedProps, id = _finishedWork$memoize2.id, onPostCommit = _finishedWork$memoize2.onPostCommit;
8324              "function" === typeof onPostCommit && onPostCommit(
8325                id,
8326                null === finishedWork.alternate ? "mount" : "update",
8327                finishedRoot.passiveEffectDuration,
8328                -0
8329              );
8330            } catch (error) {
8331              captureCommitPhaseError(finishedWork, finishedWork.return, error);
8332            }
8333          } else
8334            recursivelyTraversePassiveMountEffects(
8335              finishedRoot,
8336              finishedWork,
8337              committedLanes,
8338              committedTransitions
8339            );
8340          break;
8341        case 31:
8342          recursivelyTraversePassiveMountEffects(
8343            finishedRoot,
8344            finishedWork,
8345            committedLanes,
8346            committedTransitions
8347          );
8348          break;
8349        case 13:
8350          recursivelyTraversePassiveMountEffects(
8351            finishedRoot,
8352            finishedWork,
8353            committedLanes,
8354            committedTransitions
8355          );
8356          break;
8357        case 23:
8358          break;
8359        case 22:
8360          _finishedWork$memoize2 = finishedWork.stateNode;
8361          id = finishedWork.alternate;
8362          null !== finishedWork.memoizedState ? _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(
8363            finishedRoot,
8364            finishedWork,
8365            committedLanes,
8366            committedTransitions
8367          ) : recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(
8368            finishedRoot,
8369            finishedWork,
8370            committedLanes,
8371            committedTransitions
8372          ) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(
8373            finishedRoot,
8374            finishedWork,
8375            committedLanes,
8376            committedTransitions,
8377            0 !== (finishedWork.subtreeFlags & 10256) || false
8378          ));
8379          flags & 2048 && commitOffscreenPassiveMountEffects(id, finishedWork);
8380          break;
8381        case 24:
8382          recursivelyTraversePassiveMountEffects(
8383            finishedRoot,
8384            finishedWork,
8385            committedLanes,
8386            committedTransitions
8387          );
8388          flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
8389          break;
8390        default:
8391          recursivelyTraversePassiveMountEffects(
8392            finishedRoot,
8393            finishedWork,
8394            committedLanes,
8395            committedTransitions
8396          );
8397      }
8398    }
8399    function recursivelyTraverseReconnectPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, includeWorkInProgressEffects) {
8400      includeWorkInProgressEffects = includeWorkInProgressEffects && (0 !== (parentFiber.subtreeFlags & 10256) || false);
8401      for (parentFiber = parentFiber.child; null !== parentFiber; ) {
8402        var finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, committedLanes = committedLanes$jscomp$0, committedTransitions = committedTransitions$jscomp$0, flags = finishedWork.flags;
8403        switch (finishedWork.tag) {
8404          case 0:
8405          case 11:
8406          case 15:
8407            recursivelyTraverseReconnectPassiveEffects(
8408              finishedRoot,
8409              finishedWork,
8410              committedLanes,
8411              committedTransitions,
8412              includeWorkInProgressEffects
8413            );
8414            commitHookEffectListMount(8, finishedWork);
8415            break;
8416          case 23:
8417            break;
8418          case 22:
8419            var instance = finishedWork.stateNode;
8420            null !== finishedWork.memoizedState ? instance._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(
8421              finishedRoot,
8422              finishedWork,
8423              committedLanes,
8424              committedTransitions,
8425              includeWorkInProgressEffects
8426            ) : recursivelyTraverseAtomicPassiveEffects(
8427              finishedRoot,
8428              finishedWork
8429            ) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(
8430              finishedRoot,
8431              finishedWork,
8432              committedLanes,
8433              committedTransitions,
8434              includeWorkInProgressEffects
8435            ));
8436            includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(
8437              finishedWork.alternate,
8438              finishedWork
8439            );
8440            break;
8441          case 24:
8442            recursivelyTraverseReconnectPassiveEffects(
8443              finishedRoot,
8444              finishedWork,
8445              committedLanes,
8446              committedTransitions,
8447              includeWorkInProgressEffects
8448            );
8449            includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
8450            break;
8451          default:
8452            recursivelyTraverseReconnectPassiveEffects(
8453              finishedRoot,
8454              finishedWork,
8455              committedLanes,
8456              committedTransitions,
8457              includeWorkInProgressEffects
8458            );
8459        }
8460        parentFiber = parentFiber.sibling;
8461      }
8462    }
8463    function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
8464      if (parentFiber.subtreeFlags & 10256)
8465        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
8466          var finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, flags = finishedWork.flags;
8467          switch (finishedWork.tag) {
8468            case 22:
8469              recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
8470              flags & 2048 && commitOffscreenPassiveMountEffects(
8471                finishedWork.alternate,
8472                finishedWork
8473              );
8474              break;
8475            case 24:
8476              recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
8477              flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
8478              break;
8479            default:
8480              recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
8481          }
8482          parentFiber = parentFiber.sibling;
8483        }
8484    }
8485    var suspenseyCommitFlag = 8192;
8486    function recursivelyAccumulateSuspenseyCommit(parentFiber, committedLanes, suspendedState) {
8487      if (parentFiber.subtreeFlags & suspenseyCommitFlag)
8488        for (parentFiber = parentFiber.child; null !== parentFiber; )
8489          accumulateSuspenseyCommitOnFiber(
8490            parentFiber,
8491            committedLanes,
8492            suspendedState
8493          ), parentFiber = parentFiber.sibling;
8494    }
8495    function accumulateSuspenseyCommitOnFiber(fiber, committedLanes, suspendedState) {
8496      switch (fiber.tag) {
8497        case 26:
8498          recursivelyAccumulateSuspenseyCommit(
8499            fiber,
8500            committedLanes,
8501            suspendedState
8502          );
8503          fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource(
8504            suspendedState,
8505            currentHoistableRoot,
8506            fiber.memoizedState,
8507            fiber.memoizedProps
8508          );
8509          break;
8510        case 5:
8511          recursivelyAccumulateSuspenseyCommit(
8512            fiber,
8513            committedLanes,
8514            suspendedState
8515          );
8516          break;
8517        case 3:
8518        case 4:
8519          var previousHoistableRoot = currentHoistableRoot;
8520          currentHoistableRoot = getHoistableRoot(fiber.stateNode.containerInfo);
8521          recursivelyAccumulateSuspenseyCommit(
8522            fiber,
8523            committedLanes,
8524            suspendedState
8525          );
8526          currentHoistableRoot = previousHoistableRoot;
8527          break;
8528        case 22:
8529          null === fiber.memoizedState && (previousHoistableRoot = fiber.alternate, null !== previousHoistableRoot && null !== previousHoistableRoot.memoizedState ? (previousHoistableRoot = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(
8530            fiber,
8531            committedLanes,
8532            suspendedState
8533          ), suspenseyCommitFlag = previousHoistableRoot) : recursivelyAccumulateSuspenseyCommit(
8534            fiber,
8535            committedLanes,
8536            suspendedState
8537          ));
8538          break;
8539        default:
8540          recursivelyAccumulateSuspenseyCommit(
8541            fiber,
8542            committedLanes,
8543            suspendedState
8544          );
8545      }
8546    }
8547    function detachAlternateSiblings(parentFiber) {
8548      var previousFiber = parentFiber.alternate;
8549      if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
8550        previousFiber.child = null;
8551        do
8552          previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber;
8553        while (null !== parentFiber);
8554      }
8555    }
8556    function recursivelyTraversePassiveUnmountEffects(parentFiber) {
8557      var deletions = parentFiber.deletions;
8558      if (0 !== (parentFiber.flags & 16)) {
8559        if (null !== deletions)
8560          for (var i2 = 0; i2 < deletions.length; i2++) {
8561            var childToDelete = deletions[i2];
8562            nextEffect = childToDelete;
8563            commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
8564              childToDelete,
8565              parentFiber
8566            );
8567          }
8568        detachAlternateSiblings(parentFiber);
8569      }
8570      if (parentFiber.subtreeFlags & 10256)
8571        for (parentFiber = parentFiber.child; null !== parentFiber; )
8572          commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
8573    }
8574    function commitPassiveUnmountOnFiber(finishedWork) {
8575      switch (finishedWork.tag) {
8576        case 0:
8577        case 11:
8578        case 15:
8579          recursivelyTraversePassiveUnmountEffects(finishedWork);
8580          finishedWork.flags & 2048 && commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
8581          break;
8582        case 3:
8583          recursivelyTraversePassiveUnmountEffects(finishedWork);
8584          break;
8585        case 12:
8586          recursivelyTraversePassiveUnmountEffects(finishedWork);
8587          break;
8588        case 22:
8589          var instance = finishedWork.stateNode;
8590          null !== finishedWork.memoizedState && instance._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
8591          break;
8592        default:
8593          recursivelyTraversePassiveUnmountEffects(finishedWork);
8594      }
8595    }
8596    function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
8597      var deletions = parentFiber.deletions;
8598      if (0 !== (parentFiber.flags & 16)) {
8599        if (null !== deletions)
8600          for (var i2 = 0; i2 < deletions.length; i2++) {
8601            var childToDelete = deletions[i2];
8602            nextEffect = childToDelete;
8603            commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
8604              childToDelete,
8605              parentFiber
8606            );
8607          }
8608        detachAlternateSiblings(parentFiber);
8609      }
8610      for (parentFiber = parentFiber.child; null !== parentFiber; ) {

vendor: 5,147 bytes, lines 8611-8703

8611        deletions = parentFiber;
8612        switch (deletions.tag) {
8613          case 0:
8614          case 11:
8615          case 15:
8616            commitHookEffectListUnmount(8, deletions, deletions.return);
8617            recursivelyTraverseDisconnectPassiveEffects(deletions);
8618            break;
8619          case 22:
8620            i2 = deletions.stateNode;
8621            i2._visibility & 2 && (i2._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(deletions));
8622            break;
8623          default:
8624            recursivelyTraverseDisconnectPassiveEffects(deletions);
8625        }
8626        parentFiber = parentFiber.sibling;
8627      }
8628    }
8629    function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
8630      for (; null !== nextEffect; ) {
8631        var fiber = nextEffect;
8632        switch (fiber.tag) {
8633          case 0:
8634          case 11:
8635          case 15:
8636            commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
8637            break;
8638          case 23:
8639          case 22:
8640            if (null !== fiber.memoizedState && null !== fiber.memoizedState.cachePool) {
8641              var cache2 = fiber.memoizedState.cachePool.pool;
8642              null != cache2 && cache2.refCount++;
8643            }
8644            break;
8645          case 24:
8646            releaseCache(fiber.memoizedState.cache);
8647        }
8648        cache2 = fiber.child;
8649        if (null !== cache2) cache2.return = fiber, nextEffect = cache2;
8650        else
8651          a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
8652            cache2 = nextEffect;
8653            var sibling = cache2.sibling, returnFiber = cache2.return;
8654            detachFiberAfterEffects(cache2);
8655            if (cache2 === fiber) {
8656              nextEffect = null;
8657              break a;
8658            }
8659            if (null !== sibling) {
8660              sibling.return = returnFiber;
8661              nextEffect = sibling;
8662              break a;
8663            }
8664            nextEffect = returnFiber;
8665          }
8666      }
8667    }
8668    var DefaultAsyncDispatcher = {
8669      getCacheForType: function(resourceType) {
8670        var cache2 = readContext(CacheContext), cacheForType = cache2.data.get(resourceType);
8671        void 0 === cacheForType && (cacheForType = resourceType(), cache2.data.set(resourceType, cacheForType));
8672        return cacheForType;
8673      },
8674      cacheSignal: function() {
8675        return readContext(CacheContext).controller.signal;
8676      }
8677    }, PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, executionContext = 0, workInProgressRoot = null, workInProgress = null, workInProgressRootRenderLanes = 0, workInProgressSuspendedReason = 0, workInProgressThrownValue = null, workInProgressRootDidSkipSuspendedSiblings = false, workInProgressRootIsPrerendering = false, workInProgressRootDidAttachPingListener = false, entangledRenderLanes = 0, workInProgressRootExitStatus = 0, workInProgressRootSkippedLanes = 0, workInProgressRootInterleavedUpdatedLanes = 0, workInProgressRootPingedLanes = 0, workInProgressDeferredLane = 0, workInProgressSuspendedRetryLanes = 0, workInProgressRootConcurrentErrors = null, workInProgressRootRecoverableErrors = null, workInProgressRootDidIncludeRecursiveRenderUpdate = false, globalMostRecentFallbackTime = 0, globalMostRecentTransitionTime = 0, workInProgressRootRenderTargetTime = Infinity, workInProgressTransitions = null, legacyErrorBoundariesThatAlreadyFailed = null, pendingEffectsStatus = 0, pendingEffectsRoot = null, pendingFinishedWork = null, pendingEffectsLanes = 0, pendingEffectsRemainingLanes = 0, pendingPassiveTransitions = null, pendingRecoverableErrors = null, nestedUpdateCount = 0, rootWithNestedUpdates = null;
8678    function requestUpdateLane() {
8679      return 0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes ? workInProgressRootRenderLanes & -workInProgressRootRenderLanes : null !== ReactSharedInternals.T ? requestTransitionLane() : resolveUpdatePriority();
8680    }
8681    function requestDeferredLane() {
8682      if (0 === workInProgressDeferredLane)
8683        if (0 === (workInProgressRootRenderLanes & 536870912) || isHydrating) {
8684          var lane = nextTransitionDeferredLane;
8685          nextTransitionDeferredLane <<= 1;
8686          0 === (nextTransitionDeferredLane & 3932160) && (nextTransitionDeferredLane = 262144);
8687          workInProgressDeferredLane = lane;
8688        } else workInProgressDeferredLane = 536870912;
8689      lane = suspenseHandlerStackCursor.current;
8690      null !== lane && (lane.flags |= 32);
8691      return workInProgressDeferredLane;
8692    }
8693    function scheduleUpdateOnFiber(root2, fiber, lane) {
8694      if (root2 === workInProgressRoot && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root2.cancelPendingCommit)
8695        prepareFreshStack(root2, 0), markRootSuspended(
8696          root2,
8697          workInProgressRootRenderLanes,
8698          workInProgressDeferredLane,
8699          false
8700        );
8701      markRootUpdated$1(root2, lane);
8702      if (0 === (executionContext & 2) || root2 !== workInProgressRoot)
8703        root2 === workInProgressRoot && (0 === (executionContext & 2) && (workInProgressRootInterleavedU

vendor: 4,577 bytes, lines 8703-8797

8703pdatedLanes |= lane), 4 === workInProgressRootExitStatus && markRootSuspended(
8704          root2,
8705          workInProgressRootRenderLanes,
8706          workInProgressDeferredLane,
8707          false
8708        )), ensureRootIsScheduled(root2);
8709    }
8710    function performWorkOnRoot(root$jscomp$0, lanes, forceSync) {
8711      if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
8712      var shouldTimeSlice = !forceSync && 0 === (lanes & 127) && 0 === (lanes & root$jscomp$0.expiredLanes) || checkIfRootIsPrerendering(root$jscomp$0, lanes), exitStatus = shouldTimeSlice ? renderRootConcurrent(root$jscomp$0, lanes) : renderRootSync(root$jscomp$0, lanes, true), renderWasConcurrent = shouldTimeSlice;
8713      do {
8714        if (0 === exitStatus) {
8715          workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root$jscomp$0, lanes, 0, false);
8716          break;
8717        } else {
8718          forceSync = root$jscomp$0.current.alternate;
8719          if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
8720            exitStatus = renderRootSync(root$jscomp$0, lanes, false);
8721            renderWasConcurrent = false;
8722            continue;
8723          }
8724          if (2 === exitStatus) {
8725            renderWasConcurrent = lanes;
8726            if (root$jscomp$0.errorRecoveryDisabledLanes & renderWasConcurrent)
8727              var JSCompiler_inline_result = 0;
8728            else
8729              JSCompiler_inline_result = root$jscomp$0.pendingLanes & -536870913, JSCompiler_inline_result = 0 !== JSCompiler_inline_result ? JSCompiler_inline_result : JSCompiler_inline_result & 536870912 ? 536870912 : 0;
8730            if (0 !== JSCompiler_inline_result) {
8731              lanes = JSCompiler_inline_result;
8732              a: {
8733                var root2 = root$jscomp$0;
8734                exitStatus = workInProgressRootConcurrentErrors;
8735                var wasRootDehydrated = root2.current.memoizedState.isDehydrated;
8736                wasRootDehydrated && (prepareFreshStack(root2, JSCompiler_inline_result).flags |= 256);
8737                JSCompiler_inline_result = renderRootSync(
8738                  root2,
8739                  JSCompiler_inline_result,
8740                  false
8741                );
8742                if (2 !== JSCompiler_inline_result) {
8743                  if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
8744                    root2.errorRecoveryDisabledLanes |= renderWasConcurrent;
8745                    workInProgressRootInterleavedUpdatedLanes |= renderWasConcurrent;
8746                    exitStatus = 4;
8747                    break a;
8748                  }
8749                  renderWasConcurrent = workInProgressRootRecoverableErrors;
8750                  workInProgressRootRecoverableErrors = exitStatus;
8751                  null !== renderWasConcurrent && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = renderWasConcurrent : workInProgressRootRecoverableErrors.push.apply(
8752                    workInProgressRootRecoverableErrors,
8753                    renderWasConcurrent
8754                  ));
8755                }
8756                exitStatus = JSCompiler_inline_result;
8757              }
8758              renderWasConcurrent = false;
8759              if (2 !== exitStatus) continue;
8760            }
8761          }
8762          if (1 === exitStatus) {
8763            prepareFreshStack(root$jscomp$0, 0);
8764            markRootSuspended(root$jscomp$0, lanes, 0, true);
8765            break;
8766          }
8767          a: {
8768            shouldTimeSlice = root$jscomp$0;
8769            renderWasConcurrent = exitStatus;
8770            switch (renderWasConcurrent) {
8771              case 0:
8772              case 1:
8773                throw Error(formatProdErrorMessage(345));
8774              case 4:
8775                if ((lanes & 4194048) !== lanes) break;
8776              case 6:
8777                markRootSuspended(
8778                  shouldTimeSlice,
8779                  lanes,
8780                  workInProgressDeferredLane,
8781                  !workInProgressRootDidSkipSuspendedSiblings
8782                );
8783                break a;
8784              case 2:
8785                workInProgressRootRecoverableErrors = null;
8786                break;
8787              case 3:
8788              case 5:
8789                break;
8790              default:
8791                throw Error(formatProdErrorMessage(329));
8792            }
8793            if ((lanes & 62914560) === lanes && (exitStatus = globalMostRecentFallbackTime + 300 - now(), 10 < exitStatus)) {
8794              markRootSuspended(
8795                shouldTimeSlice,
8796                lanes,
8797                workInProgressDeferredLane,

vendor: 36,968 bytes, lines 8798-9585

8798                !workInProgressRootDidSkipSuspendedSiblings
8799              );
8800              if (0 !== getNextLanes(shouldTimeSlice, 0, true)) break a;
8801              pendingEffectsLanes = lanes;
8802              shouldTimeSlice.timeoutHandle = scheduleTimeout(
8803                commitRootWhenReady.bind(
8804                  null,
8805                  shouldTimeSlice,
8806                  forceSync,
8807                  workInProgressRootRecoverableErrors,
8808                  workInProgressTransitions,
8809                  workInProgressRootDidIncludeRecursiveRenderUpdate,
8810                  lanes,
8811                  workInProgressDeferredLane,
8812                  workInProgressRootInterleavedUpdatedLanes,
8813                  workInProgressSuspendedRetryLanes,
8814                  workInProgressRootDidSkipSuspendedSiblings,
8815                  renderWasConcurrent,
8816                  "Throttled",
8817                  -0,
8818                  0
8819                ),
8820                exitStatus
8821              );
8822              break a;
8823            }
8824            commitRootWhenReady(
8825              shouldTimeSlice,
8826              forceSync,
8827              workInProgressRootRecoverableErrors,
8828              workInProgressTransitions,
8829              workInProgressRootDidIncludeRecursiveRenderUpdate,
8830              lanes,
8831              workInProgressDeferredLane,
8832              workInProgressRootInterleavedUpdatedLanes,
8833              workInProgressSuspendedRetryLanes,
8834              workInProgressRootDidSkipSuspendedSiblings,
8835              renderWasConcurrent,
8836              null,
8837              -0,
8838              0
8839            );
8840          }
8841        }
8842        break;
8843      } while (1);
8844      ensureRootIsScheduled(root$jscomp$0);
8845    }
8846    function commitRootWhenReady(root2, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes, didSkipSuspendedSiblings, exitStatus, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
8847      root2.timeoutHandle = -1;
8848      suspendedCommitReason = finishedWork.subtreeFlags;
8849      if (suspendedCommitReason & 8192 || 16785408 === (suspendedCommitReason & 16785408)) {
8850        suspendedCommitReason = {
8851          stylesheets: null,
8852          count: 0,
8853          imgCount: 0,
8854          imgBytes: 0,
8855          suspenseyImages: [],
8856          waitingForImages: true,
8857          waitingForViewTransition: false,
8858          unsuspend: noop$12
8859        };
8860        accumulateSuspenseyCommitOnFiber(
8861          finishedWork,
8862          lanes,
8863          suspendedCommitReason
8864        );
8865        var timeoutOffset = (lanes & 62914560) === lanes ? globalMostRecentFallbackTime - now() : (lanes & 4194048) === lanes ? globalMostRecentTransitionTime - now() : 0;
8866        timeoutOffset = waitForCommitToBeReady(
8867          suspendedCommitReason,
8868          timeoutOffset
8869        );
8870        if (null !== timeoutOffset) {
8871          pendingEffectsLanes = lanes;
8872          root2.cancelPendingCommit = timeoutOffset(
8873            commitRoot.bind(
8874              null,
8875              root2,
8876              finishedWork,
8877              lanes,
8878              recoverableErrors,
8879              transitions,
8880              didIncludeRenderPhaseUpdate,
8881              spawnedLane,
8882              updatedLanes,
8883              suspendedRetryLanes,
8884              exitStatus,
8885              suspendedCommitReason,
8886              null,
8887              completedRenderStartTime,
8888              completedRenderEndTime
8889            )
8890          );
8891          markRootSuspended(root2, lanes, spawnedLane, !didSkipSuspendedSiblings);
8892          return;
8893        }
8894      }
8895      commitRoot(
8896        root2,
8897        finishedWork,
8898        lanes,
8899        recoverableErrors,
8900        transitions,
8901        didIncludeRenderPhaseUpdate,
8902        spawnedLane,
8903        updatedLanes,
8904        suspendedRetryLanes
8905      );
8906    }
8907    function isRenderConsistentWithExternalStores(finishedWork) {
8908      for (var node2 = finishedWork; ; ) {
8909        var tag = node2.tag;
8910        if ((0 === tag || 11 === tag || 15 === tag) && node2.flags & 16384 && (tag = node2.updateQueue, null !== tag && (tag = tag.stores, null !== tag)))
8911          for (var i2 = 0; i2 < tag.length; i2++) {
8912            var check = tag[i2], getSnapshot = check.getSnapshot;
8913            check = check.value;
8914            try {
8915              if (!objectIs2(getSnapshot(), check)) return false;
8916            } catch (error) {
8917              return false;
8918            }
8919          }
8920        tag = node2.child;
8921        if (node2.subtreeFlags & 16384 && null !== tag)
8922          tag.return = node2, node2 = tag;
8923        else {
8924          if (node2 === finishedWork) break;
8925          for (; null === node2.sibling; ) {
8926            if (null === node2.return || node2.return === finishedWork) return true;
8927            node2 = node2.return;
8928          }
8929          node2.sibling.return = node2.return;
8930          node2 = node2.sibling;
8931        }
8932      }
8933      return true;
8934    }
8935    function markRootSuspended(root2, suspendedLanes, spawnedLane, didAttemptEntireTree) {
8936      suspendedLanes &= ~workInProgressRootPingedLanes;
8937      suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
8938      root2.suspendedLanes |= suspendedLanes;
8939      root2.pingedLanes &= ~suspendedLanes;
8940      didAttemptEntireTree && (root2.warmLanes |= suspendedLanes);
8941      didAttemptEntireTree = root2.expirationTimes;
8942      for (var lanes = suspendedLanes; 0 < lanes; ) {
8943        var index$6 = 31 - clz32(lanes), lane = 1 << index$6;
8944        didAttemptEntireTree[index$6] = -1;
8945        lanes &= ~lane;
8946      }
8947      0 !== spawnedLane && markSpawnedDeferredLane(root2, spawnedLane, suspendedLanes);
8948    }
8949    function flushSyncWork$1() {
8950      return 0 === (executionContext & 6) ? (flushSyncWorkAcrossRoots_impl(0), false) : true;
8951    }
8952    function resetWorkInProgressStack() {
8953      if (null !== workInProgress) {
8954        if (0 === workInProgressSuspendedReason)
8955          var interruptedWork = workInProgress.return;
8956        else
8957          interruptedWork = workInProgress, lastContextDependency = currentlyRenderingFiber$1 = null, resetHooksOnUnwind(interruptedWork), thenableState$1 = null, thenableIndexCounter$1 = 0, interruptedWork = workInProgress;
8958        for (; null !== interruptedWork; )
8959          unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
8960        workInProgress = null;
8961      }
8962    }
8963    function prepareFreshStack(root2, lanes) {
8964      var timeoutHandle = root2.timeoutHandle;
8965      -1 !== timeoutHandle && (root2.timeoutHandle = -1, cancelTimeout(timeoutHandle));
8966      timeoutHandle = root2.cancelPendingCommit;
8967      null !== timeoutHandle && (root2.cancelPendingCommit = null, timeoutHandle());
8968      pendingEffectsLanes = 0;
8969      resetWorkInProgressStack();
8970      workInProgressRoot = root2;
8971      workInProgress = timeoutHandle = createWorkInProgress(root2.current, null);
8972      workInProgressRootRenderLanes = lanes;
8973      workInProgressSuspendedReason = 0;
8974      workInProgressThrownValue = null;
8975      workInProgressRootDidSkipSuspendedSiblings = false;
8976      workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root2, lanes);
8977      workInProgressRootDidAttachPingListener = false;
8978      workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = workInProgressRootExitStatus = 0;
8979      workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
8980      workInProgressRootDidIncludeRecursiveRenderUpdate = false;
8981      0 !== (lanes & 8) && (lanes |= lanes & 32);
8982      var allEntangledLanes = root2.entangledLanes;
8983      if (0 !== allEntangledLanes)
8984        for (root2 = root2.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes; ) {
8985          var index$4 = 31 - clz32(allEntangledLanes), lane = 1 << index$4;
8986          lanes |= root2[index$4];
8987          allEntangledLanes &= ~lane;
8988        }
8989      entangledRenderLanes = lanes;
8990      finishQueueingConcurrentUpdates();
8991      return timeoutHandle;
8992    }
8993    function handleThrow(root2, thrownValue) {
8994      currentlyRenderingFiber = null;
8995      ReactSharedInternals.H = ContextOnlyDispatcher;
8996      thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 3) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 4) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? 8 : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? 6 : 1;
8997      workInProgressThrownValue = thrownValue;
8998      null === workInProgress && (workInProgressRootExitStatus = 1, logUncaughtError(
8999        root2,
9000        createCapturedValueAtFiber(thrownValue, root2.current)
9001      ));
9002    }
9003    function shouldRemainOnPreviousScreen() {
9004      var handler = suspenseHandlerStackCursor.current;
9005      return null === handler ? true : (workInProgressRootRenderLanes & 4194048) === workInProgressRootRenderLanes ? null === shellBoundary ? true : false : (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes || 0 !== (workInProgressRootRenderLanes & 536870912) ? handler === shellBoundary : false;
9006    }
9007    function pushDispatcher() {
9008      var prevDispatcher = ReactSharedInternals.H;
9009      ReactSharedInternals.H = ContextOnlyDispatcher;
9010      return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
9011    }
9012    function pushAsyncDispatcher() {
9013      var prevAsyncDispatcher = ReactSharedInternals.A;
9014      ReactSharedInternals.A = DefaultAsyncDispatcher;
9015      return prevAsyncDispatcher;
9016    }
9017    function renderDidSuspendDelayIfPossible() {
9018      workInProgressRootExitStatus = 4;
9019      workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = true);
9020      0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(
9021        workInProgressRoot,
9022        workInProgressRootRenderLanes,
9023        workInProgressDeferredLane,
9024        false
9025      );
9026    }
9027    function renderRootSync(root2, lanes, shouldYieldForPrerendering) {
9028      var prevExecutionContext = executionContext;
9029      executionContext |= 2;
9030      var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
9031      if (workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes)
9032        workInProgressTransitions = null, prepareFreshStack(root2, lanes);
9033      lanes = false;
9034      var exitStatus = workInProgressRootExitStatus;
9035      a: do
9036        try {
9037          if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
9038            var unitOfWork = workInProgress, thrownValue = workInProgressThrownValue;
9039            switch (workInProgressSuspendedReason) {
9040              case 8:
9041                resetWorkInProgressStack();
9042                exitStatus = 6;
9043                break a;
9044              case 3:
9045              case 2:
9046              case 9:
9047              case 6:
9048                null === suspenseHandlerStackCursor.current && (lanes = true);
9049                var reason = workInProgressSuspendedReason;
9050                workInProgressSuspendedReason = 0;
9051                workInProgressThrownValue = null;
9052                throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
9053                if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
9054                  exitStatus = 0;
9055                  break a;
9056                }
9057                break;
9058              default:
9059                reason = workInProgressSuspendedReason, workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
9060            }
9061          }
9062          workLoopSync();
9063          exitStatus = workInProgressRootExitStatus;
9064          break;
9065        } catch (thrownValue$165) {
9066          handleThrow(root2, thrownValue$165);
9067        }
9068      while (1);
9069      lanes && root2.shellSuspendCounter++;
9070      lastContextDependency = currentlyRenderingFiber$1 = null;
9071      executionContext = prevExecutionContext;
9072      ReactSharedInternals.H = prevDispatcher;
9073      ReactSharedInternals.A = prevAsyncDispatcher;
9074      null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
9075      return exitStatus;
9076    }
9077    function workLoopSync() {
9078      for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
9079    }
9080    function renderRootConcurrent(root2, lanes) {
9081      var prevExecutionContext = executionContext;
9082      executionContext |= 2;
9083      var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
9084      workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes ? (workInProgressTransitions = null, workInProgressRootRenderTargetTime = now() + 500, prepareFreshStack(root2, lanes)) : workInProgressRootIsPrerendering = checkIfRootIsPrerendering(
9085        root2,
9086        lanes
9087      );
9088      a: do
9089        try {
9090          if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
9091            lanes = workInProgress;
9092            var thrownValue = workInProgressThrownValue;
9093            b: switch (workInProgressSuspendedReason) {
9094              case 1:
9095                workInProgressSuspendedReason = 0;
9096                workInProgressThrownValue = null;
9097                throwAndUnwindWorkLoop(root2, lanes, thrownValue, 1);
9098                break;
9099              case 2:
9100              case 9:
9101                if (isThenableResolved(thrownValue)) {
9102                  workInProgressSuspendedReason = 0;
9103                  workInProgressThrownValue = null;
9104                  replaySuspendedUnitOfWork(lanes);
9105                  break;
9106                }
9107                lanes = function() {
9108                  2 !== workInProgressSuspendedReason && 9 !== workInProgressSuspendedReason || workInProgressRoot !== root2 || (workInProgressSuspendedReason = 7);
9109                  ensureRootIsScheduled(root2);
9110                };
9111                thrownValue.then(lanes, lanes);
9112                break a;
9113              case 3:
9114                workInProgressSuspendedReason = 7;
9115                break a;
9116              case 4:
9117                workInProgressSuspendedReason = 5;
9118                break a;
9119              case 7:
9120                isThenableResolved(thrownValue) ? (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root2, lanes, thrownValue, 7));
9121                break;
9122              case 5:
9123                var resource = null;
9124                switch (workInProgress.tag) {
9125                  case 26:
9126                    resource = workInProgress.memoizedState;
9127                  case 5:
9128                  case 27:
9129                    var hostFiber = workInProgress;
9130                    if (resource ? preloadResource(resource) : hostFiber.stateNode.complete) {
9131                      workInProgressSuspendedReason = 0;
9132                      workInProgressThrownValue = null;
9133                      var sibling = hostFiber.sibling;
9134                      if (null !== sibling) workInProgress = sibling;
9135                      else {
9136                        var returnFiber = hostFiber.return;
9137                        null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
9138                      }
9139                      break b;
9140                    }
9141                }
9142                workInProgressSuspendedReason = 0;
9143                workInProgressThrownValue = null;
9144                throwAndUnwindWorkLoop(root2, lanes, thrownValue, 5);
9145                break;
9146              case 6:
9147                workInProgressSuspendedReason = 0;
9148                workInProgressThrownValue = null;
9149                throwAndUnwindWorkLoop(root2, lanes, thrownValue, 6);
9150                break;
9151              case 8:
9152                resetWorkInProgressStack();
9153                workInProgressRootExitStatus = 6;
9154                break a;
9155              default:
9156                throw Error(formatProdErrorMessage(462));
9157            }
9158          }
9159          workLoopConcurrentByScheduler();
9160          break;
9161        } catch (thrownValue$167) {
9162          handleThrow(root2, thrownValue$167);
9163        }
9164      while (1);
9165      lastContextDependency = currentlyRenderingFiber$1 = null;
9166      ReactSharedInternals.H = prevDispatcher;
9167      ReactSharedInternals.A = prevAsyncDispatcher;
9168      executionContext = prevExecutionContext;
9169      if (null !== workInProgress) return 0;
9170      workInProgressRoot = null;
9171      workInProgressRootRenderLanes = 0;
9172      finishQueueingConcurrentUpdates();
9173      return workInProgressRootExitStatus;
9174    }
9175    function workLoopConcurrentByScheduler() {
9176      for (; null !== workInProgress && !shouldYield(); )
9177        performUnitOfWork(workInProgress);
9178    }
9179    function performUnitOfWork(unitOfWork) {
9180      var next = beginWork(unitOfWork.alternate, unitOfWork, entangledRenderLanes);
9181      unitOfWork.memoizedProps = unitOfWork.pendingProps;
9182      null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
9183    }
9184    function replaySuspendedUnitOfWork(unitOfWork) {
9185      var next = unitOfWork;
9186      var current = next.alternate;
9187      switch (next.tag) {
9188        case 15:
9189        case 0:
9190          next = replayFunctionComponent(
9191            current,
9192            next,
9193            next.pendingProps,
9194            next.type,
9195            void 0,
9196            workInProgressRootRenderLanes
9197          );
9198          break;
9199        case 11:
9200          next = replayFunctionComponent(
9201            current,
9202            next,
9203            next.pendingProps,
9204            next.type.render,
9205            next.ref,
9206            workInProgressRootRenderLanes
9207          );
9208          break;
9209        case 5:
9210          resetHooksOnUnwind(next);
9211        default:
9212          unwindInterruptedWork(current, next), next = workInProgress = resetWorkInProgress(next, entangledRenderLanes), next = beginWork(current, next, entangledRenderLanes);
9213      }
9214      unitOfWork.memoizedProps = unitOfWork.pendingProps;
9215      null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
9216    }
9217    function throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, suspendedReason) {
9218      lastContextDependency = currentlyRenderingFiber$1 = null;
9219      resetHooksOnUnwind(unitOfWork);
9220      thenableState$1 = null;
9221      thenableIndexCounter$1 = 0;
9222      var returnFiber = unitOfWork.return;
9223      try {
9224        if (throwException(
9225          root2,
9226          returnFiber,
9227          unitOfWork,
9228          thrownValue,
9229          workInProgressRootRenderLanes
9230        )) {
9231          workInProgressRootExitStatus = 1;
9232          logUncaughtError(
9233            root2,
9234            createCapturedValueAtFiber(thrownValue, root2.current)
9235          );
9236          workInProgress = null;
9237          return;
9238        }
9239      } catch (error) {
9240        if (null !== returnFiber) throw workInProgress = returnFiber, error;
9241        workInProgressRootExitStatus = 1;
9242        logUncaughtError(
9243          root2,
9244          createCapturedValueAtFiber(thrownValue, root2.current)
9245        );
9246        workInProgress = null;
9247        return;
9248      }
9249      if (unitOfWork.flags & 32768) {
9250        if (isHydrating || 1 === suspendedReason) root2 = true;
9251        else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912))
9252          root2 = false;
9253        else if (workInProgressRootDidSkipSuspendedSiblings = root2 = true, 2 === suspendedReason || 9 === suspendedReason || 3 === suspendedReason || 6 === suspendedReason)
9254          suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
9255        unwindUnitOfWork(unitOfWork, root2);
9256      } else completeUnitOfWork(unitOfWork);
9257    }
9258    function completeUnitOfWork(unitOfWork) {
9259      var completedWork = unitOfWork;
9260      do {
9261        if (0 !== (completedWork.flags & 32768)) {
9262          unwindUnitOfWork(
9263            completedWork,
9264            workInProgressRootDidSkipSuspendedSiblings
9265          );
9266          return;
9267        }
9268        unitOfWork = completedWork.return;
9269        var next = completeWork(
9270          completedWork.alternate,
9271          completedWork,
9272          entangledRenderLanes
9273        );
9274        if (null !== next) {
9275          workInProgress = next;
9276          return;
9277        }
9278        completedWork = completedWork.sibling;
9279        if (null !== completedWork) {
9280          workInProgress = completedWork;
9281          return;
9282        }
9283        workInProgress = completedWork = unitOfWork;
9284      } while (null !== completedWork);
9285      0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
9286    }
9287    function unwindUnitOfWork(unitOfWork, skipSiblings) {
9288      do {
9289        var next = unwindWork(unitOfWork.alternate, unitOfWork);
9290        if (null !== next) {
9291          next.flags &= 32767;
9292          workInProgress = next;
9293          return;
9294        }
9295        next = unitOfWork.return;
9296        null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
9297        if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
9298          workInProgress = unitOfWork;
9299          return;
9300        }
9301        workInProgress = unitOfWork = next;
9302      } while (null !== unitOfWork);
9303      workInProgressRootExitStatus = 6;
9304      workInProgress = null;
9305    }
9306    function commitRoot(root2, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
9307      root2.cancelPendingCommit = null;
9308      do
9309        flushPendingEffects();
9310      while (0 !== pendingEffectsStatus);
9311      if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
9312      if (null !== finishedWork) {
9313        if (finishedWork === root2.current) throw Error(formatProdErrorMessage(177));
9314        didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
9315        didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
9316        markRootFinished(
9317          root2,
9318          lanes,
9319          didIncludeRenderPhaseUpdate,
9320          spawnedLane,
9321          updatedLanes,
9322          suspendedRetryLanes
9323        );
9324        root2 === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
9325        pendingFinishedWork = finishedWork;
9326        pendingEffectsRoot = root2;
9327        pendingEffectsLanes = lanes;
9328        pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
9329        pendingPassiveTransitions = transitions;
9330        pendingRecoverableErrors = recoverableErrors;
9331        0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root2.callbackNode = null, root2.callbackPriority = 0, scheduleCallback$1(NormalPriority$1, function() {
9332          flushPassiveEffects();
9333          return null;
9334        })) : (root2.callbackNode = null, root2.callbackPriority = 0);
9335        recoverableErrors = 0 !== (finishedWork.flags & 13878);
9336        if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
9337          recoverableErrors = ReactSharedInternals.T;
9338          ReactSharedInternals.T = null;
9339          transitions = ReactDOMSharedInternals.p;
9340          ReactDOMSharedInternals.p = 2;
9341          spawnedLane = executionContext;
9342          executionContext |= 4;
9343          try {
9344            commitBeforeMutationEffects(root2, finishedWork, lanes);
9345          } finally {
9346            executionContext = spawnedLane, ReactDOMSharedInternals.p = transitions, ReactSharedInternals.T = recoverableErrors;
9347          }
9348        }
9349        pendingEffectsStatus = 1;
9350        flushMutationEffects();
9351        flushLayoutEffects();
9352        flushSpawnedWork();
9353      }
9354    }
9355    function flushMutationEffects() {
9356      if (1 === pendingEffectsStatus) {
9357        pendingEffectsStatus = 0;
9358        var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
9359        if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
9360          rootMutationHasEffect = ReactSharedInternals.T;
9361          ReactSharedInternals.T = null;
9362          var previousPriority = ReactDOMSharedInternals.p;
9363          ReactDOMSharedInternals.p = 2;
9364          var prevExecutionContext = executionContext;
9365          executionContext |= 4;
9366          try {
9367            commitMutationEffectsOnFiber(finishedWork, root2);
9368            var priorSelectionInformation = selectionInformation, curFocusedElem = getActiveElementDeep(root2.containerInfo), priorFocusedElem = priorSelectionInformation.focusedElem, priorSelectionRange = priorSelectionInformation.selectionRange;
9369            if (curFocusedElem !== priorFocusedElem && priorFocusedElem && priorFocusedElem.ownerDocument && containsNode(
9370              priorFocusedElem.ownerDocument.documentElement,
9371              priorFocusedElem
9372            )) {
9373              if (null !== priorSelectionRange && hasSelectionCapabilities(priorFocusedElem)) {
9374                var start = priorSelectionRange.start, end = priorSelectionRange.end;
9375                void 0 === end && (end = start);
9376                if ("selectionStart" in priorFocusedElem)
9377                  priorFocusedElem.selectionStart = start, priorFocusedElem.selectionEnd = Math.min(
9378                    end,
9379                    priorFocusedElem.value.length
9380                  );
9381                else {
9382                  var doc = priorFocusedElem.ownerDocument || document, win = doc && doc.defaultView || window;
9383                  if (win.getSelection) {
9384                    var selection = win.getSelection(), length = priorFocusedElem.textContent.length, start$jscomp$0 = Math.min(priorSelectionRange.start, length), end$jscomp$0 = void 0 === priorSelectionRange.end ? start$jscomp$0 : Math.min(priorSelectionRange.end, length);
9385                    !selection.extend && start$jscomp$0 > end$jscomp$0 && (curFocusedElem = end$jscomp$0, end$jscomp$0 = start$jscomp$0, start$jscomp$0 = curFocusedElem);
9386                    var startMarker = getNodeForCharacterOffset(
9387                      priorFocusedElem,
9388                      start$jscomp$0
9389                    ), endMarker = getNodeForCharacterOffset(
9390                      priorFocusedElem,
9391                      end$jscomp$0
9392                    );
9393                    if (startMarker && endMarker && (1 !== selection.rangeCount || selection.anchorNode !== startMarker.node || selection.anchorOffset !== startMarker.offset || selection.focusNode !== endMarker.node || selection.focusOffset !== endMarker.offset)) {
9394                      var range2 = doc.createRange();
9395                      range2.setStart(startMarker.node, startMarker.offset);
9396                      selection.removeAllRanges();
9397                      start$jscomp$0 > end$jscomp$0 ? (selection.addRange(range2), selection.extend(endMarker.node, endMarker.offset)) : (range2.setEnd(endMarker.node, endMarker.offset), selection.addRange(range2));
9398                    }
9399                  }
9400                }
9401              }
9402              doc = [];
9403              for (selection = priorFocusedElem; selection = selection.parentNode; )
9404                1 === selection.nodeType && doc.push({
9405                  element: selection,
9406                  left: selection.scrollLeft,
9407                  top: selection.scrollTop
9408                });
9409              "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
9410              for (priorFocusedElem = 0; priorFocusedElem < doc.length; priorFocusedElem++) {
9411                var info = doc[priorFocusedElem];
9412                info.element.scrollLeft = info.left;
9413                info.element.scrollTop = info.top;
9414              }
9415            }
9416            _enabled = !!eventsEnabled;
9417            selectionInformation = eventsEnabled = null;
9418          } finally {
9419            executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
9420          }
9421        }
9422        root2.current = finishedWork;
9423        pendingEffectsStatus = 2;
9424      }
9425    }
9426    function flushLayoutEffects() {
9427      if (2 === pendingEffectsStatus) {
9428        pendingEffectsStatus = 0;
9429        var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
9430        if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
9431          rootHasLayoutEffect = ReactSharedInternals.T;
9432          ReactSharedInternals.T = null;
9433          var previousPriority = ReactDOMSharedInternals.p;
9434          ReactDOMSharedInternals.p = 2;
9435          var prevExecutionContext = executionContext;
9436          executionContext |= 4;
9437          try {
9438            commitLayoutEffectOnFiber(root2, finishedWork.alternate, finishedWork);
9439          } finally {
9440            executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
9441          }
9442        }
9443        pendingEffectsStatus = 3;
9444      }
9445    }
9446    function flushSpawnedWork() {
9447      if (4 === pendingEffectsStatus || 3 === pendingEffectsStatus) {
9448        pendingEffectsStatus = 0;
9449        requestPaint();
9450        var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, lanes = pendingEffectsLanes, recoverableErrors = pendingRecoverableErrors;
9451        0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? pendingEffectsStatus = 5 : (pendingEffectsStatus = 0, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root2, root2.pendingLanes));
9452        var remainingLanes = root2.pendingLanes;
9453        0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
9454        lanesToEventPriority(lanes);
9455        finishedWork = finishedWork.stateNode;
9456        if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
9457          try {
9458            injectedHook.onCommitFiberRoot(
9459              rendererID,
9460              finishedWork,
9461              void 0,
9462              128 === (finishedWork.current.flags & 128)
9463            );
9464          } catch (err) {
9465          }
9466        if (null !== recoverableErrors) {
9467          finishedWork = ReactSharedInternals.T;
9468          remainingLanes = ReactDOMSharedInternals.p;
9469          ReactDOMSharedInternals.p = 2;
9470          ReactSharedInternals.T = null;
9471          try {
9472            for (var onRecoverableError = root2.onRecoverableError, i2 = 0; i2 < recoverableErrors.length; i2++) {
9473              var recoverableError = recoverableErrors[i2];
9474              onRecoverableError(recoverableError.value, {
9475                componentStack: recoverableError.stack
9476              });
9477            }
9478          } finally {
9479            ReactSharedInternals.T = finishedWork, ReactDOMSharedInternals.p = remainingLanes;
9480          }
9481        }
9482        0 !== (pendingEffectsLanes & 3) && flushPendingEffects();
9483        ensureRootIsScheduled(root2);
9484        remainingLanes = root2.pendingLanes;
9485        0 !== (lanes & 261930) && 0 !== (remainingLanes & 42) ? root2 === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root2) : nestedUpdateCount = 0;
9486        flushSyncWorkAcrossRoots_impl(0);
9487      }
9488    }
9489    function releaseRootPooledCache(root2, remainingLanes) {
9490      0 === (root2.pooledCacheLanes &= remainingLanes) && (remainingLanes = root2.pooledCache, null != remainingLanes && (root2.pooledCache = null, releaseCache(remainingLanes)));
9491    }
9492    function flushPendingEffects() {
9493      flushMutationEffects();
9494      flushLayoutEffects();
9495      flushSpawnedWork();
9496      return flushPassiveEffects();
9497    }
9498    function flushPassiveEffects() {
9499      if (5 !== pendingEffectsStatus) return false;
9500      var root2 = pendingEffectsRoot, remainingLanes = pendingEffectsRemainingLanes;
9501      pendingEffectsRemainingLanes = 0;
9502      var renderPriority = lanesToEventPriority(pendingEffectsLanes), prevTransition = ReactSharedInternals.T, previousPriority = ReactDOMSharedInternals.p;
9503      try {
9504        ReactDOMSharedInternals.p = 32 > renderPriority ? 32 : renderPriority;
9505        ReactSharedInternals.T = null;
9506        renderPriority = pendingPassiveTransitions;
9507        pendingPassiveTransitions = null;
9508        var root$jscomp$0 = pendingEffectsRoot, lanes = pendingEffectsLanes;
9509        pendingEffectsStatus = 0;
9510        pendingFinishedWork = pendingEffectsRoot = null;
9511        pendingEffectsLanes = 0;
9512        if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
9513        var prevExecutionContext = executionContext;
9514        executionContext |= 4;
9515        commitPassiveUnmountOnFiber(root$jscomp$0.current);
9516        commitPassiveMountOnFiber(
9517          root$jscomp$0,
9518          root$jscomp$0.current,
9519          lanes,
9520          renderPriority
9521        );
9522        executionContext = prevExecutionContext;
9523        flushSyncWorkAcrossRoots_impl(0, false);
9524        if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
9525          try {
9526            injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
9527          } catch (err) {
9528          }
9529        return true;
9530      } finally {
9531        ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition, releaseRootPooledCache(root2, remainingLanes);
9532      }
9533    }
9534    function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
9535      sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
9536      sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
9537      rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
9538      null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
9539    }
9540    function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
9541      if (3 === sourceFiber.tag)
9542        captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
9543      else
9544        for (; null !== nearestMountedAncestor; ) {
9545          if (3 === nearestMountedAncestor.tag) {
9546            captureCommitPhaseErrorOnRoot(
9547              nearestMountedAncestor,
9548              sourceFiber,
9549              error
9550            );
9551            break;
9552          } else if (1 === nearestMountedAncestor.tag) {
9553            var instance = nearestMountedAncestor.stateNode;
9554            if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
9555              sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
9556              error = createClassErrorUpdate(2);
9557              instance = enqueueUpdate(nearestMountedAncestor, error, 2);
9558              null !== instance && (initializeClassErrorUpdate(
9559                error,
9560                instance,
9561                nearestMountedAncestor,
9562                sourceFiber
9563              ), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
9564              break;
9565            }
9566          }
9567          nearestMountedAncestor = nearestMountedAncestor.return;
9568        }
9569    }
9570    function attachPingListener(root2, wakeable, lanes) {
9571      var pingCache = root2.pingCache;
9572      if (null === pingCache) {
9573        pingCache = root2.pingCache = new PossiblyWeakMap();
9574        var threadIDs = /* @__PURE__ */ new Set();
9575        pingCache.set(wakeable, threadIDs);
9576      } else
9577        threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = /* @__PURE__ */ new Set(), pingCache.set(wakeable, threadIDs));
9578      threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = true, threadIDs.add(lanes), root2 = pingSuspendedRoot.bind(null, root2, wakeable, lanes), wakeable.then(root2, root2));
9579    }
9580    function pingSuspendedRoot(root2, wakeable, pingedLanes) {
9581      var pingCache = root2.pingCache;
9582      null !== pingCache && pingCache.delete(wakeable);
9583      root2.pingedLanes |= root2.suspendedLanes & pingedLanes;
9584      root2.warmLanes &= ~pingedLanes;
9585      workInProgressRoot === root2 && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (4 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && 300 > now() - globalMostRecentFallbackTime ? 0 === (executionContext & 2) && prepareFreshStack(root2, 0) : w

9585orkInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
9586      ensureRootIsScheduled(root2);
9587    }
9588    function retryTimedOutBoundary(boundaryFiber, retryLane) {
9589      0 === retryLane && (retryLane = claimNextRetryLane());
9590      boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
9591      null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
9592    }
9593    function retryDehydratedSuspenseBoundary(boundaryFiber) {
9594      var suspenseState = boundaryFiber.memoizedState, retryLane = 0;
9595      null !== suspenseState && (retryLane = suspenseState.retryLane);
9596      retryTimedOutBoundary(boundaryFiber, retryLane);
9597    }
9598    function resolveRetryWakeable(boundaryFiber, wakeable) {
9599      var retryLane = 0;
9600      switch (boundaryFiber.tag) {
9601        case 31:
9602        case 13:
9603          var retryCache = boundaryFiber.stateNode;
9604          var suspenseState = boundaryFiber.memoizedState;
9605          null !== suspenseState && (retryLane = suspenseState.retryLane);
9606          break;
9607        case 19:
9608          retryCache = boundaryFiber.stateNode;
9609          break;
9610        case 22:
9611          retryCache = boundaryFiber.stateNode._retryCache;
9612          break;
9613        default:
9614          throw Error(formatProdErrorMessage(314));
9615      }
9616      null !== retryCache && retryCache.delete(wakeable);
9617      retryTimedOutBoundary(boundaryFiber, retryLane);
9618    }
9619    function scheduleCallback$1(priorityLevel, callback) {
9620      return scheduleCallback$3(priorityLevel, callback);
9621    }
9622    var firstScheduledRoot = null, lastScheduledRoot = null, didScheduleMicrotask = false, mightHavePendingSyncWork = false, isFlushingWork = false, currentEventTransitionLane = 0;
9623    function ensureRootIsScheduled(root2) {
9624      root2 !== lastScheduledRoot && null === root2.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root2 : lastScheduledRoot = lastScheduledRoot.next = root2);
9625      mightHavePendingSyncWork = true;
9626      didScheduleMicrotask || (didScheduleMicrotask = true, scheduleImmediateRootScheduleTask());
9627    }
9628    function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
9629      if (!isFlushingWork && mightHavePendingSyncWork) {
9630        isFlushingWork = true;
9631        do {
9632          var didPerformSomeWork = false;
9633          for (var root$170 = firstScheduledRoot; null !== root$170; ) {
9634            if (0 !== syncTransitionLanes) {
9635              var pendingLanes = root$170.pendingLanes;
9636              if (0 === pendingLanes) var JSCompiler_inline_result = 0;
9637              else {
9638                var suspendedLanes = root$170.suspendedLanes, pingedLanes = root$170.pingedLanes;
9639                JSCompiler_inline_result = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
9640                JSCompiler_inline_result &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
9641                JSCompiler_inline_result = JSCompiler_inline_result & 201326741 ? JSCompiler_inline_result & 201326741 | 1 : JSCompiler_inline_result ? JSCompiler_inline_result | 2 : 0;
9642              }
9643              0 !== JSCompiler_inline_result && (didPerformSomeWork = true, performSyncWorkOnRoot(root$170, JSCompiler_inline_result));
9644            } else
9645              JSCompiler_inline_result = workInProgressRootRenderLanes, JSCompiler_inline_result = getNextLanes(
9646                root$170,
9647                root$170 === workInProgressRoot ? JSCompiler_inline_result : 0,
9648                null !== root$170.cancelPendingCommit || -1 !== root$170.timeoutHandle
9649              ), 0 === (JSCompiler_inline_result & 3) || checkIfRootIsPrerendering(root$170, JSCompiler_inline_result) || (didPerformSomeWork = true, performSyncWorkOnRoot(root$170, JSCompiler_inline_result));
9650            root$170 = root$170.next;
9651          }
9652        } while (didPerformSomeWork);
9653        isFlushingWork = false;
9654      }
9655    }
9656    function processRootScheduleInImmediateTask() {
9657      processRootScheduleInMicrotask();
9658    }
9659    function processRootScheduleInMicrotask() {
9660      mightHavePendingSyncWork = didScheduleMicrotask = false;

vendor: 8,621 bytes, lines 9661-9828

9661      var syncTransitionLanes = 0;
9662      0 !== currentEventTransitionLane && shouldAttemptEagerTransition() && (syncTransitionLanes = currentEventTransitionLane);
9663      for (var currentTime = now(), prev = null, root2 = firstScheduledRoot; null !== root2; ) {
9664        var next = root2.next, nextLanes = scheduleTaskForRootDuringMicrotask(root2, currentTime);
9665        if (0 === nextLanes)
9666          root2.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev);
9667        else if (prev = root2, 0 !== syncTransitionLanes || 0 !== (nextLanes & 3))
9668          mightHavePendingSyncWork = true;
9669        root2 = next;
9670      }
9671      0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus || flushSyncWorkAcrossRoots_impl(syncTransitionLanes);
9672      0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
9673    }
9674    function scheduleTaskForRootDuringMicrotask(root2, currentTime) {
9675      for (var suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes, expirationTimes = root2.expirationTimes, lanes = root2.pendingLanes & -62914561; 0 < lanes; ) {
9676        var index$5 = 31 - clz32(lanes), lane = 1 << index$5, expirationTime = expirationTimes[index$5];
9677        if (-1 === expirationTime) {
9678          if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes))
9679            expirationTimes[index$5] = computeExpirationTime(lane, currentTime);
9680        } else expirationTime <= currentTime && (root2.expiredLanes |= lane);
9681        lanes &= ~lane;
9682      }
9683      currentTime = workInProgressRoot;
9684      suspendedLanes = workInProgressRootRenderLanes;
9685      suspendedLanes = getNextLanes(
9686        root2,
9687        root2 === currentTime ? suspendedLanes : 0,
9688        null !== root2.cancelPendingCommit || -1 !== root2.timeoutHandle
9689      );
9690      pingedLanes = root2.callbackNode;
9691      if (0 === suspendedLanes || root2 === currentTime && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root2.cancelPendingCommit)
9692        return null !== pingedLanes && null !== pingedLanes && cancelCallback$1(pingedLanes), root2.callbackNode = null, root2.callbackPriority = 0;
9693      if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root2, suspendedLanes)) {
9694        currentTime = suspendedLanes & -suspendedLanes;
9695        if (currentTime === root2.callbackPriority) return currentTime;
9696        null !== pingedLanes && cancelCallback$1(pingedLanes);
9697        switch (lanesToEventPriority(suspendedLanes)) {
9698          case 2:
9699          case 8:
9700            suspendedLanes = UserBlockingPriority;
9701            break;
9702          case 32:
9703            suspendedLanes = NormalPriority$1;
9704            break;
9705          case 268435456:
9706            suspendedLanes = IdlePriority;
9707            break;
9708          default:
9709            suspendedLanes = NormalPriority$1;
9710        }
9711        pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root2);
9712        suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
9713        root2.callbackPriority = currentTime;
9714        root2.callbackNode = suspendedLanes;
9715        return currentTime;
9716      }
9717      null !== pingedLanes && null !== pingedLanes && cancelCallback$1(pingedLanes);
9718      root2.callbackPriority = 2;
9719      root2.callbackNode = null;
9720      return 2;
9721    }
9722    function performWorkOnRootViaSchedulerTask(root2, didTimeout) {
9723      if (0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus)
9724        return root2.callbackNode = null, root2.callbackPriority = 0, null;
9725      var originalCallbackNode = root2.callbackNode;
9726      if (flushPendingEffects() && root2.callbackNode !== originalCallbackNode)
9727        return null;
9728      var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
9729      workInProgressRootRenderLanes$jscomp$0 = getNextLanes(
9730        root2,
9731        root2 === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0,
9732        null !== root2.cancelPendingCommit || -1 !== root2.timeoutHandle
9733      );
9734      if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
9735      performWorkOnRoot(root2, workInProgressRootRenderLanes$jscomp$0, didTimeout);
9736      scheduleTaskForRootDuringMicrotask(root2, now());
9737      return null != root2.callbackNode && root2.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root2) : null;
9738    }
9739    function performSyncWorkOnRoot(root2, lanes) {
9740      if (flushPendingEffects()) return null;
9741      performWorkOnRoot(root2, lanes, true);
9742    }
9743    function scheduleImmediateRootScheduleTask() {
9744      scheduleMicrotask(function() {
9745        0 !== (executionContext & 6) ? scheduleCallback$3(
9746          ImmediatePriority,
9747          processRootScheduleInImmediateTask
9748        ) : processRootScheduleInMicrotask();
9749      });
9750    }
9751    function requestTransitionLane() {
9752      if (0 === currentEventTransitionLane) {
9753        var actionScopeLane = currentEntangledLane;
9754        0 === actionScopeLane && (actionScopeLane = nextTransitionUpdateLane, nextTransitionUpdateLane <<= 1, 0 === (nextTransitionUpdateLane & 261888) && (nextTransitionUpdateLane = 256));
9755        currentEventTransitionLane = actionScopeLane;
9756      }
9757      return currentEventTransitionLane;
9758    }
9759    function coerceFormActionProp(actionProp) {
9760      return null == actionProp || "symbol" === typeof actionProp || "boolean" === typeof actionProp ? null : "function" === typeof actionProp ? actionProp : sanitizeURL("" + actionProp);
9761    }
9762    function createFormDataWithSubmitter(form, submitter) {
9763      var temp = submitter.ownerDocument.createElement("input");
9764      temp.name = submitter.name;
9765      temp.value = submitter.value;
9766      form.id && temp.setAttribute("form", form.id);
9767      submitter.parentNode.insertBefore(temp, submitter);
9768      form = new FormData(form);
9769      temp.parentNode.removeChild(temp);
9770      return form;
9771    }
9772    function extractEvents$1(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget) {
9773      if ("submit" === domEventName && maybeTargetInst && maybeTargetInst.stateNode === nativeEventTarget) {
9774        var action = coerceFormActionProp(
9775          (nativeEventTarget[internalPropsKey] || null).action
9776        ), submitter = nativeEvent.submitter;
9777        submitter && (domEventName = (domEventName = submitter[internalPropsKey] || null) ? coerceFormActionProp(domEventName.formAction) : submitter.getAttribute("formAction"), null !== domEventName && (action = domEventName, submitter = null));
9778        var event = new SyntheticEvent(
9779          "action",
9780          "action",
9781          null,
9782          nativeEvent,
9783          nativeEventTarget
9784        );
9785        dispatchQueue.push({
9786          event,
9787          listeners: [
9788            {
9789              instance: null,
9790              listener: function() {
9791                if (nativeEvent.defaultPrevented) {
9792                  if (0 !== currentEventTransitionLane) {
9793                    var formData = submitter ? createFormDataWithSubmitter(nativeEventTarget, submitter) : new FormData(nativeEventTarget);
9794                    startHostTransition(
9795                      maybeTargetInst,
9796                      {
9797                        pending: true,
9798                        data: formData,
9799                        method: nativeEventTarget.method,
9800                        action
9801                      },
9802                      null,
9803                      formData
9804                    );
9805                  }
9806                } else
9807                  "function" === typeof action && (event.preventDefault(), formData = submitter ? createFormDataWithSubmitter(nativeEventTarget, submitter) : new FormData(nativeEventTarget), startHostTransition(
9808                    maybeTargetInst,
9809                    {
9810                      pending: true,
9811                      data: formData,
9812                      method: nativeEventTarget.method,
9813                      action
9814                    },
9815                    action,
9816                    formData
9817                  ));
9818              },
9819              currentTarget: nativeEventTarget
9820            }
9821          ]
9822        });
9823      }
9824    }
9825    for (var i$jscomp$inline_1577 = 0; i$jscomp$inline_1577 < simpleEventPluginEvents.length; i$jscomp$inline_1577++) {
9826      var eventName$jscomp$inline_1578 = simpleEventPluginEvents[i$jscomp$inline_1577], domEventName$jscomp$inline_1579 = eventName$jscomp$inline_1578.toLowerCase(), capitalizedEvent$jscomp$inline_1580 = eventName$jscomp$inline_1578[0].toUpperCase() + eventName$jscomp$inline_1578.slice(1);
9827      registerSimpleEvent(
9828        domEventName$jscomp$inline_1579,

vendor: 2,207 bytes, lines 9829-9878

9829        "on" + capitalizedEvent$jscomp$inline_1580
9830      );
9831    }
9832    registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
9833    registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
9834    registerSimpleEvent(ANIMATION_START, "onAnimationStart");
9835    registerSimpleEvent("dblclick", "onDoubleClick");
9836    registerSimpleEvent("focusin", "onFocus");
9837    registerSimpleEvent("focusout", "onBlur");
9838    registerSimpleEvent(TRANSITION_RUN, "onTransitionRun");
9839    registerSimpleEvent(TRANSITION_START, "onTransitionStart");
9840    registerSimpleEvent(TRANSITION_CANCEL, "onTransitionCancel");
9841    registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
9842    registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
9843    registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
9844    registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
9845    registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
9846    registerTwoPhaseEvent(
9847      "onChange",
9848      "change click focusin focusout input keydown keyup selectionchange".split(" ")
9849    );
9850    registerTwoPhaseEvent(
9851      "onSelect",
9852      "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
9853        " "
9854      )
9855    );
9856    registerTwoPhaseEvent("onBeforeInput", [
9857      "compositionend",
9858      "keypress",
9859      "textInput",
9860      "paste"
9861    ]);
9862    registerTwoPhaseEvent(
9863      "onCompositionEnd",
9864      "compositionend focusout keydown keypress keyup mousedown".split(" ")
9865    );
9866    registerTwoPhaseEvent(
9867      "onCompositionStart",
9868      "compositionstart focusout keydown keypress keyup mousedown".split(" ")
9869    );
9870    registerTwoPhaseEvent(
9871      "onCompositionUpdate",
9872      "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
9873    );
9874    var mediaEventTypes = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
9875      " "
9876    ), nonDelegatedEvents = new Set(
9877      "beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(mediaEventTypes)
9878    );

vendor: 6,818 bytes, lines 9879-10012

9879    function processDispatchQueue(dispatchQueue, eventSystemFlags) {
9880      eventSystemFlags = 0 !== (eventSystemFlags & 4);
9881      for (var i2 = 0; i2 < dispatchQueue.length; i2++) {
9882        var _dispatchQueue$i = dispatchQueue[i2], event = _dispatchQueue$i.event;
9883        _dispatchQueue$i = _dispatchQueue$i.listeners;
9884        a: {
9885          var previousInstance = void 0;
9886          if (eventSystemFlags)
9887            for (var i$jscomp$0 = _dispatchQueue$i.length - 1; 0 <= i$jscomp$0; i$jscomp$0--) {
9888              var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0], instance = _dispatchListeners$i.instance, currentTarget = _dispatchListeners$i.currentTarget;
9889              _dispatchListeners$i = _dispatchListeners$i.listener;
9890              if (instance !== previousInstance && event.isPropagationStopped())
9891                break a;
9892              previousInstance = _dispatchListeners$i;
9893              event.currentTarget = currentTarget;
9894              try {
9895                previousInstance(event);
9896              } catch (error) {
9897                reportGlobalError(error);
9898              }
9899              event.currentTarget = null;
9900              previousInstance = instance;
9901            }
9902          else
9903            for (i$jscomp$0 = 0; i$jscomp$0 < _dispatchQueue$i.length; i$jscomp$0++) {
9904              _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
9905              instance = _dispatchListeners$i.instance;
9906              currentTarget = _dispatchListeners$i.currentTarget;
9907              _dispatchListeners$i = _dispatchListeners$i.listener;
9908              if (instance !== previousInstance && event.isPropagationStopped())
9909                break a;
9910              previousInstance = _dispatchListeners$i;
9911              event.currentTarget = currentTarget;
9912              try {
9913                previousInstance(event);
9914              } catch (error) {
9915                reportGlobalError(error);
9916              }
9917              event.currentTarget = null;
9918              previousInstance = instance;
9919            }
9920        }
9921      }
9922    }
9923    function listenToNonDelegatedEvent(domEventName, targetElement) {
9924      var JSCompiler_inline_result = targetElement[internalEventHandlersKey];
9925      void 0 === JSCompiler_inline_result && (JSCompiler_inline_result = targetElement[internalEventHandlersKey] = /* @__PURE__ */ new Set());
9926      var listenerSetKey = domEventName + "__bubble";
9927      JSCompiler_inline_result.has(listenerSetKey) || (addTrappedEventListener(targetElement, domEventName, 2, false), JSCompiler_inline_result.add(listenerSetKey));
9928    }
9929    function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
9930      var eventSystemFlags = 0;
9931      isCapturePhaseListener && (eventSystemFlags |= 4);
9932      addTrappedEventListener(
9933        target,
9934        domEventName,
9935        eventSystemFlags,
9936        isCapturePhaseListener
9937      );
9938    }
9939    var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
9940    function listenToAllSupportedEvents(rootContainerElement) {
9941      if (!rootContainerElement[listeningMarker]) {
9942        rootContainerElement[listeningMarker] = true;
9943        allNativeEvents.forEach(function(domEventName) {
9944          "selectionchange" !== domEventName && (nonDelegatedEvents.has(domEventName) || listenToNativeEvent(domEventName, false, rootContainerElement), listenToNativeEvent(domEventName, true, rootContainerElement));
9945        });
9946        var ownerDocument = 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
9947        null === ownerDocument || ownerDocument[listeningMarker] || (ownerDocument[listeningMarker] = true, listenToNativeEvent("selectionchange", false, ownerDocument));
9948      }
9949    }
9950    function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener) {
9951      switch (getEventPriority(domEventName)) {
9952        case 2:
9953          var listenerWrapper = dispatchDiscreteEvent;
9954          break;
9955        case 8:
9956          listenerWrapper = dispatchContinuousEvent;
9957          break;
9958        default:
9959          listenerWrapper = dispatchEvent;
9960      }
9961      eventSystemFlags = listenerWrapper.bind(
9962        null,
9963        domEventName,
9964        eventSystemFlags,
9965        targetContainer
9966      );
9967      listenerWrapper = void 0;
9968      !passiveBrowserEventsSupported || "touchstart" !== domEventName && "touchmove" !== domEventName && "wheel" !== domEventName || (listenerWrapper = true);
9969      isCapturePhaseListener ? void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
9970        capture: true,
9971        passive: listenerWrapper
9972      }) : targetContainer.addEventListener(domEventName, eventSystemFlags, true) : void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
9973        passive: listenerWrapper
9974      }) : targetContainer.addEventListener(domEventName, eventSystemFlags, false);
9975    }
9976    function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst$jscomp$0, targetContainer) {
9977      var ancestorInst = targetInst$jscomp$0;
9978      if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2) && null !== targetInst$jscomp$0)
9979        a: for (; ; ) {
9980          if (null === targetInst$jscomp$0) return;
9981          var nodeTag = targetInst$jscomp$0.tag;
9982          if (3 === nodeTag || 4 === nodeTag) {
9983            var container = targetInst$jscomp$0.stateNode.containerInfo;
9984            if (container === targetContainer) break;
9985            if (4 === nodeTag)
9986              for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
9987                var grandTag = nodeTag.tag;
9988                if ((3 === grandTag || 4 === grandTag) && nodeTag.stateNode.containerInfo === targetContainer)
9989                  return;
9990                nodeTag = nodeTag.return;
9991              }
9992            for (; null !== container; ) {
9993              nodeTag = getClosestInstanceFromNode(container);
9994              if (null === nodeTag) return;
9995              grandTag = nodeTag.tag;
9996              if (5 === grandTag || 6 === grandTag || 26 === grandTag || 27 === grandTag) {
9997                targetInst$jscomp$0 = ancestorInst = nodeTag;
9998                continue a;
9999              }
10000              container = container.parentNode;
10001            }
10002          }
10003          targetInst$jscomp$0 = targetInst$jscomp$0.return;
10004        }
10005      batchedUpdates$1(function() {
10006        var targetInst = ancestorInst, nativeEventTarget = getEventTarget(nativeEvent), dispatchQueue = [];
10007        a: {
10008          var reactName = topLevelEventsToReactNames.get(domEventName);
10009          if (void 0 !== reactName) {
10010            var SyntheticEventCtor = SyntheticEvent, reactEventType = domEventName;
10011            switch (domEventName) {
10012              case "keypress":

vendor: 11,448 bytes, lines 10013-10236

10013                if (0 === getEventCharCode(nativeEvent)) break a;
10014              case "keydown":
10015              case "keyup":
10016                SyntheticEventCtor = SyntheticKeyboardEvent;
10017                break;
10018              case "focusin":
10019                reactEventType = "focus";
10020                SyntheticEventCtor = SyntheticFocusEvent;
10021                break;
10022              case "focusout":
10023                reactEventType = "blur";
10024                SyntheticEventCtor = SyntheticFocusEvent;
10025                break;
10026              case "beforeblur":
10027              case "afterblur":
10028                SyntheticEventCtor = SyntheticFocusEvent;
10029                break;
10030              case "click":
10031                if (2 === nativeEvent.button) break a;
10032              case "auxclick":
10033              case "dblclick":
10034              case "mousedown":
10035              case "mousemove":
10036              case "mouseup":
10037              case "mouseout":
10038              case "mouseover":
10039              case "contextmenu":
10040                SyntheticEventCtor = SyntheticMouseEvent;
10041                break;
10042              case "drag":
10043              case "dragend":
10044              case "dragenter":
10045              case "dragexit":
10046              case "dragleave":
10047              case "dragover":
10048              case "dragstart":
10049              case "drop":
10050                SyntheticEventCtor = SyntheticDragEvent;
10051                break;
10052              case "touchcancel":
10053              case "touchend":
10054              case "touchmove":
10055              case "touchstart":
10056                SyntheticEventCtor = SyntheticTouchEvent;
10057                break;
10058              case ANIMATION_END:
10059              case ANIMATION_ITERATION:
10060              case ANIMATION_START:
10061                SyntheticEventCtor = SyntheticAnimationEvent;
10062                break;
10063              case TRANSITION_END:
10064                SyntheticEventCtor = SyntheticTransitionEvent;
10065                break;
10066              case "scroll":
10067              case "scrollend":
10068                SyntheticEventCtor = SyntheticUIEvent;
10069                break;
10070              case "wheel":
10071                SyntheticEventCtor = SyntheticWheelEvent;
10072                break;
10073              case "copy":
10074              case "cut":
10075              case "paste":
10076                SyntheticEventCtor = SyntheticClipboardEvent;
10077                break;
10078              case "gotpointercapture":
10079              case "lostpointercapture":
10080              case "pointercancel":
10081              case "pointerdown":
10082              case "pointermove":
10083              case "pointerout":
10084              case "pointerover":
10085              case "pointerup":
10086                SyntheticEventCtor = SyntheticPointerEvent;
10087                break;
10088              case "toggle":
10089              case "beforetoggle":
10090                SyntheticEventCtor = SyntheticToggleEvent;
10091            }
10092            var inCapturePhase = 0 !== (eventSystemFlags & 4), accumulateTargetOnly = !inCapturePhase && ("scroll" === domEventName || "scrollend" === domEventName), reactEventName = inCapturePhase ? null !== reactName ? reactName + "Capture" : null : reactName;
10093            inCapturePhase = [];
10094            for (var instance = targetInst, lastHostComponent; null !== instance; ) {
10095              var _instance = instance;
10096              lastHostComponent = _instance.stateNode;
10097              _instance = _instance.tag;
10098              5 !== _instance && 26 !== _instance && 27 !== _instance || null === lastHostComponent || null === reactEventName || (_instance = getListener(instance, reactEventName), null != _instance && inCapturePhase.push(
10099                createDispatchListener(instance, _instance, lastHostComponent)
10100              ));
10101              if (accumulateTargetOnly) break;
10102              instance = instance.return;
10103            }
10104            0 < inCapturePhase.length && (reactName = new SyntheticEventCtor(
10105              reactName,
10106              reactEventType,
10107              null,
10108              nativeEvent,
10109              nativeEventTarget
10110            ), dispatchQueue.push({ event: reactName, listeners: inCapturePhase }));
10111          }
10112        }
10113        if (0 === (eventSystemFlags & 7)) {
10114          a: {
10115            reactName = "mouseover" === domEventName || "pointerover" === domEventName;
10116            SyntheticEventCtor = "mouseout" === domEventName || "pointerout" === domEventName;
10117            if (reactName && nativeEvent !== currentReplayingEvent && (reactEventType = nativeEvent.relatedTarget || nativeEvent.fromElement) && (getClosestInstanceFromNode(reactEventType) || reactEventType[internalContainerInstanceKey]))
10118              break a;
10119            if (SyntheticEventCtor || reactName) {
10120              reactName = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget : (reactName = nativeEventTarget.ownerDocument) ? reactName.defaultView || reactName.parentWindow : window;
10121              if (SyntheticEventCtor) {
10122                if (reactEventType = nativeEvent.relatedTarget || nativeEvent.toElement, SyntheticEventCtor = targetInst, reactEventType = reactEventType ? getClosestInstanceFromNode(reactEventType) : null, null !== reactEventType && (accumulateTargetOnly = getNearestMountedFiber(reactEventType), inCapturePhase = reactEventType.tag, reactEventType !== accumulateTargetOnly || 5 !== inCapturePhase && 27 !== inCapturePhase && 6 !== inCapturePhase))
10123                  reactEventType = null;
10124              } else SyntheticEventCtor = null, reactEventType = targetInst;
10125              if (SyntheticEventCtor !== reactEventType) {
10126                inCapturePhase = SyntheticMouseEvent;
10127                _instance = "onMouseLeave";
10128                reactEventName = "onMouseEnter";
10129                instance = "mouse";
10130                if ("pointerout" === domEventName || "pointerover" === domEventName)
10131                  inCapturePhase = SyntheticPointerEvent, _instance = "onPointerLeave", reactEventName = "onPointerEnter", instance = "pointer";
10132                accumulateTargetOnly = null == SyntheticEventCtor ? reactName : getNodeFromInstance(SyntheticEventCtor);
10133                lastHostComponent = null == reactEventType ? reactName : getNodeFromInstance(reactEventType);
10134                reactName = new inCapturePhase(
10135                  _instance,
10136                  instance + "leave",
10137                  SyntheticEventCtor,
10138                  nativeEvent,
10139                  nativeEventTarget
10140                );
10141                reactName.target = accumulateTargetOnly;
10142                reactName.relatedTarget = lastHostComponent;
10143                _instance = null;
10144                getClosestInstanceFromNode(nativeEventTarget) === targetInst && (inCapturePhase = new inCapturePhase(
10145                  reactEventName,
10146                  instance + "enter",
10147                  reactEventType,
10148                  nativeEvent,
10149                  nativeEventTarget
10150                ), inCapturePhase.target = lastHostComponent, inCapturePhase.relatedTarget = accumulateTargetOnly, _instance = inCapturePhase);
10151                accumulateTargetOnly = _instance;
10152                if (SyntheticEventCtor && reactEventType)
10153                  b: {
10154                    inCapturePhase = getParent;
10155                    reactEventName = SyntheticEventCtor;
10156                    instance = reactEventType;
10157                    lastHostComponent = 0;
10158                    for (_instance = reactEventName; _instance; _instance = inCapturePhase(_instance))
10159                      lastHostComponent++;
10160                    _instance = 0;
10161                    for (var tempB = instance; tempB; tempB = inCapturePhase(tempB))
10162                      _instance++;
10163                    for (; 0 < lastHostComponent - _instance; )
10164                      reactEventName = inCapturePhase(reactEventName), lastHostComponent--;
10165                    for (; 0 < _instance - lastHostComponent; )
10166                      instance = inCapturePhase(instance), _instance--;
10167                    for (; lastHostComponent--; ) {
10168                      if (reactEventName === instance || null !== instance && reactEventName === instance.alternate) {
10169                        inCapturePhase = reactEventName;
10170                        break b;
10171                      }
10172                      reactEventName = inCapturePhase(reactEventName);
10173                      instance = inCapturePhase(instance);
10174                    }
10175                    inCapturePhase = null;
10176                  }
10177                else inCapturePhase = null;
10178                null !== SyntheticEventCtor && accumulateEnterLeaveListenersForEvent(
10179                  dispatchQueue,
10180                  reactName,
10181                  SyntheticEventCtor,
10182                  inCapturePhase,
10183                  false
10184                );
10185                null !== reactEventType && null !== accumulateTargetOnly && accumulateEnterLeaveListenersForEvent(
10186                  dispatchQueue,
10187                  accumulateTargetOnly,
10188                  reactEventType,
10189                  inCapturePhase,
10190                  true
10191                );
10192              }
10193            }
10194          }
10195          a: {
10196            reactName = targetInst ? getNodeFromInstance(targetInst) : window;
10197            SyntheticEventCtor = reactName.nodeName && reactName.nodeName.toLowerCase();
10198            if ("select" === SyntheticEventCtor || "input" === SyntheticEventCtor && "file" === reactName.type)
10199              var getTargetInstFunc = getTargetInstForChangeEvent;
10200            else if (isTextInputElement(reactName))
10201              if (isInputEventSupported)
10202                getTargetInstFunc = getTargetInstForInputOrChangeEvent;
10203              else {
10204                getTargetInstFunc = getTargetInstForInputEventPolyfill;
10205                var handleEventFunc = handleEventsForInputEventPolyfill;
10206              }
10207            else
10208              SyntheticEventCtor = reactName.nodeName, !SyntheticEventCtor || "input" !== SyntheticEventCtor.toLowerCase() || "checkbox" !== reactName.type && "radio" !== reactName.type ? targetInst && isCustomElement(targetInst.elementType) && (getTargetInstFunc = getTargetInstForChangeEvent) : getTargetInstFunc = getTargetInstForClickEvent;
10209            if (getTargetInstFunc && (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))) {
10210              createAndAccumulateChangeEvent(
10211                dispatchQueue,
10212                getTargetInstFunc,
10213                nativeEvent,
10214                nativeEventTarget
10215              );
10216              break a;
10217            }
10218            handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
10219            "focusout" === domEventName && targetInst && "number" === reactName.type && null != targetInst.memoizedProps.value && setDefaultValue(reactName, "number", reactName.value);
10220          }
10221          handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
10222          switch (domEventName) {
10223            case "focusin":
10224              if (isTextInputElement(handleEventFunc) || "true" === handleEventFunc.contentEditable)
10225                activeElement = handleEventFunc, activeElementInst = targetInst, lastSelection = null;
10226              break;
10227            case "focusout":
10228              lastSelection = activeElementInst = activeElement = null;
10229              break;
10230            case "mousedown":
10231              mouseDown = true;
10232              break;
10233            case "contextmenu":
10234            case "mouseup":
10235            case "dragend":
10236              mouseDown = false;

vendor: 41,654 bytes, lines 10237-11233

10237              constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
10238              break;
10239            case "selectionchange":
10240              if (skipSelectionChangeEvent) break;
10241            case "keydown":
10242            case "keyup":
10243              constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
10244          }
10245          var fallbackData;
10246          if (canUseCompositionEvent)
10247            b: {
10248              switch (domEventName) {
10249                case "compositionstart":
10250                  var eventType = "onCompositionStart";
10251                  break b;
10252                case "compositionend":
10253                  eventType = "onCompositionEnd";
10254                  break b;
10255                case "compositionupdate":
10256                  eventType = "onCompositionUpdate";
10257                  break b;
10258              }
10259              eventType = void 0;
10260            }
10261          else
10262            isComposing ? isFallbackCompositionEnd(domEventName, nativeEvent) && (eventType = "onCompositionEnd") : "keydown" === domEventName && 229 === nativeEvent.keyCode && (eventType = "onCompositionStart");
10263          eventType && (useFallbackCompositionData && "ko" !== nativeEvent.locale && (isComposing || "onCompositionStart" !== eventType ? "onCompositionEnd" === eventType && isComposing && (fallbackData = getData()) : (root = nativeEventTarget, startText = "value" in root ? root.value : root.textContent, isComposing = true)), handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType), 0 < handleEventFunc.length && (eventType = new SyntheticCompositionEvent(
10264            eventType,
10265            domEventName,
10266            null,
10267            nativeEvent,
10268            nativeEventTarget
10269          ), dispatchQueue.push({ event: eventType, listeners: handleEventFunc }), fallbackData ? eventType.data = fallbackData : (fallbackData = getDataFromCustomEvent(nativeEvent), null !== fallbackData && (eventType.data = fallbackData))));
10270          if (fallbackData = canUseTextInputEvent ? getNativeBeforeInputChars(domEventName, nativeEvent) : getFallbackBeforeInputChars(domEventName, nativeEvent))
10271            eventType = accumulateTwoPhaseListeners(targetInst, "onBeforeInput"), 0 < eventType.length && (handleEventFunc = new SyntheticCompositionEvent(
10272              "onBeforeInput",
10273              "beforeinput",
10274              null,
10275              nativeEvent,
10276              nativeEventTarget
10277            ), dispatchQueue.push({
10278              event: handleEventFunc,
10279              listeners: eventType
10280            }), handleEventFunc.data = fallbackData);
10281          extractEvents$1(
10282            dispatchQueue,
10283            domEventName,
10284            targetInst,
10285            nativeEvent,
10286            nativeEventTarget
10287          );
10288        }
10289        processDispatchQueue(dispatchQueue, eventSystemFlags);
10290      });
10291    }
10292    function createDispatchListener(instance, listener, currentTarget) {
10293      return {
10294        instance,
10295        listener,
10296        currentTarget
10297      };
10298    }
10299    function accumulateTwoPhaseListeners(targetFiber, reactName) {
10300      for (var captureName = reactName + "Capture", listeners = []; null !== targetFiber; ) {
10301        var _instance2 = targetFiber, stateNode = _instance2.stateNode;
10302        _instance2 = _instance2.tag;
10303        5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2 || null === stateNode || (_instance2 = getListener(targetFiber, captureName), null != _instance2 && listeners.unshift(
10304          createDispatchListener(targetFiber, _instance2, stateNode)
10305        ), _instance2 = getListener(targetFiber, reactName), null != _instance2 && listeners.push(
10306          createDispatchListener(targetFiber, _instance2, stateNode)
10307        ));
10308        if (3 === targetFiber.tag) return listeners;
10309        targetFiber = targetFiber.return;
10310      }
10311      return [];
10312    }
10313    function getParent(inst) {
10314      if (null === inst) return null;
10315      do
10316        inst = inst.return;
10317      while (inst && 5 !== inst.tag && 27 !== inst.tag);
10318      return inst ? inst : null;
10319    }
10320    function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common2, inCapturePhase) {
10321      for (var registrationName = event._reactName, listeners = []; null !== target && target !== common2; ) {
10322        var _instance3 = target, alternate = _instance3.alternate, stateNode = _instance3.stateNode;
10323        _instance3 = _instance3.tag;
10324        if (null !== alternate && alternate === common2) break;
10325        5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3 || null === stateNode || (alternate = stateNode, inCapturePhase ? (stateNode = getListener(target, registrationName), null != stateNode && listeners.unshift(
10326          createDispatchListener(target, stateNode, alternate)
10327        )) : inCapturePhase || (stateNode = getListener(target, registrationName), null != stateNode && listeners.push(
10328          createDispatchListener(target, stateNode, alternate)
10329        )));
10330        target = target.return;
10331      }
10332      0 !== listeners.length && dispatchQueue.push({ event, listeners });
10333    }
10334    var NORMALIZE_NEWLINES_REGEX = /\r\n?/g, NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
10335    function normalizeMarkupForTextOrAttribute(markup) {
10336      return ("string" === typeof markup ? markup : "" + markup).replace(NORMALIZE_NEWLINES_REGEX, "\n").replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
10337    }
10338    function checkForUnmatchedText(serverText, clientText) {
10339      clientText = normalizeMarkupForTextOrAttribute(clientText);
10340      return normalizeMarkupForTextOrAttribute(serverText) === clientText ? true : false;
10341    }
10342    function setProp(domElement, tag, key2, value, props, prevValue) {
10343      switch (key2) {
10344        case "children":
10345          "string" === typeof value ? "body" === tag || "textarea" === tag && "" === value || setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && "body" !== tag && setTextContent(domElement, "" + value);
10346          break;
10347        case "className":
10348          setValueForKnownAttribute(domElement, "class", value);
10349          break;
10350        case "tabIndex":
10351          setValueForKnownAttribute(domElement, "tabindex", value);
10352          break;
10353        case "dir":
10354        case "role":
10355        case "viewBox":
10356        case "width":
10357        case "height":
10358          setValueForKnownAttribute(domElement, key2, value);
10359          break;
10360        case "style":
10361          setValueForStyles(domElement, value, prevValue);
10362          break;
10363        case "data":
10364          if ("object" !== tag) {
10365            setValueForKnownAttribute(domElement, "data", value);
10366            break;
10367          }
10368        case "src":
10369        case "href":
10370          if ("" === value && ("a" !== tag || "href" !== key2)) {
10371            domElement.removeAttribute(key2);
10372            break;
10373          }
10374          if (null == value || "function" === typeof value || "symbol" === typeof value || "boolean" === typeof value) {
10375            domElement.removeAttribute(key2);
10376            break;
10377          }
10378          value = sanitizeURL("" + value);
10379          domElement.setAttribute(key2, value);
10380          break;
10381        case "action":
10382        case "formAction":
10383          if ("function" === typeof value) {
10384            domElement.setAttribute(
10385              key2,
10386              "javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')"
10387            );
10388            break;
10389          } else
10390            "function" === typeof prevValue && ("formAction" === key2 ? ("input" !== tag && setProp(domElement, tag, "name", props.name, props, null), setProp(
10391              domElement,
10392              tag,
10393              "formEncType",
10394              props.formEncType,
10395              props,
10396              null
10397            ), setProp(
10398              domElement,
10399              tag,
10400              "formMethod",
10401              props.formMethod,
10402              props,
10403              null
10404            ), setProp(
10405              domElement,
10406              tag,
10407              "formTarget",
10408              props.formTarget,
10409              props,
10410              null
10411            )) : (setProp(domElement, tag, "encType", props.encType, props, null), setProp(domElement, tag, "method", props.method, props, null), setProp(domElement, tag, "target", props.target, props, null)));
10412          if (null == value || "symbol" === typeof value || "boolean" === typeof value) {
10413            domElement.removeAttribute(key2);
10414            break;
10415          }
10416          value = sanitizeURL("" + value);
10417          domElement.setAttribute(key2, value);
10418          break;
10419        case "onClick":
10420          null != value && (domElement.onclick = noop$12);
10421          break;
10422        case "onScroll":
10423          null != value && listenToNonDelegatedEvent("scroll", domElement);
10424          break;
10425        case "onScrollEnd":
10426          null != value && listenToNonDelegatedEvent("scrollend", domElement);
10427          break;
10428        case "dangerouslySetInnerHTML":
10429          if (null != value) {
10430            if ("object" !== typeof value || !("__html" in value))
10431              throw Error(formatProdErrorMessage(61));
10432            key2 = value.__html;
10433            if (null != key2) {
10434              if (null != props.children) throw Error(formatProdErrorMessage(60));
10435              domElement.innerHTML = key2;
10436            }
10437          }
10438          break;
10439        case "multiple":
10440          domElement.multiple = value && "function" !== typeof value && "symbol" !== typeof value;
10441          break;
10442        case "muted":
10443          domElement.muted = value && "function" !== typeof value && "symbol" !== typeof value;
10444          break;
10445        case "suppressContentEditableWarning":
10446        case "suppressHydrationWarning":
10447        case "defaultValue":
10448        case "defaultChecked":
10449        case "innerHTML":
10450        case "ref":
10451          break;
10452        case "autoFocus":
10453          break;
10454        case "xlinkHref":
10455          if (null == value || "function" === typeof value || "boolean" === typeof value || "symbol" === typeof value) {
10456            domElement.removeAttribute("xlink:href");
10457            break;
10458          }
10459          key2 = sanitizeURL("" + value);
10460          domElement.setAttributeNS(
10461            "http://www.w3.org/1999/xlink",
10462            "xlink:href",
10463            key2
10464          );
10465          break;
10466        case "contentEditable":
10467        case "spellCheck":
10468        case "draggable":
10469        case "value":
10470        case "autoReverse":
10471        case "externalResourcesRequired":
10472        case "focusable":
10473        case "preserveAlpha":
10474          null != value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key2, "" + value) : domElement.removeAttribute(key2);
10475          break;
10476        case "inert":
10477        case "allowFullScreen":
10478        case "async":
10479        case "autoPlay":
10480        case "controls":
10481        case "default":
10482        case "defer":
10483        case "disabled":
10484        case "disablePictureInPicture":
10485        case "disableRemotePlayback":
10486        case "formNoValidate":
10487        case "hidden":
10488        case "loop":
10489        case "noModule":
10490        case "noValidate":
10491        case "open":
10492        case "playsInline":
10493        case "readOnly":
10494        case "required":
10495        case "reversed":
10496        case "scoped":
10497        case "seamless":
10498        case "itemScope":
10499          value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key2, "") : domElement.removeAttribute(key2);
10500          break;
10501        case "capture":
10502        case "download":
10503          true === value ? domElement.setAttribute(key2, "") : false !== value && null != value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key2, value) : domElement.removeAttribute(key2);
10504          break;
10505        case "cols":
10506        case "rows":
10507        case "size":
10508        case "span":
10509          null != value && "function" !== typeof value && "symbol" !== typeof value && !isNaN(value) && 1 <= value ? domElement.setAttribute(key2, value) : domElement.removeAttribute(key2);
10510          break;
10511        case "rowSpan":
10512        case "start":
10513          null == value || "function" === typeof value || "symbol" === typeof value || isNaN(value) ? domElement.removeAttribute(key2) : domElement.setAttribute(key2, value);
10514          break;
10515        case "popover":
10516          listenToNonDelegatedEvent("beforetoggle", domElement);
10517          listenToNonDelegatedEvent("toggle", domElement);
10518          setValueForAttribute(domElement, "popover", value);
10519          break;
10520        case "xlinkActuate":
10521          setValueForNamespacedAttribute(
10522            domElement,
10523            "http://www.w3.org/1999/xlink",
10524            "xlink:actuate",
10525            value
10526          );
10527          break;
10528        case "xlinkArcrole":
10529          setValueForNamespacedAttribute(
10530            domElement,
10531            "http://www.w3.org/1999/xlink",
10532            "xlink:arcrole",
10533            value
10534          );
10535          break;
10536        case "xlinkRole":
10537          setValueForNamespacedAttribute(
10538            domElement,
10539            "http://www.w3.org/1999/xlink",
10540            "xlink:role",
10541            value
10542          );
10543          break;
10544        case "xlinkShow":
10545          setValueForNamespacedAttribute(
10546            domElement,
10547            "http://www.w3.org/1999/xlink",
10548            "xlink:show",
10549            value
10550          );
10551          break;
10552        case "xlinkTitle":
10553          setValueForNamespacedAttribute(
10554            domElement,
10555            "http://www.w3.org/1999/xlink",
10556            "xlink:title",
10557            value
10558          );
10559          break;
10560        case "xlinkType":
10561          setValueForNamespacedAttribute(
10562            domElement,
10563            "http://www.w3.org/1999/xlink",
10564            "xlink:type",
10565            value
10566          );
10567          break;
10568        case "xmlBase":
10569          setValueForNamespacedAttribute(
10570            domElement,
10571            "http://www.w3.org/XML/1998/namespace",
10572            "xml:base",
10573            value
10574          );
10575          break;
10576        case "xmlLang":
10577          setValueForNamespacedAttribute(
10578            domElement,
10579            "http://www.w3.org/XML/1998/namespace",
10580            "xml:lang",
10581            value
10582          );
10583          break;
10584        case "xmlSpace":
10585          setValueForNamespacedAttribute(
10586            domElement,
10587            "http://www.w3.org/XML/1998/namespace",
10588            "xml:space",
10589            value
10590          );
10591          break;
10592        case "is":
10593          setValueForAttribute(domElement, "is", value);
10594          break;
10595        case "innerText":
10596        case "textContent":
10597          break;
10598        default:
10599          if (!(2 < key2.length) || "o" !== key2[0] && "O" !== key2[0] || "n" !== key2[1] && "N" !== key2[1])
10600            key2 = aliases.get(key2) || key2, setValueForAttribute(domElement, key2, value);
10601      }
10602    }
10603    function setPropOnCustomElement(domElement, tag, key2, value, props, prevValue) {
10604      switch (key2) {
10605        case "style":
10606          setValueForStyles(domElement, value, prevValue);
10607          break;
10608        case "dangerouslySetInnerHTML":
10609          if (null != value) {
10610            if ("object" !== typeof value || !("__html" in value))
10611              throw Error(formatProdErrorMessage(61));
10612            key2 = value.__html;
10613            if (null != key2) {
10614              if (null != props.children) throw Error(formatProdErrorMessage(60));
10615              domElement.innerHTML = key2;
10616            }
10617          }
10618          break;
10619        case "children":
10620          "string" === typeof value ? setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && setTextContent(domElement, "" + value);
10621          break;
10622        case "onScroll":
10623          null != value && listenToNonDelegatedEvent("scroll", domElement);
10624          break;
10625        case "onScrollEnd":
10626          null != value && listenToNonDelegatedEvent("scrollend", domElement);
10627          break;
10628        case "onClick":
10629          null != value && (domElement.onclick = noop$12);
10630          break;
10631        case "suppressContentEditableWarning":
10632        case "suppressHydrationWarning":
10633        case "innerHTML":
10634        case "ref":
10635          break;
10636        case "innerText":
10637        case "textContent":
10638          break;
10639        default:
10640          if (!registrationNameDependencies.hasOwnProperty(key2))
10641            a: {
10642              if ("o" === key2[0] && "n" === key2[1] && (props = key2.endsWith("Capture"), tag = key2.slice(2, props ? key2.length - 7 : void 0), prevValue = domElement[internalPropsKey] || null, prevValue = null != prevValue ? prevValue[key2] : null, "function" === typeof prevValue && domElement.removeEventListener(tag, prevValue, props), "function" === typeof value)) {
10643                "function" !== typeof prevValue && null !== prevValue && (key2 in domElement ? domElement[key2] = null : domElement.hasAttribute(key2) && domElement.removeAttribute(key2));
10644                domElement.addEventListener(tag, value, props);
10645                break a;
10646              }
10647              key2 in domElement ? domElement[key2] = value : true === value ? domElement.setAttribute(key2, "") : setValueForAttribute(domElement, key2, value);
10648            }
10649      }
10650    }
10651    function setInitialProperties(domElement, tag, props) {
10652      switch (tag) {
10653        case "div":
10654        case "span":
10655        case "svg":
10656        case "path":
10657        case "a":
10658        case "g":
10659        case "p":
10660        case "li":
10661          break;
10662        case "img":
10663          listenToNonDelegatedEvent("error", domElement);
10664          listenToNonDelegatedEvent("load", domElement);
10665          var hasSrc = false, hasSrcSet = false, propKey;
10666          for (propKey in props)
10667            if (props.hasOwnProperty(propKey)) {
10668              var propValue = props[propKey];
10669              if (null != propValue)
10670                switch (propKey) {
10671                  case "src":
10672                    hasSrc = true;
10673                    break;
10674                  case "srcSet":
10675                    hasSrcSet = true;
10676                    break;
10677                  case "children":
10678                  case "dangerouslySetInnerHTML":
10679                    throw Error(formatProdErrorMessage(137, tag));
10680                  default:
10681                    setProp(domElement, tag, propKey, propValue, props, null);
10682                }
10683            }
10684          hasSrcSet && setProp(domElement, tag, "srcSet", props.srcSet, props, null);
10685          hasSrc && setProp(domElement, tag, "src", props.src, props, null);
10686          return;
10687        case "input":
10688          listenToNonDelegatedEvent("invalid", domElement);
10689          var defaultValue = propKey = propValue = hasSrcSet = null, checked = null, defaultChecked = null;
10690          for (hasSrc in props)
10691            if (props.hasOwnProperty(hasSrc)) {
10692              var propValue$184 = props[hasSrc];
10693              if (null != propValue$184)
10694                switch (hasSrc) {
10695                  case "name":
10696                    hasSrcSet = propValue$184;
10697                    break;
10698                  case "type":
10699                    propValue = propValue$184;
10700                    break;
10701                  case "checked":
10702                    checked = propValue$184;
10703                    break;
10704                  case "defaultChecked":
10705                    defaultChecked = propValue$184;
10706                    break;
10707                  case "value":
10708                    propKey = propValue$184;
10709                    break;
10710                  case "defaultValue":
10711                    defaultValue = propValue$184;
10712                    break;
10713                  case "children":
10714                  case "dangerouslySetInnerHTML":
10715                    if (null != propValue$184)
10716                      throw Error(formatProdErrorMessage(137, tag));
10717                    break;
10718                  default:
10719                    setProp(domElement, tag, hasSrc, propValue$184, props, null);
10720                }
10721            }
10722          initInput(
10723            domElement,
10724            propKey,
10725            defaultValue,
10726            checked,
10727            defaultChecked,
10728            propValue,
10729            hasSrcSet,
10730            false
10731          );
10732          return;
10733        case "select":
10734          listenToNonDelegatedEvent("invalid", domElement);
10735          hasSrc = propValue = propKey = null;
10736          for (hasSrcSet in props)
10737            if (props.hasOwnProperty(hasSrcSet) && (defaultValue = props[hasSrcSet], null != defaultValue))
10738              switch (hasSrcSet) {
10739                case "value":
10740                  propKey = defaultValue;
10741                  break;
10742                case "defaultValue":
10743                  propValue = defaultValue;
10744                  break;
10745                case "multiple":
10746                  hasSrc = defaultValue;
10747                default:
10748                  setProp(domElement, tag, hasSrcSet, defaultValue, props, null);
10749              }
10750          tag = propKey;
10751          props = propValue;
10752          domElement.multiple = !!hasSrc;
10753          null != tag ? updateOptions(domElement, !!hasSrc, tag, false) : null != props && updateOptions(domElement, !!hasSrc, props, true);
10754          return;
10755        case "textarea":
10756          listenToNonDelegatedEvent("invalid", domElement);
10757          propKey = hasSrcSet = hasSrc = null;
10758          for (propValue in props)
10759            if (props.hasOwnProperty(propValue) && (defaultValue = props[propValue], null != defaultValue))
10760              switch (propValue) {
10761                case "value":
10762                  hasSrc = defaultValue;
10763                  break;
10764                case "defaultValue":
10765                  hasSrcSet = defaultValue;
10766                  break;
10767                case "children":
10768                  propKey = defaultValue;
10769                  break;
10770                case "dangerouslySetInnerHTML":
10771                  if (null != defaultValue) throw Error(formatProdErrorMessage(91));
10772                  break;
10773                default:
10774                  setProp(domElement, tag, propValue, defaultValue, props, null);
10775              }
10776          initTextarea(domElement, hasSrc, hasSrcSet, propKey);
10777          return;
10778        case "option":
10779          for (checked in props)
10780            if (props.hasOwnProperty(checked) && (hasSrc = props[checked], null != hasSrc))
10781              switch (checked) {
10782                case "selected":
10783                  domElement.selected = hasSrc && "function" !== typeof hasSrc && "symbol" !== typeof hasSrc;
10784                  break;
10785                default:
10786                  setProp(domElement, tag, checked, hasSrc, props, null);
10787              }
10788          return;
10789        case "dialog":
10790          listenToNonDelegatedEvent("beforetoggle", domElement);
10791          listenToNonDelegatedEvent("toggle", domElement);
10792          listenToNonDelegatedEvent("cancel", domElement);
10793          listenToNonDelegatedEvent("close", domElement);
10794          break;
10795        case "iframe":
10796        case "object":
10797          listenToNonDelegatedEvent("load", domElement);
10798          break;
10799        case "video":
10800        case "audio":
10801          for (hasSrc = 0; hasSrc < mediaEventTypes.length; hasSrc++)
10802            listenToNonDelegatedEvent(mediaEventTypes[hasSrc], domElement);
10803          break;
10804        case "image":
10805          listenToNonDelegatedEvent("error", domElement);
10806          listenToNonDelegatedEvent("load", domElement);
10807          break;
10808        case "details":
10809          listenToNonDelegatedEvent("toggle", domElement);
10810          break;
10811        case "embed":
10812        case "source":
10813        case "link":
10814          listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement);
10815        case "area":
10816        case "base":
10817        case "br":
10818        case "col":
10819        case "hr":
10820        case "keygen":
10821        case "meta":
10822        case "param":
10823        case "track":
10824        case "wbr":
10825        case "menuitem":
10826          for (defaultChecked in props)
10827            if (props.hasOwnProperty(defaultChecked) && (hasSrc = props[defaultChecked], null != hasSrc))
10828              switch (defaultChecked) {
10829                case "children":
10830                case "dangerouslySetInnerHTML":
10831                  throw Error(formatProdErrorMessage(137, tag));
10832                default:
10833                  setProp(domElement, tag, defaultChecked, hasSrc, props, null);
10834              }
10835          return;
10836        default:
10837          if (isCustomElement(tag)) {
10838            for (propValue$184 in props)
10839              props.hasOwnProperty(propValue$184) && (hasSrc = props[propValue$184], void 0 !== hasSrc && setPropOnCustomElement(
10840                domElement,
10841                tag,
10842                propValue$184,
10843                hasSrc,
10844                props,
10845                void 0
10846              ));
10847            return;
10848          }
10849      }
10850      for (defaultValue in props)
10851        props.hasOwnProperty(defaultValue) && (hasSrc = props[defaultValue], null != hasSrc && setProp(domElement, tag, defaultValue, hasSrc, props, null));
10852    }
10853    function updateProperties(domElement, tag, lastProps, nextProps) {
10854      switch (tag) {
10855        case "div":
10856        case "span":
10857        case "svg":
10858        case "path":
10859        case "a":
10860        case "g":
10861        case "p":
10862        case "li":
10863          break;
10864        case "input":
10865          var name = null, type2 = null, value = null, defaultValue = null, lastDefaultValue = null, checked = null, defaultChecked = null;
10866          for (propKey in lastProps) {
10867            var lastProp = lastProps[propKey];
10868            if (lastProps.hasOwnProperty(propKey) && null != lastProp)
10869              switch (propKey) {
10870                case "checked":
10871                  break;
10872                case "value":
10873                  break;
10874                case "defaultValue":
10875                  lastDefaultValue = lastProp;
10876                default:
10877                  nextProps.hasOwnProperty(propKey) || setProp(domElement, tag, propKey, null, nextProps, lastProp);
10878              }
10879          }
10880          for (var propKey$201 in nextProps) {
10881            var propKey = nextProps[propKey$201];
10882            lastProp = lastProps[propKey$201];
10883            if (nextProps.hasOwnProperty(propKey$201) && (null != propKey || null != lastProp))
10884              switch (propKey$201) {
10885                case "type":
10886                  type2 = propKey;
10887                  break;
10888                case "name":
10889                  name = propKey;
10890                  break;
10891                case "checked":
10892                  checked = propKey;
10893                  break;
10894                case "defaultChecked":
10895                  defaultChecked = propKey;
10896                  break;
10897                case "value":
10898                  value = propKey;
10899                  break;
10900                case "defaultValue":
10901                  defaultValue = propKey;
10902                  break;
10903                case "children":
10904                case "dangerouslySetInnerHTML":
10905                  if (null != propKey)
10906                    throw Error(formatProdErrorMessage(137, tag));
10907                  break;
10908                default:
10909                  propKey !== lastProp && setProp(
10910                    domElement,
10911                    tag,
10912                    propKey$201,
10913                    propKey,
10914                    nextProps,
10915                    lastProp
10916                  );
10917              }
10918          }
10919          updateInput(
10920            domElement,
10921            value,
10922            defaultValue,
10923            lastDefaultValue,
10924            checked,
10925            defaultChecked,
10926            type2,
10927            name
10928          );
10929          return;
10930        case "select":
10931          propKey = value = defaultValue = propKey$201 = null;
10932          for (type2 in lastProps)
10933            if (lastDefaultValue = lastProps[type2], lastProps.hasOwnProperty(type2) && null != lastDefaultValue)
10934              switch (type2) {
10935                case "value":
10936                  break;
10937                case "multiple":
10938                  propKey = lastDefaultValue;
10939                default:
10940                  nextProps.hasOwnProperty(type2) || setProp(
10941                    domElement,
10942                    tag,
10943                    type2,
10944                    null,
10945                    nextProps,
10946                    lastDefaultValue
10947                  );
10948              }
10949          for (name in nextProps)
10950            if (type2 = nextProps[name], lastDefaultValue = lastProps[name], nextProps.hasOwnProperty(name) && (null != type2 || null != lastDefaultValue))
10951              switch (name) {
10952                case "value":
10953                  propKey$201 = type2;
10954                  break;
10955                case "defaultValue":
10956                  defaultValue = type2;
10957                  break;
10958                case "multiple":
10959                  value = type2;
10960                default:
10961                  type2 !== lastDefaultValue && setProp(
10962                    domElement,
10963                    tag,
10964                    name,
10965                    type2,
10966                    nextProps,
10967                    lastDefaultValue
10968                  );
10969              }
10970          tag = defaultValue;
10971          lastProps = value;
10972          nextProps = propKey;
10973          null != propKey$201 ? updateOptions(domElement, !!lastProps, propKey$201, false) : !!nextProps !== !!lastProps && (null != tag ? updateOptions(domElement, !!lastProps, tag, true) : updateOptions(domElement, !!lastProps, lastProps ? [] : "", false));
10974          return;
10975        case "textarea":
10976          propKey = propKey$201 = null;
10977          for (defaultValue in lastProps)
10978            if (name = lastProps[defaultValue], lastProps.hasOwnProperty(defaultValue) && null != name && !nextProps.hasOwnProperty(defaultValue))
10979              switch (defaultValue) {
10980                case "value":
10981                  break;
10982                case "children":
10983                  break;
10984                default:
10985                  setProp(domElement, tag, defaultValue, null, nextProps, name);
10986              }
10987          for (value in nextProps)
10988            if (name = nextProps[value], type2 = lastProps[value], nextProps.hasOwnProperty(value) && (null != name || null != type2))
10989              switch (value) {
10990                case "value":
10991                  propKey$201 = name;
10992                  break;
10993                case "defaultValue":
10994                  propKey = name;
10995                  break;
10996                case "children":
10997                  break;
10998                case "dangerouslySetInnerHTML":
10999                  if (null != name) throw Error(formatProdErrorMessage(91));
11000                  break;
11001                default:
11002                  name !== type2 && setProp(domElement, tag, value, name, nextProps, type2);
11003              }
11004          updateTextarea(domElement, propKey$201, propKey);
11005          return;
11006        case "option":
11007          for (var propKey$217 in lastProps)
11008            if (propKey$201 = lastProps[propKey$217], lastProps.hasOwnProperty(propKey$217) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$217))
11009              switch (propKey$217) {
11010                case "selected":
11011                  domElement.selected = false;
11012                  break;
11013                default:
11014                  setProp(
11015                    domElement,
11016                    tag,
11017                    propKey$217,
11018                    null,
11019                    nextProps,
11020                    propKey$201
11021                  );
11022              }
11023          for (lastDefaultValue in nextProps)
11024            if (propKey$201 = nextProps[lastDefaultValue], propKey = lastProps[lastDefaultValue], nextProps.hasOwnProperty(lastDefaultValue) && propKey$201 !== propKey && (null != propKey$201 || null != propKey))
11025              switch (lastDefaultValue) {
11026                case "selected":
11027                  domElement.selected = propKey$201 && "function" !== typeof propKey$201 && "symbol" !== typeof propKey$201;
11028                  break;
11029                default:
11030                  setProp(
11031                    domElement,
11032                    tag,
11033                    lastDefaultValue,
11034                    propKey$201,
11035                    nextProps,
11036                    propKey
11037                  );
11038              }
11039          return;
11040        case "img":
11041        case "link":
11042        case "area":
11043        case "base":
11044        case "br":
11045        case "col":
11046        case "embed":
11047        case "hr":
11048        case "keygen":
11049        case "meta":
11050        case "param":
11051        case "source":
11052        case "track":
11053        case "wbr":
11054        case "menuitem":
11055          for (var propKey$222 in lastProps)
11056            propKey$201 = lastProps[propKey$222], lastProps.hasOwnProperty(propKey$222) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$222) && setProp(domElement, tag, propKey$222, null, nextProps, propKey$201);
11057          for (checked in nextProps)
11058            if (propKey$201 = nextProps[checked], propKey = lastProps[checked], nextProps.hasOwnProperty(checked) && propKey$201 !== propKey && (null != propKey$201 || null != propKey))
11059              switch (checked) {
11060                case "children":
11061                case "dangerouslySetInnerHTML":
11062                  if (null != propKey$201)
11063                    throw Error(formatProdErrorMessage(137, tag));
11064                  break;
11065                default:
11066                  setProp(
11067                    domElement,
11068                    tag,
11069                    checked,
11070                    propKey$201,
11071                    nextProps,
11072                    propKey
11073                  );
11074              }
11075          return;
11076        default:
11077          if (isCustomElement(tag)) {
11078            for (var propKey$227 in lastProps)
11079              propKey$201 = lastProps[propKey$227], lastProps.hasOwnProperty(propKey$227) && void 0 !== propKey$201 && !nextProps.hasOwnProperty(propKey$227) && setPropOnCustomElement(
11080                domElement,
11081                tag,
11082                propKey$227,
11083                void 0,
11084                nextProps,
11085                propKey$201
11086              );
11087            for (defaultChecked in nextProps)
11088              propKey$201 = nextProps[defaultChecked], propKey = lastProps[defaultChecked], !nextProps.hasOwnProperty(defaultChecked) || propKey$201 === propKey || void 0 === propKey$201 && void 0 === propKey || setPropOnCustomElement(
11089                domElement,
11090                tag,
11091                defaultChecked,
11092                propKey$201,
11093                nextProps,
11094                propKey
11095              );
11096            return;
11097          }
11098      }
11099      for (var propKey$232 in lastProps)
11100        propKey$201 = lastProps[propKey$232], lastProps.hasOwnProperty(propKey$232) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$232) && setProp(domElement, tag, propKey$232, null, nextProps, propKey$201);
11101      for (lastProp in nextProps)
11102        propKey$201 = nextProps[lastProp], propKey = lastProps[lastProp], !nextProps.hasOwnProperty(lastProp) || propKey$201 === propKey || null == propKey$201 && null == propKey || setProp(domElement, tag, lastProp, propKey$201, nextProps, propKey);
11103    }
11104    function isLikelyStaticResource(initiatorType) {
11105      switch (initiatorType) {
11106        case "css":
11107        case "script":
11108        case "font":
11109        case "img":
11110        case "image":
11111        case "input":
11112        case "link":
11113          return true;
11114        default:
11115          return false;
11116      }
11117    }
11118    function estimateBandwidth() {
11119      if ("function" === typeof performance.getEntriesByType) {
11120        for (var count = 0, bits = 0, resourceEntries = performance.getEntriesByType("resource"), i2 = 0; i2 < resourceEntries.length; i2++) {
11121          var entry = resourceEntries[i2], transferSize = entry.transferSize, initiatorType = entry.initiatorType, duration = entry.duration;
11122          if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
11123            initiatorType = 0;
11124            duration = entry.responseEnd;
11125            for (i2 += 1; i2 < resourceEntries.length; i2++) {
11126              var overlapEntry = resourceEntries[i2], overlapStartTime = overlapEntry.startTime;
11127              if (overlapStartTime > duration) break;
11128              var overlapTransferSize = overlapEntry.transferSize, overlapInitiatorType = overlapEntry.initiatorType;
11129              overlapTransferSize && isLikelyStaticResource(overlapInitiatorType) && (overlapEntry = overlapEntry.responseEnd, initiatorType += overlapTransferSize * (overlapEntry < duration ? 1 : (duration - overlapStartTime) / (overlapEntry - overlapStartTime)));
11130            }
11131            --i2;
11132            bits += 8 * (transferSize + initiatorType) / (entry.duration / 1e3);
11133            count++;
11134            if (10 < count) break;
11135          }
11136        }
11137        if (0 < count) return bits / count / 1e6;
11138      }
11139      return navigator.connection && (count = navigator.connection.downlink, "number" === typeof count) ? count : 5;
11140    }
11141    var eventsEnabled = null, selectionInformation = null;
11142    function getOwnerDocumentFromRootContainer(rootContainerElement) {
11143      return 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
11144    }
11145    function getOwnHostContext(namespaceURI) {
11146      switch (namespaceURI) {
11147        case "http://www.w3.org/2000/svg":
11148          return 1;
11149        case "http://www.w3.org/1998/Math/MathML":
11150          return 2;
11151        default:
11152          return 0;
11153      }
11154    }
11155    function getChildHostContextProd(parentNamespace, type2) {
11156      if (0 === parentNamespace)
11157        switch (type2) {
11158          case "svg":
11159            return 1;
11160          case "math":
11161            return 2;
11162          default:
11163            return 0;
11164        }
11165      return 1 === parentNamespace && "foreignObject" === type2 ? 0 : parentNamespace;
11166    }
11167    function shouldSetTextContent(type2, props) {
11168      return "textarea" === type2 || "noscript" === type2 || "string" === typeof props.children || "number" === typeof props.children || "bigint" === typeof props.children || "object" === typeof props.dangerouslySetInnerHTML && null !== props.dangerouslySetInnerHTML && null != props.dangerouslySetInnerHTML.__html;
11169    }
11170    var currentPopstateTransitionEvent = null;
11171    function shouldAttemptEagerTransition() {
11172      var event = window.event;
11173      if (event && "popstate" === event.type) {
11174        if (event === currentPopstateTransitionEvent) return false;
11175        currentPopstateTransitionEvent = event;
11176        return true;
11177      }
11178      currentPopstateTransitionEvent = null;
11179      return false;
11180    }
11181    var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0, cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0, localPromise = "function" === typeof Promise ? Promise : void 0, scheduleMicrotask = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof localPromise ? function(callback) {
11182      return localPromise.resolve(null).then(callback).catch(handleErrorInNextTick);
11183    } : scheduleTimeout;
11184    function handleErrorInNextTick(error) {
11185      setTimeout(function() {
11186        throw error;
11187      });
11188    }
11189    function isSingletonScope(type2) {
11190      return "head" === type2;
11191    }
11192    function clearHydrationBoundary(parentInstance, hydrationInstance) {
11193      var node2 = hydrationInstance, depth = 0;
11194      do {
11195        var nextNode = node2.nextSibling;
11196        parentInstance.removeChild(node2);
11197        if (nextNode && 8 === nextNode.nodeType)
11198          if (node2 = nextNode.data, "/$" === node2 || "/&" === node2) {
11199            if (0 === depth) {
11200              parentInstance.removeChild(nextNode);
11201              retryIfBlockedOn(hydrationInstance);
11202              return;
11203            }
11204            depth--;
11205          } else if ("$" === node2 || "$?" === node2 || "$~" === node2 || "$!" === node2 || "&" === node2)
11206            depth++;
11207          else if ("html" === node2)
11208            releaseSingletonInstance(parentInstance.ownerDocument.documentElement);
11209          else if ("head" === node2) {
11210            node2 = parentInstance.ownerDocument.head;
11211            releaseSingletonInstance(node2);
11212            for (var node$jscomp$0 = node2.firstChild; node$jscomp$0; ) {
11213              var nextNode$jscomp$0 = node$jscomp$0.nextSibling, nodeName = node$jscomp$0.nodeName;
11214              node$jscomp$0[internalHoistableMarker] || "SCRIPT" === nodeName || "STYLE" === nodeName || "LINK" === nodeName && "stylesheet" === node$jscomp$0.rel.toLowerCase() || node2.removeChild(node$jscomp$0);
11215              node$jscomp$0 = nextNode$jscomp$0;
11216            }
11217          } else
11218            "body" === node2 && releaseSingletonInstance(parentInstance.ownerDocument.body);
11219        node2 = nextNode;
11220      } while (node2);
11221      retryIfBlockedOn(hydrationInstance);
11222    }
11223    function hideOrUnhideDehydratedBoundary(suspenseInstance, isHidden) {
11224      var node2 = suspenseInstance;
11225      suspenseInstance = 0;
11226      do {
11227        var nextNode = node2.nextSibling;
11228        1 === node2.nodeType ? isHidden ? (node2._stashedDisplay = node2.style.display, node2.style.display = "none") : (node2.style.display = node2._stashedDisplay || "", "" === node2.getAttribute("style") && node2.removeAttribute("style")) : 3 === node2.nodeType && (isHidden ? (node2._stashedText = node2.nodeValue, node2.nodeValue = "") : node2.nodeValue = node2._stashedText || "");
11229        if (nextNode && 8 === nextNode.nodeType)
11230          if (node2 = nextNode.data, "/$" === node2)
11231            if (0 === suspenseInstance) break;
11232            else suspenseInstance--;
11233          else

vendor: 4,942 bytes, lines 11234-11341

11234            "$" !== node2 && "$?" !== node2 && "$~" !== node2 && "$!" !== node2 || suspenseInstance++;
11235        node2 = nextNode;
11236      } while (node2);
11237    }
11238    function clearContainerSparingly(container) {
11239      var nextNode = container.firstChild;
11240      nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
11241      for (; nextNode; ) {
11242        var node2 = nextNode;
11243        nextNode = nextNode.nextSibling;
11244        switch (node2.nodeName) {
11245          case "HTML":
11246          case "HEAD":
11247          case "BODY":
11248            clearContainerSparingly(node2);
11249            detachDeletedInstance(node2);
11250            continue;
11251          case "SCRIPT":
11252          case "STYLE":
11253            continue;
11254          case "LINK":
11255            if ("stylesheet" === node2.rel.toLowerCase()) continue;
11256        }
11257        container.removeChild(node2);
11258      }
11259    }
11260    function canHydrateInstance(instance, type2, props, inRootOrSingleton) {
11261      for (; 1 === instance.nodeType; ) {
11262        var anyProps = props;
11263        if (instance.nodeName.toLowerCase() !== type2.toLowerCase()) {
11264          if (!inRootOrSingleton && ("INPUT" !== instance.nodeName || "hidden" !== instance.type))
11265            break;
11266        } else if (!inRootOrSingleton)
11267          if ("input" === type2 && "hidden" === instance.type) {
11268            var name = null == anyProps.name ? null : "" + anyProps.name;
11269            if ("hidden" === anyProps.type && instance.getAttribute("name") === name)
11270              return instance;
11271          } else return instance;
11272        else if (!instance[internalHoistableMarker])
11273          switch (type2) {
11274            case "meta":
11275              if (!instance.hasAttribute("itemprop")) break;
11276              return instance;
11277            case "link":
11278              name = instance.getAttribute("rel");
11279              if ("stylesheet" === name && instance.hasAttribute("data-precedence"))
11280                break;
11281              else if (name !== anyProps.rel || instance.getAttribute("href") !== (null == anyProps.href || "" === anyProps.href ? null : anyProps.href) || instance.getAttribute("crossorigin") !== (null == anyProps.crossOrigin ? null : anyProps.crossOrigin) || instance.getAttribute("title") !== (null == anyProps.title ? null : anyProps.title))
11282                break;
11283              return instance;
11284            case "style":
11285              if (instance.hasAttribute("data-precedence")) break;
11286              return instance;
11287            case "script":
11288              name = instance.getAttribute("src");
11289              if ((name !== (null == anyProps.src ? null : anyProps.src) || instance.getAttribute("type") !== (null == anyProps.type ? null : anyProps.type) || instance.getAttribute("crossorigin") !== (null == anyProps.crossOrigin ? null : anyProps.crossOrigin)) && name && instance.hasAttribute("async") && !instance.hasAttribute("itemprop"))
11290                break;
11291              return instance;
11292            default:
11293              return instance;
11294          }
11295        instance = getNextHydratable(instance.nextSibling);
11296        if (null === instance) break;
11297      }
11298      return null;
11299    }
11300    function canHydrateTextInstance(instance, text, inRootOrSingleton) {
11301      if ("" === text) return null;
11302      for (; 3 !== instance.nodeType; ) {
11303        if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
11304          return null;
11305        instance = getNextHydratable(instance.nextSibling);
11306        if (null === instance) return null;
11307      }
11308      return instance;
11309    }
11310    function canHydrateHydrationBoundary(instance, inRootOrSingleton) {
11311      for (; 8 !== instance.nodeType; ) {
11312        if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
11313          return null;
11314        instance = getNextHydratable(instance.nextSibling);
11315        if (null === instance) return null;
11316      }
11317      return instance;
11318    }
11319    function isSuspenseInstancePending(instance) {
11320      return "$?" === instance.data || "$~" === instance.data;
11321    }
11322    function isSuspenseInstanceFallback(instance) {
11323      return "$!" === instance.data || "$?" === instance.data && "loading" !== instance.ownerDocument.readyState;
11324    }
11325    function registerSuspenseInstanceRetry(instance, callback) {
11326      var ownerDocument = instance.ownerDocument;
11327      if ("$~" === instance.data) instance._reactRetry = callback;
11328      else if ("$?" !== instance.data || "loading" !== ownerDocument.readyState)
11329        callback();
11330      else {
11331        var listener = function() {
11332          callback();
11333          ownerDocument.removeEventListener("DOMContentLoaded", listener);
11334        };
11335        ownerDocument.addEventListener("DOMContentLoaded", listener);
11336        instance._reactRetry = listener;
11337      }
11338    }
11339    function getNextHydratable(node2) {
11340      for (; null != node2; node2 = node2.nextSibling) {
11341        var nodeType = node2.nodeType;

vendor: 21,906 bytes, lines 11342-11769

11342        if (1 === nodeType || 3 === nodeType) break;
11343        if (8 === nodeType) {
11344          nodeType = node2.data;
11345          if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType || "$~" === nodeType || "&" === nodeType || "F!" === nodeType || "F" === nodeType)
11346            break;
11347          if ("/$" === nodeType || "/&" === nodeType) return null;
11348        }
11349      }
11350      return node2;
11351    }
11352    var previousHydratableOnEnteringScopedSingleton = null;
11353    function getNextHydratableInstanceAfterHydrationBoundary(hydrationInstance) {
11354      hydrationInstance = hydrationInstance.nextSibling;
11355      for (var depth = 0; hydrationInstance; ) {
11356        if (8 === hydrationInstance.nodeType) {
11357          var data = hydrationInstance.data;
11358          if ("/$" === data || "/&" === data) {
11359            if (0 === depth)
11360              return getNextHydratable(hydrationInstance.nextSibling);
11361            depth--;
11362          } else
11363            "$" !== data && "$!" !== data && "$?" !== data && "$~" !== data && "&" !== data || depth++;
11364        }
11365        hydrationInstance = hydrationInstance.nextSibling;
11366      }
11367      return null;
11368    }
11369    function getParentHydrationBoundary(targetInstance) {
11370      targetInstance = targetInstance.previousSibling;
11371      for (var depth = 0; targetInstance; ) {
11372        if (8 === targetInstance.nodeType) {
11373          var data = targetInstance.data;
11374          if ("$" === data || "$!" === data || "$?" === data || "$~" === data || "&" === data) {
11375            if (0 === depth) return targetInstance;
11376            depth--;
11377          } else "/$" !== data && "/&" !== data || depth++;
11378        }
11379        targetInstance = targetInstance.previousSibling;
11380      }
11381      return null;
11382    }
11383    function resolveSingletonInstance(type2, props, rootContainerInstance) {
11384      props = getOwnerDocumentFromRootContainer(rootContainerInstance);
11385      switch (type2) {
11386        case "html":
11387          type2 = props.documentElement;
11388          if (!type2) throw Error(formatProdErrorMessage(452));
11389          return type2;
11390        case "head":
11391          type2 = props.head;
11392          if (!type2) throw Error(formatProdErrorMessage(453));
11393          return type2;
11394        case "body":
11395          type2 = props.body;
11396          if (!type2) throw Error(formatProdErrorMessage(454));
11397          return type2;
11398        default:
11399          throw Error(formatProdErrorMessage(451));
11400      }
11401    }
11402    function releaseSingletonInstance(instance) {
11403      for (var attributes = instance.attributes; attributes.length; )
11404        instance.removeAttributeNode(attributes[0]);
11405      detachDeletedInstance(instance);
11406    }
11407    var preloadPropsMap = /* @__PURE__ */ new Map(), preconnectsSet = /* @__PURE__ */ new Set();
11408    function getHoistableRoot(container) {
11409      return "function" === typeof container.getRootNode ? container.getRootNode() : 9 === container.nodeType ? container : container.ownerDocument;
11410    }
11411    var previousDispatcher = ReactDOMSharedInternals.d;
11412    ReactDOMSharedInternals.d = {
11413      f: flushSyncWork,
11414      r: requestFormReset,
11415      D: prefetchDNS,
11416      C: preconnect,
11417      L: preload,
11418      m: preloadModule,
11419      X: preinitScript,
11420      S: preinitStyle,
11421      M: preinitModuleScript
11422    };
11423    function flushSyncWork() {
11424      var previousWasRendering = previousDispatcher.f(), wasRendering = flushSyncWork$1();
11425      return previousWasRendering || wasRendering;
11426    }
11427    function requestFormReset(form) {
11428      var formInst = getInstanceFromNode(form);
11429      null !== formInst && 5 === formInst.tag && "form" === formInst.type ? requestFormReset$1(formInst) : previousDispatcher.r(form);
11430    }
11431    var globalDocument = "undefined" === typeof document ? null : document;
11432    function preconnectAs(rel, href, crossOrigin) {
11433      var ownerDocument = globalDocument;
11434      if (ownerDocument && "string" === typeof href && href) {
11435        var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
11436        limitedEscapedHref = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
11437        "string" === typeof crossOrigin && (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
11438        preconnectsSet.has(limitedEscapedHref) || (preconnectsSet.add(limitedEscapedHref), rel = { rel, crossOrigin, href }, null === ownerDocument.querySelector(limitedEscapedHref) && (href = ownerDocument.createElement("link"), setInitialProperties(href, "link", rel), markNodeAsHoistable(href), ownerDocument.head.appendChild(href)));
11439      }
11440    }
11441    function prefetchDNS(href) {
11442      previousDispatcher.D(href);
11443      preconnectAs("dns-prefetch", href, null);
11444    }
11445    function preconnect(href, crossOrigin) {
11446      previousDispatcher.C(href, crossOrigin);
11447      preconnectAs("preconnect", href, crossOrigin);
11448    }
11449    function preload(href, as, options2) {
11450      previousDispatcher.L(href, as, options2);
11451      var ownerDocument = globalDocument;
11452      if (ownerDocument && href && as) {
11453        var preloadSelector = 'link[rel="preload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"]';
11454        "image" === as ? options2 && options2.imageSrcSet ? (preloadSelector += '[imagesrcset="' + escapeSelectorAttributeValueInsideDoubleQuotes(
11455          options2.imageSrcSet
11456        ) + '"]', "string" === typeof options2.imageSizes && (preloadSelector += '[imagesizes="' + escapeSelectorAttributeValueInsideDoubleQuotes(
11457          options2.imageSizes
11458        ) + '"]')) : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]' : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]';
11459        var key2 = preloadSelector;
11460        switch (as) {
11461          case "style":
11462            key2 = getStyleKey(href);
11463            break;
11464          case "script":
11465            key2 = getScriptKey(href);
11466        }
11467        preloadPropsMap.has(key2) || (href = assign(
11468          {
11469            rel: "preload",
11470            href: "image" === as && options2 && options2.imageSrcSet ? void 0 : href,
11471            as
11472          },
11473          options2
11474        ), preloadPropsMap.set(key2, href), null !== ownerDocument.querySelector(preloadSelector) || "style" === as && ownerDocument.querySelector(getStylesheetSelectorFromKey(key2)) || "script" === as && ownerDocument.querySelector(getScriptSelectorFromKey(key2)) || (as = ownerDocument.createElement("link"), setInitialProperties(as, "link", href), markNodeAsHoistable(as), ownerDocument.head.appendChild(as)));
11475      }
11476    }
11477    function preloadModule(href, options2) {
11478      previousDispatcher.m(href, options2);
11479      var ownerDocument = globalDocument;
11480      if (ownerDocument && href) {
11481        var as = options2 && "string" === typeof options2.as ? options2.as : "script", preloadSelector = 'link[rel="modulepreload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"][href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]', key2 = preloadSelector;
11482        switch (as) {
11483          case "audioworklet":
11484          case "paintworklet":
11485          case "serviceworker":
11486          case "sharedworker":
11487          case "worker":
11488          case "script":
11489            key2 = getScriptKey(href);
11490        }
11491        if (!preloadPropsMap.has(key2) && (href = assign({ rel: "modulepreload", href }, options2), preloadPropsMap.set(key2, href), null === ownerDocument.querySelector(preloadSelector))) {
11492          switch (as) {
11493            case "audioworklet":
11494            case "paintworklet":
11495            case "serviceworker":
11496            case "sharedworker":
11497            case "worker":
11498            case "script":
11499              if (ownerDocument.querySelector(getScriptSelectorFromKey(key2)))
11500                return;
11501          }
11502          as = ownerDocument.createElement("link");
11503          setInitialProperties(as, "link", href);
11504          markNodeAsHoistable(as);
11505          ownerDocument.head.appendChild(as);
11506        }
11507      }
11508    }
11509    function preinitStyle(href, precedence, options2) {
11510      previousDispatcher.S(href, precedence, options2);
11511      var ownerDocument = globalDocument;
11512      if (ownerDocument && href) {
11513        var styles = getResourcesFromRoot(ownerDocument).hoistableStyles, key2 = getStyleKey(href);
11514        precedence = precedence || "default";
11515        var resource = styles.get(key2);
11516        if (!resource) {
11517          var state2 = { loading: 0, preload: null };
11518          if (resource = ownerDocument.querySelector(
11519            getStylesheetSelectorFromKey(key2)
11520          ))
11521            state2.loading = 5;
11522          else {
11523            href = assign(
11524              { rel: "stylesheet", href, "data-precedence": precedence },
11525              options2
11526            );
11527            (options2 = preloadPropsMap.get(key2)) && adoptPreloadPropsForStylesheet(href, options2);
11528            var link = resource = ownerDocument.createElement("link");
11529            markNodeAsHoistable(link);
11530            setInitialProperties(link, "link", href);
11531            link._p = new Promise(function(resolve, reject) {
11532              link.onload = resolve;
11533              link.onerror = reject;
11534            });
11535            link.addEventListener("load", function() {
11536              state2.loading |= 1;
11537            });
11538            link.addEventListener("error", function() {
11539              state2.loading |= 2;
11540            });
11541            state2.loading |= 4;
11542            insertStylesheet(resource, precedence, ownerDocument);
11543          }
11544          resource = {
11545            type: "stylesheet",
11546            instance: resource,
11547            count: 1,
11548            state: state2
11549          };
11550          styles.set(key2, resource);
11551        }
11552      }
11553    }
11554    function preinitScript(src2, options2) {
11555      previousDispatcher.X(src2, options2);
11556      var ownerDocument = globalDocument;
11557      if (ownerDocument && src2) {
11558        var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key2 = getScriptKey(src2), resource = scripts.get(key2);
11559        resource || (resource = ownerDocument.querySelector(getScriptSelectorFromKey(key2)), resource || (src2 = assign({ src: src2, async: true }, options2), (options2 = preloadPropsMap.get(key2)) && adoptPreloadPropsForScript(src2, options2), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src2), ownerDocument.head.appendChild(resource)), resource = {
11560          type: "script",
11561          instance: resource,
11562          count: 1,
11563          state: null
11564        }, scripts.set(key2, resource));
11565      }
11566    }
11567    function preinitModuleScript(src2, options2) {
11568      previousDispatcher.M(src2, options2);
11569      var ownerDocument = globalDocument;
11570      if (ownerDocument && src2) {
11571        var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key2 = getScriptKey(src2), resource = scripts.get(key2);
11572        resource || (resource = ownerDocument.querySelector(getScriptSelectorFromKey(key2)), resource || (src2 = assign({ src: src2, async: true, type: "module" }, options2), (options2 = preloadPropsMap.get(key2)) && adoptPreloadPropsForScript(src2, options2), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src2), ownerDocument.head.appendChild(resource)), resource = {
11573          type: "script",
11574          instance: resource,
11575          count: 1,
11576          state: null
11577        }, scripts.set(key2, resource));
11578      }
11579    }
11580    function getResource(type2, currentProps, pendingProps, currentResource) {
11581      var JSCompiler_inline_result = (JSCompiler_inline_result = rootInstanceStackCursor.current) ? getHoistableRoot(JSCompiler_inline_result) : null;
11582      if (!JSCompiler_inline_result) throw Error(formatProdErrorMessage(446));
11583      switch (type2) {
11584        case "meta":
11585        case "title":
11586          return null;
11587        case "style":
11588          return "string" === typeof pendingProps.precedence && "string" === typeof pendingProps.href ? (currentProps = getStyleKey(pendingProps.href), pendingProps = getResourcesFromRoot(
11589            JSCompiler_inline_result
11590          ).hoistableStyles, currentResource = pendingProps.get(currentProps), currentResource || (currentResource = {
11591            type: "style",
11592            instance: null,
11593            count: 0,
11594            state: null
11595          }, pendingProps.set(currentProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
11596        case "link":
11597          if ("stylesheet" === pendingProps.rel && "string" === typeof pendingProps.href && "string" === typeof pendingProps.precedence) {
11598            type2 = getStyleKey(pendingProps.href);
11599            var styles$243 = getResourcesFromRoot(
11600              JSCompiler_inline_result
11601            ).hoistableStyles, resource$244 = styles$243.get(type2);
11602            resource$244 || (JSCompiler_inline_result = JSCompiler_inline_result.ownerDocument || JSCompiler_inline_result, resource$244 = {
11603              type: "stylesheet",
11604              instance: null,
11605              count: 0,
11606              state: { loading: 0, preload: null }
11607            }, styles$243.set(type2, resource$244), (styles$243 = JSCompiler_inline_result.querySelector(
11608              getStylesheetSelectorFromKey(type2)
11609            )) && !styles$243._p && (resource$244.instance = styles$243, resource$244.state.loading = 5), preloadPropsMap.has(type2) || (pendingProps = {
11610              rel: "preload",
11611              as: "style",
11612              href: pendingProps.href,
11613              crossOrigin: pendingProps.crossOrigin,
11614              integrity: pendingProps.integrity,
11615              media: pendingProps.media,
11616              hrefLang: pendingProps.hrefLang,
11617              referrerPolicy: pendingProps.referrerPolicy
11618            }, preloadPropsMap.set(type2, pendingProps), styles$243 || preloadStylesheet(
11619              JSCompiler_inline_result,
11620              type2,
11621              pendingProps,
11622              resource$244.state
11623            )));
11624            if (currentProps && null === currentResource)
11625              throw Error(formatProdErrorMessage(528, ""));
11626            return resource$244;
11627          }
11628          if (currentProps && null !== currentResource)
11629            throw Error(formatProdErrorMessage(529, ""));
11630          return null;
11631        case "script":
11632          return currentProps = pendingProps.async, pendingProps = pendingProps.src, "string" === typeof pendingProps && currentProps && "function" !== typeof currentProps && "symbol" !== typeof currentProps ? (currentProps = getScriptKey(pendingProps), pendingProps = getResourcesFromRoot(
11633            JSCompiler_inline_result
11634          ).hoistableScripts, currentResource = pendingProps.get(currentProps), currentResource || (currentResource = {
11635            type: "script",
11636            instance: null,
11637            count: 0,
11638            state: null
11639          }, pendingProps.set(currentProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
11640        default:
11641          throw Error(formatProdErrorMessage(444, type2));
11642      }
11643    }
11644    function getStyleKey(href) {
11645      return 'href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
11646    }
11647    function getStylesheetSelectorFromKey(key2) {
11648      return 'link[rel="stylesheet"][' + key2 + "]";
11649    }
11650    function stylesheetPropsFromRawProps(rawProps) {
11651      return assign({}, rawProps, {
11652        "data-precedence": rawProps.precedence,
11653        precedence: null
11654      });
11655    }
11656    function preloadStylesheet(ownerDocument, key2, preloadProps, state2) {
11657      ownerDocument.querySelector('link[rel="preload"][as="style"][' + key2 + "]") ? state2.loading = 1 : (key2 = ownerDocument.createElement("link"), state2.preload = key2, key2.addEventListener("load", function() {
11658        return state2.loading |= 1;
11659      }), key2.addEventListener("error", function() {
11660        return state2.loading |= 2;
11661      }), setInitialProperties(key2, "link", preloadProps), markNodeAsHoistable(key2), ownerDocument.head.appendChild(key2));
11662    }
11663    function getScriptKey(src2) {
11664      return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src2) + '"]';
11665    }
11666    function getScriptSelectorFromKey(key2) {
11667      return "script[async]" + key2;
11668    }
11669    function acquireResource(hoistableRoot, resource, props) {
11670      resource.count++;
11671      if (null === resource.instance)
11672        switch (resource.type) {
11673          case "style":
11674            var instance = hoistableRoot.querySelector(
11675              'style[data-href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(props.href) + '"]'
11676            );
11677            if (instance)
11678              return resource.instance = instance, markNodeAsHoistable(instance), instance;
11679            var styleProps = assign({}, props, {
11680              "data-href": props.href,
11681              "data-precedence": props.precedence,
11682              href: null,
11683              precedence: null
11684            });
11685            instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
11686              "style"
11687            );
11688            markNodeAsHoistable(instance);
11689            setInitialProperties(instance, "style", styleProps);
11690            insertStylesheet(instance, props.precedence, hoistableRoot);
11691            return resource.instance = instance;
11692          case "stylesheet":
11693            styleProps = getStyleKey(props.href);
11694            var instance$249 = hoistableRoot.querySelector(
11695              getStylesheetSelectorFromKey(styleProps)
11696            );
11697            if (instance$249)
11698              return resource.state.loading |= 4, resource.instance = instance$249, markNodeAsHoistable(instance$249), instance$249;
11699            instance = stylesheetPropsFromRawProps(props);
11700            (styleProps = preloadPropsMap.get(styleProps)) && adoptPreloadPropsForStylesheet(instance, styleProps);
11701            instance$249 = (hoistableRoot.ownerDocument || hoistableRoot).createElement("link");
11702            markNodeAsHoistable(instance$249);
11703            var linkInstance = instance$249;
11704            linkInstance._p = new Promise(function(resolve, reject) {
11705              linkInstance.onload = resolve;
11706              linkInstance.onerror = reject;
11707            });
11708            setInitialProperties(instance$249, "link", instance);
11709            resource.state.loading |= 4;
11710            insertStylesheet(instance$249, props.precedence, hoistableRoot);
11711            return resource.instance = instance$249;
11712          case "script":
11713            instance$249 = getScriptKey(props.src);
11714            if (styleProps = hoistableRoot.querySelector(
11715              getScriptSelectorFromKey(instance$249)
11716            ))
11717              return resource.instance = styleProps, markNodeAsHoistable(styleProps), styleProps;
11718            instance = props;
11719            if (styleProps = preloadPropsMap.get(instance$249))
11720              instance = assign({}, props), adoptPreloadPropsForScript(instance, styleProps);
11721            hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
11722            styleProps = hoistableRoot.createElement("script");
11723            markNodeAsHoistable(styleProps);
11724            setInitialProperties(styleProps, "link", instance);
11725            hoistableRoot.head.appendChild(styleProps);
11726            return resource.instance = styleProps;
11727          case "void":
11728            return null;
11729          default:
11730            throw Error(formatProdErrorMessage(443, resource.type));
11731        }
11732      else
11733        "stylesheet" === resource.type && 0 === (resource.state.loading & 4) && (instance = resource.instance, resource.state.loading |= 4, insertStylesheet(instance, props.precedence, hoistableRoot));
11734      return resource.instance;
11735    }
11736    function insertStylesheet(instance, precedence, root2) {
11737      for (var nodes = root2.querySelectorAll(
11738        'link[rel="stylesheet"][data-precedence],style[data-precedence]'
11739      ), last = nodes.length ? nodes[nodes.length - 1] : null, prior = last, i2 = 0; i2 < nodes.length; i2++) {
11740        var node2 = nodes[i2];
11741        if (node2.dataset.precedence === precedence) prior = node2;
11742        else if (prior !== last) break;
11743      }
11744      prior ? prior.parentNode.insertBefore(instance, prior.nextSibling) : (precedence = 9 === root2.nodeType ? root2.head : root2, precedence.insertBefore(instance, precedence.firstChild));
11745    }
11746    function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
11747      null == stylesheetProps.crossOrigin && (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
11748      null == stylesheetProps.referrerPolicy && (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
11749      null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
11750    }
11751    function adoptPreloadPropsForScript(scriptProps, preloadProps) {
11752      null == scriptProps.crossOrigin && (scriptProps.crossOrigin = preloadProps.crossOrigin);
11753      null == scriptProps.referrerPolicy && (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
11754      null == scriptProps.integrity && (scriptProps.integrity = preloadProps.integrity);
11755    }
11756    var tagCaches = null;
11757    function getHydratableHoistableCache(type2, keyAttribute, ownerDocument) {
11758      if (null === tagCaches) {
11759        var cache2 = /* @__PURE__ */ new Map();
11760        var caches = tagCaches = /* @__PURE__ */ new Map();
11761        caches.set(ownerDocument, cache2);
11762      } else
11763        caches = tagCaches, cache2 = caches.get(ownerDocument), cache2 || (cache2 = /* @__PURE__ */ new Map(), caches.set(ownerDocument, cache2));
11764      if (cache2.has(type2)) return cache2;
11765      cache2.set(type2, null);
11766      ownerDocument = ownerDocument.getElementsByTagName(type2);
11767      for (caches = 0; caches < ownerDocument.length; caches++) {
11768        var node2 = ownerDocument[caches];
11769        if (!(node2[internalHoistableMarker] || node2[internalInstanceKey] || "link" === type2 && "stylesheet" === node2.getAttribute("rel")) && "http://www.w3.org/2000/svg" !== no

vendor: 4,253 bytes, lines 11769-11856

11769de2.namespaceURI) {
11770          var nodeKey = node2.getAttribute(keyAttribute) || "";
11771          nodeKey = type2 + nodeKey;
11772          var existing = cache2.get(nodeKey);
11773          existing ? existing.push(node2) : cache2.set(nodeKey, [node2]);
11774        }
11775      }
11776      return cache2;
11777    }
11778    function mountHoistable(hoistableRoot, type2, instance) {
11779      hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
11780      hoistableRoot.head.insertBefore(
11781        instance,
11782        "title" === type2 ? hoistableRoot.querySelector("head > title") : null
11783      );
11784    }
11785    function isHostHoistableType(type2, props, hostContext) {
11786      if (1 === hostContext || null != props.itemProp) return false;
11787      switch (type2) {
11788        case "meta":
11789        case "title":
11790          return true;
11791        case "style":
11792          if ("string" !== typeof props.precedence || "string" !== typeof props.href || "" === props.href)
11793            break;
11794          return true;
11795        case "link":
11796          if ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href || props.onLoad || props.onError)
11797            break;
11798          switch (props.rel) {
11799            case "stylesheet":
11800              return type2 = props.disabled, "string" === typeof props.precedence && null == type2;
11801            default:
11802              return true;
11803          }
11804        case "script":
11805          if (props.async && "function" !== typeof props.async && "symbol" !== typeof props.async && !props.onLoad && !props.onError && props.src && "string" === typeof props.src)
11806            return true;
11807      }
11808      return false;
11809    }
11810    function preloadResource(resource) {
11811      return "stylesheet" === resource.type && 0 === (resource.state.loading & 3) ? false : true;
11812    }
11813    function suspendResource(state2, hoistableRoot, resource, props) {
11814      if ("stylesheet" === resource.type && ("string" !== typeof props.media || false !== matchMedia(props.media).matches) && 0 === (resource.state.loading & 4)) {
11815        if (null === resource.instance) {
11816          var key2 = getStyleKey(props.href), instance = hoistableRoot.querySelector(
11817            getStylesheetSelectorFromKey(key2)
11818          );
11819          if (instance) {
11820            hoistableRoot = instance._p;
11821            null !== hoistableRoot && "object" === typeof hoistableRoot && "function" === typeof hoistableRoot.then && (state2.count++, state2 = onUnsuspend.bind(state2), hoistableRoot.then(state2, state2));
11822            resource.state.loading |= 4;
11823            resource.instance = instance;
11824            markNodeAsHoistable(instance);
11825            return;
11826          }
11827          instance = hoistableRoot.ownerDocument || hoistableRoot;
11828          props = stylesheetPropsFromRawProps(props);
11829          (key2 = preloadPropsMap.get(key2)) && adoptPreloadPropsForStylesheet(props, key2);
11830          instance = instance.createElement("link");
11831          markNodeAsHoistable(instance);
11832          var linkInstance = instance;
11833          linkInstance._p = new Promise(function(resolve, reject) {
11834            linkInstance.onload = resolve;
11835            linkInstance.onerror = reject;
11836          });
11837          setInitialProperties(instance, "link", props);
11838          resource.instance = instance;
11839        }
11840        null === state2.stylesheets && (state2.stylesheets = /* @__PURE__ */ new Map());
11841        state2.stylesheets.set(resource, hoistableRoot);
11842        (hoistableRoot = resource.state.preload) && 0 === (resource.state.loading & 3) && (state2.count++, resource = onUnsuspend.bind(state2), hoistableRoot.addEventListener("load", resource), hoistableRoot.addEventListener("error", resource));
11843      }
11844    }
11845    var estimatedBytesWithinLimit = 0;
11846    function waitForCommitToBeReady(state2, timeoutOffset) {
11847      state2.stylesheets && 0 === state2.count && insertSuspendedStylesheets(state2, state2.stylesheets);
11848      return 0 < state2.count || 0 < state2.imgCount ? function(commit) {
11849        var stylesheetTimer = setTimeout(function() {
11850          state2.stylesheets && insertSuspendedStylesheets(state2, state2.stylesheets);
11851          if (state2.unsuspend) {
11852            var unsuspend = state2.unsuspend;
11853            state2.unsuspend = null;
11854            unsuspend();
11855          }
11856        }, 6e4 + timeoutOffset);

vendor: 11,698 bytes, lines 11857-12124

11857        0 < state2.imgBytes && 0 === estimatedBytesWithinLimit && (estimatedBytesWithinLimit = 62500 * estimateBandwidth());
11858        var imgTimer = setTimeout(
11859          function() {
11860            state2.waitingForImages = false;
11861            if (0 === state2.count && (state2.stylesheets && insertSuspendedStylesheets(state2, state2.stylesheets), state2.unsuspend)) {
11862              var unsuspend = state2.unsuspend;
11863              state2.unsuspend = null;
11864              unsuspend();
11865            }
11866          },
11867          (state2.imgBytes > estimatedBytesWithinLimit ? 50 : 800) + timeoutOffset
11868        );
11869        state2.unsuspend = commit;
11870        return function() {
11871          state2.unsuspend = null;
11872          clearTimeout(stylesheetTimer);
11873          clearTimeout(imgTimer);
11874        };
11875      } : null;
11876    }
11877    function onUnsuspend() {
11878      this.count--;
11879      if (0 === this.count && (0 === this.imgCount || !this.waitingForImages)) {
11880        if (this.stylesheets) insertSuspendedStylesheets(this, this.stylesheets);
11881        else if (this.unsuspend) {
11882          var unsuspend = this.unsuspend;
11883          this.unsuspend = null;
11884          unsuspend();
11885        }
11886      }
11887    }
11888    var precedencesByRoot = null;
11889    function insertSuspendedStylesheets(state2, resources) {
11890      state2.stylesheets = null;
11891      null !== state2.unsuspend && (state2.count++, precedencesByRoot = /* @__PURE__ */ new Map(), resources.forEach(insertStylesheetIntoRoot, state2), precedencesByRoot = null, onUnsuspend.call(state2));
11892    }
11893    function insertStylesheetIntoRoot(root2, resource) {
11894      if (!(resource.state.loading & 4)) {
11895        var precedences = precedencesByRoot.get(root2);
11896        if (precedences) var last = precedences.get(null);
11897        else {
11898          precedences = /* @__PURE__ */ new Map();
11899          precedencesByRoot.set(root2, precedences);
11900          for (var nodes = root2.querySelectorAll(
11901            "link[data-precedence],style[data-precedence]"
11902          ), i2 = 0; i2 < nodes.length; i2++) {
11903            var node2 = nodes[i2];
11904            if ("LINK" === node2.nodeName || "not all" !== node2.getAttribute("media"))
11905              precedences.set(node2.dataset.precedence, node2), last = node2;
11906          }
11907          last && precedences.set(null, last);
11908        }
11909        nodes = resource.instance;
11910        node2 = nodes.getAttribute("data-precedence");
11911        i2 = precedences.get(node2) || last;
11912        i2 === last && precedences.set(null, nodes);
11913        precedences.set(node2, nodes);
11914        this.count++;
11915        last = onUnsuspend.bind(this);
11916        nodes.addEventListener("load", last);
11917        nodes.addEventListener("error", last);
11918        i2 ? i2.parentNode.insertBefore(nodes, i2.nextSibling) : (root2 = 9 === root2.nodeType ? root2.head : root2, root2.insertBefore(nodes, root2.firstChild));
11919        resource.state.loading |= 4;
11920      }
11921    }
11922    var HostTransitionContext = {
11923      $$typeof: REACT_CONTEXT_TYPE,
11924      Provider: null,
11925      Consumer: null,
11926      _currentValue: sharedNotPendingObject,
11927      _currentValue2: sharedNotPendingObject,
11928      _threadCount: 0
11929    };
11930    function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator, formState) {
11931      this.tag = 1;
11932      this.containerInfo = containerInfo;
11933      this.pingCache = this.current = this.pendingChildren = null;
11934      this.timeoutHandle = -1;
11935      this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null;
11936      this.callbackPriority = 0;
11937      this.expirationTimes = createLaneMap(-1);
11938      this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
11939      this.entanglements = createLaneMap(0);
11940      this.hiddenUpdates = createLaneMap(null);
11941      this.identifierPrefix = identifierPrefix;
11942      this.onUncaughtError = onUncaughtError;
11943      this.onCaughtError = onCaughtError;
11944      this.onRecoverableError = onRecoverableError;
11945      this.pooledCache = null;
11946      this.pooledCacheLanes = 0;
11947      this.formState = formState;
11948      this.incompleteTransitions = /* @__PURE__ */ new Map();
11949    }
11950    function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, identifierPrefix, formState, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator) {
11951      containerInfo = new FiberRootNode(
11952        containerInfo,
11953        tag,
11954        hydrate,
11955        identifierPrefix,
11956        onUncaughtError,
11957        onCaughtError,
11958        onRecoverableError,
11959        onDefaultTransitionIndicator,
11960        formState
11961      );
11962      tag = 1;
11963      true === isStrictMode && (tag |= 24);
11964      isStrictMode = createFiberImplClass(3, null, null, tag);
11965      containerInfo.current = isStrictMode;
11966      isStrictMode.stateNode = containerInfo;
11967      tag = createCache();
11968      tag.refCount++;
11969      containerInfo.pooledCache = tag;
11970      tag.refCount++;
11971      isStrictMode.memoizedState = {
11972        element: initialChildren,
11973        isDehydrated: hydrate,
11974        cache: tag
11975      };
11976      initializeUpdateQueue(isStrictMode);
11977      return containerInfo;
11978    }
11979    function getContextForSubtree(parentComponent) {
11980      if (!parentComponent) return emptyContextObject;
11981      parentComponent = emptyContextObject;
11982      return parentComponent;
11983    }
11984    function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
11985      parentComponent = getContextForSubtree(parentComponent);
11986      null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
11987      container = createUpdate(lane);
11988      container.payload = { element };
11989      callback = void 0 === callback ? null : callback;
11990      null !== callback && (container.callback = callback);
11991      element = enqueueUpdate(rootFiber, container, lane);
11992      null !== element && (scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
11993    }
11994    function markRetryLaneImpl(fiber, retryLane) {
11995      fiber = fiber.memoizedState;
11996      if (null !== fiber && null !== fiber.dehydrated) {
11997        var a = fiber.retryLane;
11998        fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
11999      }
12000    }
12001    function markRetryLaneIfNotHydrated(fiber, retryLane) {
12002      markRetryLaneImpl(fiber, retryLane);
12003      (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
12004    }
12005    function attemptContinuousHydration(fiber) {
12006      if (13 === fiber.tag || 31 === fiber.tag) {
12007        var root2 = enqueueConcurrentRenderForLane(fiber, 67108864);
12008        null !== root2 && scheduleUpdateOnFiber(root2, fiber, 67108864);
12009        markRetryLaneIfNotHydrated(fiber, 67108864);
12010      }
12011    }
12012    function attemptHydrationAtCurrentPriority(fiber) {
12013      if (13 === fiber.tag || 31 === fiber.tag) {
12014        var lane = requestUpdateLane();
12015        lane = getBumpedLaneForHydrationByLane(lane);
12016        var root2 = enqueueConcurrentRenderForLane(fiber, lane);
12017        null !== root2 && scheduleUpdateOnFiber(root2, fiber, lane);
12018        markRetryLaneIfNotHydrated(fiber, lane);
12019      }
12020    }
12021    var _enabled = true;
12022    function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
12023      var prevTransition = ReactSharedInternals.T;
12024      ReactSharedInternals.T = null;
12025      var previousPriority = ReactDOMSharedInternals.p;
12026      try {
12027        ReactDOMSharedInternals.p = 2, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
12028      } finally {
12029        ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
12030      }
12031    }
12032    function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
12033      var prevTransition = ReactSharedInternals.T;
12034      ReactSharedInternals.T = null;
12035      var previousPriority = ReactDOMSharedInternals.p;
12036      try {
12037        ReactDOMSharedInternals.p = 8, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
12038      } finally {
12039        ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
12040      }
12041    }
12042    function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
12043      if (_enabled) {
12044        var blockedOn = findInstanceBlockingEvent(nativeEvent);
12045        if (null === blockedOn)
12046          dispatchEventForPluginEventSystem(
12047            domEventName,
12048            eventSystemFlags,
12049            nativeEvent,
12050            return_targetInst,
12051            targetContainer
12052          ), clearIfContinuousEvent(domEventName, nativeEvent);
12053        else if (queueIfContinuousEvent(
12054          blockedOn,
12055          domEventName,
12056          eventSystemFlags,
12057          targetContainer,
12058          nativeEvent
12059        ))
12060          nativeEvent.stopPropagation();
12061        else if (clearIfContinuousEvent(domEventName, nativeEvent), eventSystemFlags & 4 && -1 < discreteReplayableEvents.indexOf(domEventName)) {
12062          for (; null !== blockedOn; ) {
12063            var fiber = getInstanceFromNode(blockedOn);
12064            if (null !== fiber)
12065              switch (fiber.tag) {
12066                case 3:
12067                  fiber = fiber.stateNode;
12068                  if (fiber.current.memoizedState.isDehydrated) {
12069                    var lanes = getHighestPriorityLanes(fiber.pendingLanes);
12070                    if (0 !== lanes) {
12071                      var root2 = fiber;
12072                      root2.pendingLanes |= 2;
12073                      for (root2.entangledLanes |= 2; lanes; ) {
12074                        var lane = 1 << 31 - clz32(lanes);
12075                        root2.entanglements[1] |= lane;
12076                        lanes &= ~lane;
12077                      }
12078                      ensureRootIsScheduled(fiber);
12079                      0 === (executionContext & 6) && (workInProgressRootRenderTargetTime = now() + 500, flushSyncWorkAcrossRoots_impl(0));
12080                    }
12081                  }
12082                  break;
12083                case 31:
12084                case 13:
12085                  root2 = enqueueConcurrentRenderForLane(fiber, 2), null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2), flushSyncWork$1(), markRetryLaneIfNotHydrated(fiber, 2);
12086              }
12087            fiber = findInstanceBlockingEvent(nativeEvent);
12088            null === fiber && dispatchEventForPluginEventSystem(
12089              domEventName,
12090              eventSystemFlags,
12091              nativeEvent,
12092              return_targetInst,
12093              targetContainer
12094            );
12095            if (fiber === blockedOn) break;
12096            blockedOn = fiber;
12097          }
12098          null !== blockedOn && nativeEvent.stopPropagation();
12099        } else
12100          dispatchEventForPluginEventSystem(
12101            domEventName,
12102            eventSystemFlags,
12103            nativeEvent,
12104            null,
12105            targetContainer
12106          );
12107      }
12108    }
12109    function findInstanceBlockingEvent(nativeEvent) {
12110      nativeEvent = getEventTarget(nativeEvent);
12111      return findInstanceBlockingTarget(nativeEvent);
12112    }
12113    var return_targetInst = null;
12114    function findInstanceBlockingTarget(targetNode) {
12115      return_targetInst = null;
12116      targetNode = getClosestInstanceFromNode(targetNode);
12117      if (null !== targetNode) {
12118        var nearestMounted = getNearestMountedFiber(targetNode);
12119        if (null === nearestMounted) targetNode = null;
12120        else {
12121          var tag = nearestMounted.tag;
12122          if (13 === tag) {
12123            targetNode = getSuspenseInstanceFromFiber(nearestMounted);
12124            if (null !== targetNode) return targetNode;

vendor: 6,937 bytes, lines 12125-12329

12125            targetNode = null;
12126          } else if (31 === tag) {
12127            targetNode = getActivityInstanceFromFiber(nearestMounted);
12128            if (null !== targetNode) return targetNode;
12129            targetNode = null;
12130          } else if (3 === tag) {
12131            if (nearestMounted.stateNode.current.memoizedState.isDehydrated)
12132              return 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
12133            targetNode = null;
12134          } else nearestMounted !== targetNode && (targetNode = null);
12135        }
12136      }
12137      return_targetInst = targetNode;
12138      return null;
12139    }
12140    function getEventPriority(domEventName) {
12141      switch (domEventName) {
12142        case "beforetoggle":
12143        case "cancel":
12144        case "click":
12145        case "close":
12146        case "contextmenu":
12147        case "copy":
12148        case "cut":
12149        case "auxclick":
12150        case "dblclick":
12151        case "dragend":
12152        case "dragstart":
12153        case "drop":
12154        case "focusin":
12155        case "focusout":
12156        case "input":
12157        case "invalid":
12158        case "keydown":
12159        case "keypress":
12160        case "keyup":
12161        case "mousedown":
12162        case "mouseup":
12163        case "paste":
12164        case "pause":
12165        case "play":
12166        case "pointercancel":
12167        case "pointerdown":
12168        case "pointerup":
12169        case "ratechange":
12170        case "reset":
12171        case "resize":
12172        case "seeked":
12173        case "submit":
12174        case "toggle":
12175        case "touchcancel":
12176        case "touchend":
12177        case "touchstart":
12178        case "volumechange":
12179        case "change":
12180        case "selectionchange":
12181        case "textInput":
12182        case "compositionstart":
12183        case "compositionend":
12184        case "compositionupdate":
12185        case "beforeblur":
12186        case "afterblur":
12187        case "beforeinput":
12188        case "blur":
12189        case "fullscreenchange":
12190        case "focus":
12191        case "hashchange":
12192        case "popstate":
12193        case "select":
12194        case "selectstart":
12195          return 2;
12196        case "drag":
12197        case "dragenter":
12198        case "dragexit":
12199        case "dragleave":
12200        case "dragover":
12201        case "mousemove":
12202        case "mouseout":
12203        case "mouseover":
12204        case "pointermove":
12205        case "pointerout":
12206        case "pointerover":
12207        case "scroll":
12208        case "touchmove":
12209        case "wheel":
12210        case "mouseenter":
12211        case "mouseleave":
12212        case "pointerenter":
12213        case "pointerleave":
12214          return 8;
12215        case "message":
12216          switch (getCurrentPriorityLevel()) {
12217            case ImmediatePriority:
12218              return 2;
12219            case UserBlockingPriority:
12220              return 8;
12221            case NormalPriority$1:
12222            case LowPriority:
12223              return 32;
12224            case IdlePriority:
12225              return 268435456;
12226            default:
12227              return 32;
12228          }
12229        default:
12230          return 32;
12231      }
12232    }
12233    var hasScheduledReplayAttempt = false, queuedFocus = null, queuedDrag = null, queuedMouse = null, queuedPointers = /* @__PURE__ */ new Map(), queuedPointerCaptures = /* @__PURE__ */ new Map(), queuedExplicitHydrationTargets = [], discreteReplayableEvents = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(
12234      " "
12235    );
12236    function clearIfContinuousEvent(domEventName, nativeEvent) {
12237      switch (domEventName) {
12238        case "focusin":
12239        case "focusout":
12240          queuedFocus = null;
12241          break;
12242        case "dragenter":
12243        case "dragleave":
12244          queuedDrag = null;
12245          break;
12246        case "mouseover":
12247        case "mouseout":
12248          queuedMouse = null;
12249          break;
12250        case "pointerover":
12251        case "pointerout":
12252          queuedPointers.delete(nativeEvent.pointerId);
12253          break;
12254        case "gotpointercapture":
12255        case "lostpointercapture":
12256          queuedPointerCaptures.delete(nativeEvent.pointerId);
12257      }
12258    }
12259    function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
12260      if (null === existingQueuedEvent || existingQueuedEvent.nativeEvent !== nativeEvent)
12261        return existingQueuedEvent = {
12262          blockedOn,
12263          domEventName,
12264          eventSystemFlags,
12265          nativeEvent,
12266          targetContainers: [targetContainer]
12267        }, null !== blockedOn && (blockedOn = getInstanceFromNode(blockedOn), null !== blockedOn && attemptContinuousHydration(blockedOn)), existingQueuedEvent;
12268      existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
12269      blockedOn = existingQueuedEvent.targetContainers;
12270      null !== targetContainer && -1 === blockedOn.indexOf(targetContainer) && blockedOn.push(targetContainer);
12271      return existingQueuedEvent;
12272    }
12273    function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
12274      switch (domEventName) {
12275        case "focusin":
12276          return queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
12277            queuedFocus,
12278            blockedOn,
12279            domEventName,
12280            eventSystemFlags,
12281            targetContainer,
12282            nativeEvent
12283          ), true;
12284        case "dragenter":
12285          return queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
12286            queuedDrag,
12287            blockedOn,
12288            domEventName,
12289            eventSystemFlags,
12290            targetContainer,
12291            nativeEvent
12292          ), true;
12293        case "mouseover":
12294          return queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
12295            queuedMouse,
12296            blockedOn,
12297            domEventName,
12298            eventSystemFlags,
12299            targetContainer,
12300            nativeEvent
12301          ), true;
12302        case "pointerover":
12303          var pointerId = nativeEvent.pointerId;
12304          queuedPointers.set(
12305            pointerId,
12306            accumulateOrCreateContinuousQueuedReplayableEvent(
12307              queuedPointers.get(pointerId) || null,
12308              blockedOn,
12309              domEventName,
12310              eventSystemFlags,
12311              targetContainer,
12312              nativeEvent
12313            )
12314          );
12315          return true;
12316        case "gotpointercapture":
12317          return pointerId = nativeEvent.pointerId, queuedPointerCaptures.set(
12318            pointerId,
12319            accumulateOrCreateContinuousQueuedReplayableEvent(
12320              queuedPointerCaptures.get(pointerId) || null,
12321              blockedOn,
12322              domEventName,
12323              eventSystemFlags,
12324              targetContainer,
12325              nativeEvent
12326            )
12327          ), true;
12328      }
12329      return false;

vendor: 11,313 bytes, lines 12330-12562

12330    }
12331    function attemptExplicitHydrationTarget(queuedTarget) {
12332      var targetInst = getClosestInstanceFromNode(queuedTarget.target);
12333      if (null !== targetInst) {
12334        var nearestMounted = getNearestMountedFiber(targetInst);
12335        if (null !== nearestMounted) {
12336          if (targetInst = nearestMounted.tag, 13 === targetInst) {
12337            if (targetInst = getSuspenseInstanceFromFiber(nearestMounted), null !== targetInst) {
12338              queuedTarget.blockedOn = targetInst;
12339              runWithPriority(queuedTarget.priority, function() {
12340                attemptHydrationAtCurrentPriority(nearestMounted);
12341              });
12342              return;
12343            }
12344          } else if (31 === targetInst) {
12345            if (targetInst = getActivityInstanceFromFiber(nearestMounted), null !== targetInst) {
12346              queuedTarget.blockedOn = targetInst;
12347              runWithPriority(queuedTarget.priority, function() {
12348                attemptHydrationAtCurrentPriority(nearestMounted);
12349              });
12350              return;
12351            }
12352          } else if (3 === targetInst && nearestMounted.stateNode.current.memoizedState.isDehydrated) {
12353            queuedTarget.blockedOn = 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
12354            return;
12355          }
12356        }
12357      }
12358      queuedTarget.blockedOn = null;
12359    }
12360    function attemptReplayContinuousQueuedEvent(queuedEvent) {
12361      if (null !== queuedEvent.blockedOn) return false;
12362      for (var targetContainers = queuedEvent.targetContainers; 0 < targetContainers.length; ) {
12363        var nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
12364        if (null === nextBlockedOn) {
12365          nextBlockedOn = queuedEvent.nativeEvent;
12366          var nativeEventClone = new nextBlockedOn.constructor(
12367            nextBlockedOn.type,
12368            nextBlockedOn
12369          );
12370          currentReplayingEvent = nativeEventClone;
12371          nextBlockedOn.target.dispatchEvent(nativeEventClone);
12372          currentReplayingEvent = null;
12373        } else
12374          return targetContainers = getInstanceFromNode(nextBlockedOn), null !== targetContainers && attemptContinuousHydration(targetContainers), queuedEvent.blockedOn = nextBlockedOn, false;
12375        targetContainers.shift();
12376      }
12377      return true;
12378    }
12379    function attemptReplayContinuousQueuedEventInMap(queuedEvent, key2, map) {
12380      attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key2);
12381    }
12382    function replayUnblockedEvents() {
12383      hasScheduledReplayAttempt = false;
12384      null !== queuedFocus && attemptReplayContinuousQueuedEvent(queuedFocus) && (queuedFocus = null);
12385      null !== queuedDrag && attemptReplayContinuousQueuedEvent(queuedDrag) && (queuedDrag = null);
12386      null !== queuedMouse && attemptReplayContinuousQueuedEvent(queuedMouse) && (queuedMouse = null);
12387      queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
12388      queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
12389    }
12390    function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
12391      queuedEvent.blockedOn === unblocked && (queuedEvent.blockedOn = null, hasScheduledReplayAttempt || (hasScheduledReplayAttempt = true, Scheduler.unstable_scheduleCallback(
12392        Scheduler.unstable_NormalPriority,
12393        replayUnblockedEvents
12394      )));
12395    }
12396    var lastScheduledReplayQueue = null;
12397    function scheduleReplayQueueIfNeeded(formReplayingQueue) {
12398      lastScheduledReplayQueue !== formReplayingQueue && (lastScheduledReplayQueue = formReplayingQueue, Scheduler.unstable_scheduleCallback(
12399        Scheduler.unstable_NormalPriority,
12400        function() {
12401          lastScheduledReplayQueue === formReplayingQueue && (lastScheduledReplayQueue = null);
12402          for (var i2 = 0; i2 < formReplayingQueue.length; i2 += 3) {
12403            var form = formReplayingQueue[i2], submitterOrAction = formReplayingQueue[i2 + 1], formData = formReplayingQueue[i2 + 2];
12404            if ("function" !== typeof submitterOrAction)
12405              if (null === findInstanceBlockingTarget(submitterOrAction || form))
12406                continue;
12407              else break;
12408            var formInst = getInstanceFromNode(form);
12409            null !== formInst && (formReplayingQueue.splice(i2, 3), i2 -= 3, startHostTransition(
12410              formInst,
12411              {
12412                pending: true,
12413                data: formData,
12414                method: form.method,
12415                action: submitterOrAction
12416              },
12417              submitterOrAction,
12418              formData
12419            ));
12420          }
12421        }
12422      ));
12423    }
12424    function retryIfBlockedOn(unblocked) {
12425      function unblock(queuedEvent) {
12426        return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
12427      }
12428      null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
12429      null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
12430      null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
12431      queuedPointers.forEach(unblock);
12432      queuedPointerCaptures.forEach(unblock);
12433      for (var i2 = 0; i2 < queuedExplicitHydrationTargets.length; i2++) {
12434        var queuedTarget = queuedExplicitHydrationTargets[i2];
12435        queuedTarget.blockedOn === unblocked && (queuedTarget.blockedOn = null);
12436      }
12437      for (; 0 < queuedExplicitHydrationTargets.length && (i2 = queuedExplicitHydrationTargets[0], null === i2.blockedOn); )
12438        attemptExplicitHydrationTarget(i2), null === i2.blockedOn && queuedExplicitHydrationTargets.shift();
12439      i2 = (unblocked.ownerDocument || unblocked).$$reactFormReplay;
12440      if (null != i2)
12441        for (queuedTarget = 0; queuedTarget < i2.length; queuedTarget += 3) {
12442          var form = i2[queuedTarget], submitterOrAction = i2[queuedTarget + 1], formProps = form[internalPropsKey] || null;
12443          if ("function" === typeof submitterOrAction)
12444            formProps || scheduleReplayQueueIfNeeded(i2);
12445          else if (formProps) {
12446            var action = null;
12447            if (submitterOrAction && submitterOrAction.hasAttribute("formAction"))
12448              if (form = submitterOrAction, formProps = submitterOrAction[internalPropsKey] || null)
12449                action = formProps.formAction;
12450              else {
12451                if (null !== findInstanceBlockingTarget(form)) continue;
12452              }
12453            else action = formProps.action;
12454            "function" === typeof action ? i2[queuedTarget + 1] = action : (i2.splice(queuedTarget, 3), queuedTarget -= 3);
12455            scheduleReplayQueueIfNeeded(i2);
12456          }
12457        }
12458    }
12459    function defaultOnDefaultTransitionIndicator() {
12460      function handleNavigate(event) {
12461        event.canIntercept && "react-transition" === event.info && event.intercept({
12462          handler: function() {
12463            return new Promise(function(resolve) {
12464              return pendingResolve = resolve;
12465            });
12466          },
12467          focusReset: "manual",
12468          scroll: "manual"
12469        });
12470      }
12471      function handleNavigateComplete() {
12472        null !== pendingResolve && (pendingResolve(), pendingResolve = null);
12473        isCancelled || setTimeout(startFakeNavigation, 20);
12474      }
12475      function startFakeNavigation() {
12476        if (!isCancelled && !navigation.transition) {
12477          var currentEntry = navigation.currentEntry;
12478          currentEntry && null != currentEntry.url && navigation.navigate(currentEntry.url, {
12479            state: currentEntry.getState(),
12480            info: "react-transition",
12481            history: "replace"
12482          });
12483        }
12484      }
12485      if ("object" === typeof navigation) {
12486        var isCancelled = false, pendingResolve = null;
12487        navigation.addEventListener("navigate", handleNavigate);
12488        navigation.addEventListener("navigatesuccess", handleNavigateComplete);
12489        navigation.addEventListener("navigateerror", handleNavigateComplete);
12490        setTimeout(startFakeNavigation, 100);
12491        return function() {
12492          isCancelled = true;
12493          navigation.removeEventListener("navigate", handleNavigate);
12494          navigation.removeEventListener("navigatesuccess", handleNavigateComplete);
12495          navigation.removeEventListener("navigateerror", handleNavigateComplete);
12496          null !== pendingResolve && (pendingResolve(), pendingResolve = null);
12497        };
12498      }
12499    }
12500    function ReactDOMRoot(internalRoot) {
12501      this._internalRoot = internalRoot;
12502    }
12503    ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function(children) {
12504      var root2 = this._internalRoot;
12505      if (null === root2) throw Error(formatProdErrorMessage(409));
12506      var current = root2.current, lane = requestUpdateLane();
12507      updateContainerImpl(current, lane, children, root2, null, null);
12508    };
12509    ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function() {
12510      var root2 = this._internalRoot;
12511      if (null !== root2) {
12512        this._internalRoot = null;
12513        var container = root2.containerInfo;
12514        updateContainerImpl(root2.current, 2, null, root2, null, null);
12515        flushSyncWork$1();
12516        container[internalContainerInstanceKey] = null;
12517      }
12518    };
12519    function ReactDOMHydrationRoot(internalRoot) {
12520      this._internalRoot = internalRoot;
12521    }
12522    ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function(target) {
12523      if (target) {
12524        var updatePriority = resolveUpdatePriority();
12525        target = { blockedOn: null, target, priority: updatePriority };
12526        for (var i2 = 0; i2 < queuedExplicitHydrationTargets.length && 0 !== updatePriority && updatePriority < queuedExplicitHydrationTargets[i2].priority; i2++) ;
12527        queuedExplicitHydrationTargets.splice(i2, 0, target);
12528        0 === i2 && attemptExplicitHydrationTarget(target);
12529      }
12530    };
12531    var isomorphicReactPackageVersion$jscomp$inline_1840 = React2.version;
12532    if ("19.2.5" !== isomorphicReactPackageVersion$jscomp$inline_1840)
12533      throw Error(
12534        formatProdErrorMessage(
12535          527,
12536          isomorphicReactPackageVersion$jscomp$inline_1840,
12537          "19.2.5"
12538        )
12539      );
12540    ReactDOMSharedInternals.findDOMNode = function(componentOrElement) {
12541      var fiber = componentOrElement._reactInternals;
12542      if (void 0 === fiber) {
12543        if ("function" === typeof componentOrElement.render)
12544          throw Error(formatProdErrorMessage(188));
12545        componentOrElement = Object.keys(componentOrElement).join(",");
12546        throw Error(formatProdErrorMessage(268, componentOrElement));
12547      }
12548      componentOrElement = findCurrentFiberUsingSlowPath(fiber);
12549      componentOrElement = null !== componentOrElement ? findCurrentHostFiberImpl(componentOrElement) : null;
12550      componentOrElement = null === componentOrElement ? null : componentOrElement.stateNode;
12551      return componentOrElement;
12552    };
12553    var internals$jscomp$inline_2347 = {
12554      bundleType: 0,
12555      version: "19.2.5",
12556      rendererPackageName: "react-dom",
12557      currentDispatcherRef: ReactSharedInternals,
12558      reconcilerVersion: "19.2.5"
12559    };
12560    if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
12561      var hook$jscomp$inline_2348 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
12562      if (!hook$jscomp$inline_2348.isDisabled && hook$jscomp$inline_2348.supp

12562ortsFiber)
12563        try {
12564          rendererID = hook$jscomp$inline_2348.inject(
12565            internals$jscomp$inline_2347
12566          ), injectedHook = hook$jscomp$inline_2348;
12567        } catch (err) {
12568        }
12569    }
12570    reactDomClient_production.createRoot = function(container, options2) {
12571      if (!isValidContainer(container)) throw Error(formatProdErrorMessage(299));
12572      var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError;
12573      null !== options2 && void 0 !== options2 && (true === options2.unstable_strictMode && (isStrictMode = true), void 0 !== options2.identifierPrefix && (identifierPrefix = options2.identifierPrefix), void 0 !== options2.onUncaughtError && (onUncaughtError = options2.onUncaughtError), void 0 !== options2.onCaughtError && (onCaughtError = options2.onCaughtError), void 0 !== options2.onRecoverableError && (onRecoverableError = options2.onRecoverableError));
12574      options2 = createFiberRoot(
12575        container,
12576        1,
12577        false,
12578        null,
12579        null,
12580        isStrictMode,
12581        identifierPrefix,
12582        null,
12583        onUncaughtError,
12584        onCaughtError,
12585        onRecoverableError,
12586        defaultOnDefaultTransitionIndicator
12587      );
12588      container[internalContainerInstanceKey] = options2.current;
12589      listenToAllSupportedEvents(container);
12590      return new ReactDOMRoot(options2);
12591    };
12592    reactDomClient_production.hydrateRoot = function(container, initialChildren, options2) {
12593      if (!isValidContainer(container)) throw Error(formatProdErrorMessage(299));
12594      var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError, formState = null;
12595      null !== options2 && void 0 !== options2 && (true === options2.unstable_strictMode && (isStrictMode = true), void 0 !== options2.identifierPrefix && (identifierPrefix = options2.identifierPrefix), void 0 !== options2.onUncaughtError && (onUncaughtError = options2.onUncaughtError), void 0 !== options2.onCaughtError && (onCaughtError = options2.onCaughtError), void 0 !== options2.onRecoverableError && (onRecoverableError = options2.onRecoverableError), void 0 !== options2.formState && (formState = options2.formState));
12596      initialChildren = createFiberRoot(
12597        container,
12598        1,
12599        true,
12600        initialChildren,
12601        null != options2 ? options2 : null,
12602        isStrictMode,
12603        identifierPrefix,
12604        formState,
12605        onUncaughtError,
12606        onCaughtError,
12607        onRecoverableError,
12608        defaultOnDefaultTransitionIndicator
12609      );
12610      initialChildren.context = getContextForSubtree(null);
12611      options2 = initialChildren.current;
12612      isStrictMode = requestUpdateLane();
12613      isStrictMode = getBumpedLaneForHydrationByLane(isStrictMode);
12614      identifierPrefix = createUpdate(isStrictMode);
12615      identifierPrefix.callback = null;
12616      enqueueUpdate(options2, identifierPrefix, isStrictMode);
12617      options2 = isStrictMode;
12618      initialChildren.current.lanes = options2;
12619      markRootUpdated$1(initialChildren, options2);
12620      ensureRootIsScheduled(initialChildren);
12621      container[internalContainerInstanceKey] = initialChildren.current;
12622      listenToAllSupportedEvents(container);
12623      return new ReactDOMHydrationRoot(initialChildren);
12624    };
12625    reactDomClient_production.version = "19.2.5";
12626    return reactDomClient_production;
12627  }
12628  var hasRequiredClient;
12629  function requireClient() {
12630    if (hasRequiredClient) return client.exports;
12631    hasRequiredClient = 1;
12632    function checkDCE() {
12633      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function") {
12634        return;
12635      }
12636      try {
12637        __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
12638      } catch (err) {
12639        console.error(err);
12640      }
12641    }
12642    {
12643      checkDCE();
12644      client.exports = requireReactDomClient_production();
12645    }
12646    return client.exports;
12647  }
12648  var clientExports = requireClient();
12649  const ReactDOM = /* @__PURE__ */ getDefaultExportFromCjs$1(clientExports);
12650  const global$1 = globalThis || void 0 || self;
12651  function bind(fn, thisArg) {
12652    return function wrap() {
12653      return fn.apply(thisArg, arguments);
12654    };
12655  }
12656  const { toString } = Object.prototype;
12657  const { getPrototypeOf } = Object;
12658  const { iterator, toStringTag } = Symbol;
12659  const kindOf = /* @__PURE__ */ ((cache2) => (thing) => {
12660    const str = toString.call(thing);
12661    return cache2[str] || (cache2[str] = str.slice(8, -1).toLowerCase());
12662  })(/* @__PURE__ */ Object.create(null));
12663  const kindOfTest = (type2) => {
12664    type2 = type2.toLowerCase();
12665    return (thing) => kindOf(thing) === type2;
12666  };
12667  const typeOfTest = (type2) => (thing) => typeof thing === type2;

vendor: 5,192 bytes, lines 12668-12809

12668  const { isArray } = Array;
12669  const isUndefined = typeOfTest("undefined");
12670  function isBuffer$1(val) {
12671    return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
12672  }
12673  const isArrayBuffer = kindOfTest("ArrayBuffer");
12674  function isArrayBufferView(val) {
12675    let result;
12676    if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
12677      result = ArrayBuffer.isView(val);
12678    } else {
12679      result = val && val.buffer && isArrayBuffer(val.buffer);
12680    }
12681    return result;
12682  }
12683  const isString = typeOfTest("string");
12684  const isFunction$1 = typeOfTest("function");
12685  const isNumber = typeOfTest("number");
12686  const isObject = (thing) => thing !== null && typeof thing === "object";
12687  const isBoolean = (thing) => thing === true || thing === false;
12688  const isPlainObject = (val) => {
12689    if (kindOf(val) !== "object") {
12690      return false;
12691    }
12692    const prototype2 = getPrototypeOf(val);
12693    return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
12694  };
12695  const isEmptyObject = (val) => {
12696    if (!isObject(val) || isBuffer$1(val)) {
12697      return false;
12698    }
12699    try {
12700      return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
12701    } catch (e) {
12702      return false;
12703    }
12704  };
12705  const isDate = kindOfTest("Date");
12706  const isFile = kindOfTest("File");
12707  const isReactNativeBlob = (value) => {
12708    return !!(value && typeof value.uri !== "undefined");
12709  };
12710  const isReactNative = (formData) => formData && typeof formData.getParts !== "undefined";
12711  const isBlob = kindOfTest("Blob");
12712  const isFileList = kindOfTest("FileList");
12713  const isStream = (val) => isObject(val) && isFunction$1(val.pipe);
12714  function getGlobal() {
12715    if (typeof globalThis !== "undefined") return globalThis;
12716    if (typeof self !== "undefined") return self;
12717    if (typeof window !== "undefined") return window;
12718    if (typeof global$1 !== "undefined") return global$1;
12719    return {};
12720  }
12721  const G = getGlobal();
12722  const FormDataCtor = typeof G.FormData !== "undefined" ? G.FormData : void 0;
12723  const isFormData = (thing) => {
12724    if (!thing) return false;
12725    if (FormDataCtor && thing instanceof FormDataCtor) return true;
12726    const proto = getPrototypeOf(thing);
12727    if (!proto || proto === Object.prototype) return false;
12728    if (!isFunction$1(thing.append)) return false;
12729    const kind = kindOf(thing);
12730    return kind === "formdata" || // detect form-data instance
12731    kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]";
12732  };
12733  const isURLSearchParams = kindOfTest("URLSearchParams");
12734  const [isReadableStream, isRequest, isResponse, isHeaders] = [
12735    "ReadableStream",
12736    "Request",
12737    "Response",
12738    "Headers"
12739  ].map(kindOfTest);
12740  const trim = (str) => {
12741    return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
12742  };
12743  function forEach$1(obj, fn, { allOwnKeys = false } = {}) {
12744    if (obj === null || typeof obj === "undefined") {
12745      return;
12746    }
12747    let i2;
12748    let l;
12749    if (typeof obj !== "object") {
12750      obj = [obj];
12751    }
12752    if (isArray(obj)) {
12753      for (i2 = 0, l = obj.length; i2 < l; i2++) {
12754        fn.call(null, obj[i2], i2, obj);
12755      }
12756    } else {
12757      if (isBuffer$1(obj)) {
12758        return;
12759      }
12760      const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
12761      const len2 = keys.length;
12762      let key2;
12763      for (i2 = 0; i2 < len2; i2++) {
12764        key2 = keys[i2];
12765        fn.call(null, obj[key2], key2, obj);
12766      }
12767    }
12768  }
12769  function findKey(obj, key2) {
12770    if (isBuffer$1(obj)) {
12771      return null;
12772    }
12773    key2 = key2.toLowerCase();
12774    const keys = Object.keys(obj);
12775    let i2 = keys.length;
12776    let _key;
12777    while (i2-- > 0) {
12778      _key = keys[i2];
12779      if (key2 === _key.toLowerCase()) {
12780        return _key;
12781      }
12782    }
12783    return null;
12784  }
12785  const _global = (() => {
12786    if (typeof globalThis !== "undefined") return globalThis;
12787    return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global$1;
12788  })();
12789  const isContextDefined = (context) => !isUndefined(context) && context !== _global;
12790  function merge(...objs) {
12791    const { caseless, skipUndefined } = isContextDefined(this) && this || {};
12792    const result = {};
12793    const assignValue = (val, key2) => {
12794      if (key2 === "__proto__" || key2 === "constructor" || key2 === "prototype") {
12795        return;
12796      }
12797      const targetKey = caseless && findKey(result, key2) || key2;
12798      const existing = hasOwnProperty(result, targetKey) ? result[targetKey] : void 0;
12799      if (isPlainObject(existing) && isPlainObject(val)) {
12800        result[targetKey] = merge(existing, val);
12801      } else if (isPlainObject(val)) {
12802        result[targetKey] = merge({}, val);
12803      } else if (isArray(val)) {
12804        result[targetKey] = val.slice();
12805      } else if (!skipUndefined || !isUndefined(val)) {
12806        result[targetKey] = val;
12807      }
12808    };
12809    for (let i2 = 0, l = objs.length; i2 < l; i2++) {

vendor: 1,178 bytes, lines 12810-12849

12810      objs[i2] && forEach$1(objs[i2], assignValue);
12811    }
12812    return result;
12813  }
12814  const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
12815    forEach$1(
12816      b,
12817      (val, key2) => {
12818        if (thisArg && isFunction$1(val)) {
12819          Object.defineProperty(a, key2, {
12820            // Null-proto descriptor so a polluted Object.prototype.get cannot
12821            // hijack defineProperty's accessor-vs-data resolution.
12822            __proto__: null,
12823            value: bind(val, thisArg),
12824            writable: true,
12825            enumerable: true,
12826            configurable: true
12827          });
12828        } else {
12829          Object.defineProperty(a, key2, {
12830            __proto__: null,
12831            value: val,
12832            writable: true,
12833            enumerable: true,
12834            configurable: true
12835          });
12836        }
12837      },
12838      { allOwnKeys }
12839    );
12840    return a;
12841  };
12842  const stripBOM = (content) => {
12843    if (content.charCodeAt(0) === 65279) {
12844      content = content.slice(1);
12845    }
12846    return content;
12847  };
12848  const inherits$1 = (constructor, superConstructor, props, descriptors) => {
12849    constructor.prototype = Object.create(superConstructor.prototype, descriptors);

vendor: 4,755 bytes, lines 12850-12994

12850    Object.defineProperty(constructor.prototype, "constructor", {
12851      __proto__: null,
12852      value: constructor,
12853      writable: true,
12854      enumerable: false,
12855      configurable: true
12856    });
12857    Object.defineProperty(constructor, "super", {
12858      __proto__: null,
12859      value: superConstructor.prototype
12860    });
12861    props && Object.assign(constructor.prototype, props);
12862  };
12863  const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
12864    let props;
12865    let i2;
12866    let prop;
12867    const merged = {};
12868    destObj = destObj || {};
12869    if (sourceObj == null) return destObj;
12870    do {
12871      props = Object.getOwnPropertyNames(sourceObj);
12872      i2 = props.length;
12873      while (i2-- > 0) {
12874        prop = props[i2];
12875        if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
12876          destObj[prop] = sourceObj[prop];
12877          merged[prop] = true;
12878        }
12879      }
12880      sourceObj = filter !== false && getPrototypeOf(sourceObj);
12881    } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
12882    return destObj;
12883  };
12884  const endsWith = (str, searchString, position) => {
12885    str = String(str);
12886    if (position === void 0 || position > str.length) {
12887      position = str.length;
12888    }
12889    position -= searchString.length;
12890    const lastIndex = str.indexOf(searchString, position);
12891    return lastIndex !== -1 && lastIndex === position;
12892  };
12893  const toArray = (thing) => {
12894    if (!thing) return null;
12895    if (isArray(thing)) return thing;
12896    let i2 = thing.length;
12897    if (!isNumber(i2)) return null;
12898    const arr = new Array(i2);
12899    while (i2-- > 0) {
12900      arr[i2] = thing[i2];
12901    }
12902    return arr;
12903  };
12904  const isTypedArray$1 = /* @__PURE__ */ ((TypedArray) => {
12905    return (thing) => {
12906      return TypedArray && thing instanceof TypedArray;
12907    };
12908  })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
12909  const forEachEntry = (obj, fn) => {
12910    const generator = obj && obj[iterator];
12911    const _iterator = generator.call(obj);
12912    let result;
12913    while ((result = _iterator.next()) && !result.done) {
12914      const pair = result.value;
12915      fn.call(obj, pair[0], pair[1]);
12916    }
12917  };
12918  const matchAll = (regExp, str) => {
12919    let matches;
12920    const arr = [];
12921    while ((matches = regExp.exec(str)) !== null) {
12922      arr.push(matches);
12923    }
12924    return arr;
12925  };
12926  const isHTMLForm = kindOfTest("HTMLFormElement");
12927  const toCamelCase = (str) => {
12928    return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
12929      return p1.toUpperCase() + p2;
12930    });
12931  };
12932  const hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
12933  const isRegExp = kindOfTest("RegExp");
12934  const reduceDescriptors = (obj, reducer) => {
12935    const descriptors = Object.getOwnPropertyDescriptors(obj);
12936    const reducedDescriptors = {};
12937    forEach$1(descriptors, (descriptor, name) => {
12938      let ret;
12939      if ((ret = reducer(descriptor, name, obj)) !== false) {
12940        reducedDescriptors[name] = ret || descriptor;
12941      }
12942    });
12943    Object.defineProperties(obj, reducedDescriptors);
12944  };
12945  const freezeMethods = (obj) => {
12946    reduceDescriptors(obj, (descriptor, name) => {
12947      if (isFunction$1(obj) && ["arguments", "caller", "callee"].includes(name)) {
12948        return false;
12949      }
12950      const value = obj[name];
12951      if (!isFunction$1(value)) return;
12952      descriptor.enumerable = false;
12953      if ("writable" in descriptor) {
12954        descriptor.writable = false;
12955        return;
12956      }
12957      if (!descriptor.set) {
12958        descriptor.set = () => {
12959          throw Error("Can not rewrite read-only method '" + name + "'");
12960        };
12961      }
12962    });
12963  };
12964  const toObjectSet = (arrayOrString, delimiter) => {
12965    const obj = {};
12966    const define = (arr) => {
12967      arr.forEach((value) => {
12968        obj[value] = true;
12969      });
12970    };
12971    isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
12972    return obj;
12973  };
12974  const noop = () => {
12975  };
12976  const toFiniteNumber = (value, defaultValue) => {
12977    return value != null && Number.isFinite(value = +value) ? value : defaultValue;
12978  };
12979  function isSpecCompliantForm(thing) {
12980    return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
12981  }
12982  const toJSONObject = (obj) => {
12983    const stack = new Array(10);
12984    const visit = (source, i2) => {
12985      if (isObject(source)) {
12986        if (stack.indexOf(source) >= 0) {
12987          return;
12988        }
12989        if (isBuffer$1(source)) {
12990          return source;
12991        }
12992        if (!("toJSON" in source)) {
12993          stack[i2] = source;
12994          const target = isArray(source) ? [] : {};

12995          forEach$1(source, (value, key2) => {
12996            const reducedValue = visit(value, i2 + 1);
12997            !isUndefined(reducedValue) && (target[key2] = reducedValue);
12998          });
12999          stack[i2] = void 0;
13000          return target;
13001        }
13002      }
13003      return source;
13004    };
13005    return visit(obj, 0);
13006  };
13007  const isAsyncFn = kindOfTest("AsyncFunction");
13008  const isThenable = (thing) => thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
13009  const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
13010    if (setImmediateSupported) {
13011      return setImmediate;
13012    }
13013    return postMessageSupported ? ((token, callbacks) => {
13014      _global.addEventListener(
13015        "message",
13016        ({ source, data }) => {
13017          if (source === _global && data === token) {
13018            callbacks.length && callbacks.shift()();
13019          }
13020        },
13021        false
13022      );
13023      return (cb) => {
13024        callbacks.push(cb);
13025        _global.postMessage(token, "*");
13026      };
13027    })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
13028  })(typeof setImmediate === "function", isFunction$1(_global.postMessage));
13029  const asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process$1 !== "undefined" && process$1.nextTick || _setImmediate;
13030  const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
13031  const utils$5 = {
13032    isArray,
13033    isArrayBuffer,
13034    isBuffer: isBuffer$1,
13035    isFormData,
13036    isArrayBufferView,
13037    isString,
13038    isNumber,
13039    isBoolean,
13040    isObject,
13041    isPlainObject,
13042    isEmptyObject,
13043    isReadableStream,
13044    isRequest,
13045    isResponse,
13046    isHeaders,
13047    isUndefined,
13048    isDate,
13049    isFile,
13050    isReactNativeBlob,
13051    isReactNative,
13052    isBlob,
13053    isRegExp,
13054    isFunction: isFunction$1,
13055    isStream,
13056    isURLSearchParams,
13057    isTypedArray: isTypedArray$1,
13058    isFileList,
13059    forEach: forEach$1,
13060    merge,
13061    extend,
13062    trim,
13063    stripBOM,
13064    inherits: inherits$1,
13065    toFlatObject,
13066    kindOf,
13067    kindOfTest,
13068    endsWith,
13069    toArray,
13070    forEachEntry,
13071    matchAll,
13072    isHTMLForm,
13073    hasOwnProperty,
13074    hasOwnProp: hasOwnProperty,
13075    // an alias to avoid ESLint no-prototype-builtins detection
13076    reduceDescriptors,
13077    freezeMethods,
13078    toObjectSet,
13079    toCamelCase,
13080    noop,
13081    toFiniteNumber,
13082    findKey,
13083    global: _global,
13084    isContextDefined,
13085    isSpecCompliantForm,
13086    toJSONObject,
13087    isAsyncFn,
13088    isThenable,
13089    setImmediate: _setImmediate,
13090    asap,
13091    isIterable
13092  };
13093  var buffer$1 = {};
13094  var base64Js = {};
13095  base64Js.byteLength = byteLength;
13096  base64Js.toByteArray = toByteArray;
13097  base64Js.fromByteArray = fromByteArray;
13098  var lookup = [];
13099  var revLookup = [];
13100  var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
13101  var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
13102  for (var i = 0, len = code.length; i < len; ++i) {
13103    lookup[i] = code[i];
13104    revLookup[code.charCodeAt(i)] = i;
13105  }
13106  revLookup["-".charCodeAt(0)] = 62;
13107  revLookup["_".charCodeAt(0)] = 63;
13108  function getLens(b64) {
13109    var len2 = b64.length;
13110    if (len2 % 4 > 0) {
13111      throw new Error("Invalid string. Length must be a multiple of 4");
13112    }
13113    var validLen = b64.indexOf("=");
13114    if (validLen === -1) validLen = len2;
13115    var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
13116    return [validLen, placeHoldersLen];
13117  }
13118  function byteLength(b64) {
13119    var lens = getLens(b64);
13120    var validLen = lens[0];
13121    var placeHoldersLen = lens[1];
13122    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
13123  }
13124  function _byteLength(b64, validLen, placeHoldersLen) {
13125    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
13126  }
13127  function toByteArray(b64) {
13128    var tmp;
13129    var lens = getLens(b64);
13130    var validLen = lens[0];
13131    var placeHoldersLen = lens[1];
13132    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
13133    var curByte = 0;
13134    var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
13135    var i2;
13136    for (i2 = 0; i2 < len2; i2 += 4) {
13137      tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
13138      arr[curByte++] = tmp >> 16 & 255;
13139      arr[curByte++] = tmp >> 8 & 255;
13140      arr[curByte++] = tmp & 255;
13141    }
13142    if (placeHoldersLen === 2) {
13143      tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
13144      arr[curByte++] = tmp & 255;
13145    }
13146    if (placeHoldersLen === 1) {
13147      tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
13148      arr[curByte++] = tmp >> 8 & 255;
13149      arr[curByte++] = tmp & 255;
13150    }
13151    return arr;
13152  }
13153  function tripletToBase64(num) {
13154    return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
13155  }
13156  function encodeChunk(uint8, start, end) {
13157    var tmp;
13158    var output = [];
13159    for (var i2 = start; i2 < end; i2 += 3) {
13160      tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
13161      output.push(tripletToBase64(tmp));
13162    }
13163    return output.join("");
13164  }
13165  function fromByteArray(uint8) {
13166    var tmp;
13167    var len2 = uint8.length;
13168    var extraBytes = len2 % 3;
13169    var parts = [];
13170    var maxChunkLength = 16383;
13171    for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
13172      parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
13173    }
13174    if (extraBytes === 1) {
13175      tmp = uint8[len2 - 1];
13176      parts.push(
13177        lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
13178      );
13179    } else if (extraBytes === 2) {
13180      tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
13181      parts.push(
13182        lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
13183      );
13184    }
13185    return parts.join("");
13186  }
13187  var ieee754 = {};
13188  /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
13189  ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) {
13190    var e, m;
13191    var eLen = nBytes * 8 - mLen - 1;
13192    var eMax = (1 << eLen) - 1;
13193    var eBias = eMax >> 1;

vendor: 40,788 bytes, lines 13194-14329

13194    var nBits = -7;
13195    var i2 = isLE ? nBytes - 1 : 0;
13196    var d = isLE ? -1 : 1;
13197    var s = buffer2[offset + i2];
13198    i2 += d;
13199    e = s & (1 << -nBits) - 1;
13200    s >>= -nBits;
13201    nBits += eLen;
13202    for (; nBits > 0; e = e * 256 + buffer2[offset + i2], i2 += d, nBits -= 8) {
13203    }
13204    m = e & (1 << -nBits) - 1;
13205    e >>= -nBits;
13206    nBits += mLen;
13207    for (; nBits > 0; m = m * 256 + buffer2[offset + i2], i2 += d, nBits -= 8) {
13208    }
13209    if (e === 0) {
13210      e = 1 - eBias;
13211    } else if (e === eMax) {
13212      return m ? NaN : (s ? -1 : 1) * Infinity;
13213    } else {
13214      m = m + Math.pow(2, mLen);
13215      e = e - eBias;
13216    }
13217    return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
13218  };
13219  ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
13220    var e, m, c;
13221    var eLen = nBytes * 8 - mLen - 1;
13222    var eMax = (1 << eLen) - 1;
13223    var eBias = eMax >> 1;
13224    var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
13225    var i2 = isLE ? 0 : nBytes - 1;
13226    var d = isLE ? 1 : -1;
13227    var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
13228    value = Math.abs(value);
13229    if (isNaN(value) || value === Infinity) {
13230      m = isNaN(value) ? 1 : 0;
13231      e = eMax;
13232    } else {
13233      e = Math.floor(Math.log(value) / Math.LN2);
13234      if (value * (c = Math.pow(2, -e)) < 1) {
13235        e--;
13236        c *= 2;
13237      }
13238      if (e + eBias >= 1) {
13239        value += rt / c;
13240      } else {
13241        value += rt * Math.pow(2, 1 - eBias);
13242      }
13243      if (value * c >= 2) {
13244        e++;
13245        c /= 2;
13246      }
13247      if (e + eBias >= eMax) {
13248        m = 0;
13249        e = eMax;
13250      } else if (e + eBias >= 1) {
13251        m = (value * c - 1) * Math.pow(2, mLen);
13252        e = e + eBias;
13253      } else {
13254        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
13255        e = 0;
13256      }
13257    }
13258    for (; mLen >= 8; buffer2[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
13259    }
13260    e = e << mLen | m;
13261    eLen += mLen;
13262    for (; eLen > 0; buffer2[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
13263    }
13264    buffer2[offset + i2 - d] |= s * 128;
13265  };
13266  /*!
13267   * The buffer module from node.js, for the browser.
13268   *
13269   * @author   Feross Aboukhadijeh <https://feross.org>
13270   * @license  MIT
13271   */
13272  (function(exports$12) {
13273    const base64 = base64Js;
13274    const ieee754$1 = ieee754;
13275    const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
13276    exports$12.Buffer = Buffer2;
13277    exports$12.SlowBuffer = SlowBuffer;
13278    exports$12.INSPECT_MAX_BYTES = 50;
13279    const K_MAX_LENGTH = 2147483647;
13280    exports$12.kMaxLength = K_MAX_LENGTH;
13281    const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
13282    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
13283    if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
13284      console.error(
13285        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
13286      );
13287    }
13288    function typedArraySupport() {
13289      try {
13290        const arr = new GlobalUint8Array(1);
13291        const proto = { foo: function() {
13292          return 42;
13293        } };
13294        Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
13295        Object.setPrototypeOf(arr, proto);
13296        return arr.foo() === 42;
13297      } catch (e) {
13298        return false;
13299      }
13300    }
13301    Object.defineProperty(Buffer2.prototype, "parent", {
13302      enumerable: true,
13303      get: function() {
13304        if (!Buffer2.isBuffer(this)) return void 0;
13305        return this.buffer;
13306      }
13307    });
13308    Object.defineProperty(Buffer2.prototype, "offset", {
13309      enumerable: true,
13310      get: function() {
13311        if (!Buffer2.isBuffer(this)) return void 0;
13312        return this.byteOffset;
13313      }
13314    });
13315    function createBuffer(length) {
13316      if (length > K_MAX_LENGTH) {
13317        throw new RangeError('The value "' + length + '" is invalid for option "size"');
13318      }
13319      const buf = new GlobalUint8Array(length);
13320      Object.setPrototypeOf(buf, Buffer2.prototype);
13321      return buf;
13322    }
13323    function Buffer2(arg, encodingOrOffset, length) {
13324      if (typeof arg === "number") {
13325        if (typeof encodingOrOffset === "string") {
13326          throw new TypeError(
13327            'The "string" argument must be of type string. Received type number'
13328          );
13329        }
13330        return allocUnsafe(arg);
13331      }
13332      return from(arg, encodingOrOffset, length);
13333    }
13334    Buffer2.poolSize = 8192;
13335    function from(value, encodingOrOffset, length) {
13336      if (typeof value === "string") {
13337        return fromString(value, encodingOrOffset);
13338      }
13339      if (GlobalArrayBuffer.isView(value)) {
13340        return fromArrayView(value);
13341      }
13342      if (value == null) {
13343        throw new TypeError(
13344          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
13345        );
13346      }
13347      if (isInstance(value, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) {
13348        return fromArrayBuffer(value, encodingOrOffset, length);
13349      }
13350      if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) {
13351        return fromArrayBuffer(value, encodingOrOffset, length);
13352      }
13353      if (typeof value === "number") {
13354        throw new TypeError(
13355          'The "value" argument must not be of type number. Received type number'
13356        );
13357      }
13358      const valueOf = value.valueOf && value.valueOf();
13359      if (valueOf != null && valueOf !== value) {
13360        return Buffer2.from(valueOf, encodingOrOffset, length);
13361      }
13362      const b = fromObject(value);
13363      if (b) return b;
13364      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
13365        return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
13366      }
13367      throw new TypeError(
13368        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
13369      );
13370    }
13371    Buffer2.from = function(value, encodingOrOffset, length) {
13372      return from(value, encodingOrOffset, length);
13373    };
13374    Object.setPrototypeOf(Buffer2.prototype, GlobalUint8Array.prototype);
13375    Object.setPrototypeOf(Buffer2, GlobalUint8Array);
13376    function assertSize(size) {
13377      if (typeof size !== "number") {
13378        throw new TypeError('"size" argument must be of type number');
13379      } else if (size < 0) {
13380        throw new RangeError('The value "' + size + '" is invalid for option "size"');
13381      }
13382    }
13383    function alloc(size, fill, encoding) {
13384      assertSize(size);
13385      if (size <= 0) {
13386        return createBuffer(size);
13387      }
13388      if (fill !== void 0) {
13389        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
13390      }
13391      return createBuffer(size);
13392    }
13393    Buffer2.alloc = function(size, fill, encoding) {
13394      return alloc(size, fill, encoding);
13395    };
13396    function allocUnsafe(size) {
13397      assertSize(size);
13398      return createBuffer(size < 0 ? 0 : checked(size) | 0);
13399    }
13400    Buffer2.allocUnsafe = function(size) {
13401      return allocUnsafe(size);
13402    };
13403    Buffer2.allocUnsafeSlow = function(size) {
13404      return allocUnsafe(size);
13405    };
13406    function fromString(string, encoding) {
13407      if (typeof encoding !== "string" || encoding === "") {
13408        encoding = "utf8";
13409      }
13410      if (!Buffer2.isEncoding(encoding)) {
13411        throw new TypeError("Unknown encoding: " + encoding);
13412      }
13413      const length = byteLength2(string, encoding) | 0;
13414      let buf = createBuffer(length);
13415      const actual = buf.write(string, encoding);
13416      if (actual !== length) {
13417        buf = buf.slice(0, actual);
13418      }
13419      return buf;
13420    }
13421    function fromArrayLike(array) {
13422      const length = array.length < 0 ? 0 : checked(array.length) | 0;
13423      const buf = createBuffer(length);
13424      for (let i2 = 0; i2 < length; i2 += 1) {
13425        buf[i2] = array[i2] & 255;
13426      }
13427      return buf;
13428    }
13429    function fromArrayView(arrayView) {
13430      if (isInstance(arrayView, GlobalUint8Array)) {
13431        const copy = new GlobalUint8Array(arrayView);
13432        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
13433      }
13434      return fromArrayLike(arrayView);
13435    }
13436    function fromArrayBuffer(array, byteOffset, length) {
13437      if (byteOffset < 0 || array.byteLength < byteOffset) {
13438        throw new RangeError('"offset" is outside of buffer bounds');
13439      }
13440      if (array.byteLength < byteOffset + (length || 0)) {
13441        throw new RangeError('"length" is outside of buffer bounds');
13442      }
13443      let buf;
13444      if (byteOffset === void 0 && length === void 0) {
13445        buf = new GlobalUint8Array(array);
13446      } else if (length === void 0) {
13447        buf = new GlobalUint8Array(array, byteOffset);
13448      } else {
13449        buf = new GlobalUint8Array(array, byteOffset, length);
13450      }
13451      Object.setPrototypeOf(buf, Buffer2.prototype);
13452      return buf;
13453    }
13454    function fromObject(obj) {
13455      if (Buffer2.isBuffer(obj)) {
13456        const len2 = checked(obj.length) | 0;
13457        const buf = createBuffer(len2);
13458        if (buf.length === 0) {
13459          return buf;
13460        }
13461        obj.copy(buf, 0, 0, len2);
13462        return buf;
13463      }
13464      if (obj.length !== void 0) {
13465        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
13466          return createBuffer(0);
13467        }
13468        return fromArrayLike(obj);
13469      }
13470      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
13471        return fromArrayLike(obj.data);
13472      }
13473    }
13474    function checked(length) {
13475      if (length >= K_MAX_LENGTH) {
13476        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
13477      }
13478      return length | 0;
13479    }
13480    function SlowBuffer(length) {
13481      if (+length != length) {
13482        length = 0;
13483      }
13484      return Buffer2.alloc(+length);
13485    }
13486    Buffer2.isBuffer = function isBuffer2(b) {
13487      return b != null && b._isBuffer === true && b !== Buffer2.prototype;
13488    };
13489    Buffer2.compare = function compare(a, b) {
13490      if (isInstance(a, GlobalUint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);
13491      if (isInstance(b, GlobalUint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);
13492      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
13493        throw new TypeError(
13494          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
13495        );
13496      }
13497      if (a === b) return 0;
13498      let x = a.length;
13499      let y = b.length;
13500      for (let i2 = 0, len2 = Math.min(x, y); i2 < len2; ++i2) {
13501        if (a[i2] !== b[i2]) {
13502          x = a[i2];
13503          y = b[i2];
13504          break;
13505        }
13506      }
13507      if (x < y) return -1;
13508      if (y < x) return 1;
13509      return 0;
13510    };
13511    Buffer2.isEncoding = function isEncoding(encoding) {
13512      switch (String(encoding).toLowerCase()) {
13513        case "hex":
13514        case "utf8":
13515        case "utf-8":
13516        case "ascii":
13517        case "latin1":
13518        case "binary":
13519        case "base64":
13520        case "ucs2":
13521        case "ucs-2":
13522        case "utf16le":
13523        case "utf-16le":
13524          return true;
13525        default:
13526          return false;
13527      }
13528    };
13529    Buffer2.concat = function concat(list, length) {
13530      if (!Array.isArray(list)) {
13531        throw new TypeError('"list" argument must be an Array of Buffers');
13532      }
13533      if (list.length === 0) {
13534        return Buffer2.alloc(0);
13535      }
13536      let i2;
13537      if (length === void 0) {
13538        length = 0;
13539        for (i2 = 0; i2 < list.length; ++i2) {
13540          length += list[i2].length;
13541        }
13542      }
13543      const buffer2 = Buffer2.allocUnsafe(length);
13544      let pos = 0;
13545      for (i2 = 0; i2 < list.length; ++i2) {
13546        let buf = list[i2];
13547        if (isInstance(buf, GlobalUint8Array)) {
13548          if (pos + buf.length > buffer2.length) {
13549            if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
13550            buf.copy(buffer2, pos);
13551          } else {
13552            GlobalUint8Array.prototype.set.call(
13553              buffer2,
13554              buf,
13555              pos
13556            );
13557          }
13558        } else if (!Buffer2.isBuffer(buf)) {
13559          throw new TypeError('"list" argument must be an Array of Buffers');
13560        } else {
13561          buf.copy(buffer2, pos);
13562        }
13563        pos += buf.length;
13564      }
13565      return buffer2;
13566    };
13567    function byteLength2(string, encoding) {
13568      if (Buffer2.isBuffer(string)) {
13569        return string.length;
13570      }
13571      if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) {
13572        return string.byteLength;
13573      }
13574      if (typeof string !== "string") {
13575        throw new TypeError(
13576          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
13577        );
13578      }
13579      const len2 = string.length;
13580      const mustMatch = arguments.length > 2 && arguments[2] === true;
13581      if (!mustMatch && len2 === 0) return 0;
13582      let loweredCase = false;
13583      for (; ; ) {
13584        switch (encoding) {
13585          case "ascii":
13586          case "latin1":
13587          case "binary":
13588            return len2;
13589          case "utf8":
13590          case "utf-8":
13591            return utf8ToBytes(string).length;
13592          case "ucs2":
13593          case "ucs-2":
13594          case "utf16le":
13595          case "utf-16le":
13596            return len2 * 2;
13597          case "hex":
13598            return len2 >>> 1;
13599          case "base64":
13600            return base64ToBytes(string).length;
13601          default:
13602            if (loweredCase) {
13603              return mustMatch ? -1 : utf8ToBytes(string).length;
13604            }
13605            encoding = ("" + encoding).toLowerCase();
13606            loweredCase = true;
13607        }
13608      }
13609    }
13610    Buffer2.byteLength = byteLength2;
13611    function slowToString(encoding, start, end) {
13612      let loweredCase = false;
13613      if (start === void 0 || start < 0) {
13614        start = 0;
13615      }
13616      if (start > this.length) {
13617        return "";
13618      }
13619      if (end === void 0 || end > this.length) {
13620        end = this.length;
13621      }
13622      if (end <= 0) {
13623        return "";
13624      }
13625      end >>>= 0;
13626      start >>>= 0;
13627      if (end <= start) {
13628        return "";
13629      }
13630      if (!encoding) encoding = "utf8";
13631      while (true) {
13632        switch (encoding) {
13633          case "hex":
13634            return hexSlice(this, start, end);
13635          case "utf8":
13636          case "utf-8":
13637            return utf8Slice(this, start, end);
13638          case "ascii":
13639            return asciiSlice(this, start, end);
13640          case "latin1":
13641          case "binary":
13642            return latin1Slice(this, start, end);
13643          case "base64":
13644            return base64Slice(this, start, end);
13645          case "ucs2":
13646          case "ucs-2":
13647          case "utf16le":
13648          case "utf-16le":
13649            return utf16leSlice(this, start, end);
13650          default:
13651            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
13652            encoding = (encoding + "").toLowerCase();
13653            loweredCase = true;
13654        }
13655      }
13656    }
13657    Buffer2.prototype._isBuffer = true;
13658    function swap(b, n, m) {
13659      const i2 = b[n];
13660      b[n] = b[m];
13661      b[m] = i2;
13662    }
13663    Buffer2.prototype.swap16 = function swap16() {
13664      const len2 = this.length;
13665      if (len2 % 2 !== 0) {
13666        throw new RangeError("Buffer size must be a multiple of 16-bits");
13667      }
13668      for (let i2 = 0; i2 < len2; i2 += 2) {
13669        swap(this, i2, i2 + 1);
13670      }
13671      return this;
13672    };
13673    Buffer2.prototype.swap32 = function swap32() {
13674      const len2 = this.length;
13675      if (len2 % 4 !== 0) {
13676        throw new RangeError("Buffer size must be a multiple of 32-bits");
13677      }
13678      for (let i2 = 0; i2 < len2; i2 += 4) {
13679        swap(this, i2, i2 + 3);
13680        swap(this, i2 + 1, i2 + 2);
13681      }
13682      return this;
13683    };
13684    Buffer2.prototype.swap64 = function swap64() {
13685      const len2 = this.length;
13686      if (len2 % 8 !== 0) {
13687        throw new RangeError("Buffer size must be a multiple of 64-bits");
13688      }
13689      for (let i2 = 0; i2 < len2; i2 += 8) {
13690        swap(this, i2, i2 + 7);
13691        swap(this, i2 + 1, i2 + 6);
13692        swap(this, i2 + 2, i2 + 5);
13693        swap(this, i2 + 3, i2 + 4);
13694      }
13695      return this;
13696    };
13697    Buffer2.prototype.toString = function toString2() {
13698      const length = this.length;
13699      if (length === 0) return "";
13700      if (arguments.length === 0) return utf8Slice(this, 0, length);
13701      return slowToString.apply(this, arguments);
13702    };
13703    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
13704    Buffer2.prototype.equals = function equals(b) {
13705      if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
13706      if (this === b) return true;
13707      return Buffer2.compare(this, b) === 0;
13708    };
13709    Buffer2.prototype.inspect = function inspect() {
13710      let str = "";
13711      const max2 = exports$12.INSPECT_MAX_BYTES;
13712      str = this.toString("hex", 0, max2).replace(/(.{2})/g, "$1 ").trim();
13713      if (this.length > max2) str += " ... ";
13714      return "<Buffer " + str + ">";
13715    };
13716    if (customInspectSymbol) {
13717      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
13718    }
13719    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
13720      if (isInstance(target, GlobalUint8Array)) {
13721        target = Buffer2.from(target, target.offset, target.byteLength);
13722      }
13723      if (!Buffer2.isBuffer(target)) {
13724        throw new TypeError(
13725          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
13726        );
13727      }
13728      if (start === void 0) {
13729        start = 0;
13730      }
13731      if (end === void 0) {
13732        end = target ? target.length : 0;
13733      }
13734      if (thisStart === void 0) {
13735        thisStart = 0;
13736      }
13737      if (thisEnd === void 0) {
13738        thisEnd = this.length;
13739      }
13740      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
13741        throw new RangeError("out of range index");
13742      }
13743      if (thisStart >= thisEnd && start >= end) {
13744        return 0;
13745      }
13746      if (thisStart >= thisEnd) {
13747        return -1;
13748      }
13749      if (start >= end) {
13750        return 1;
13751      }
13752      start >>>= 0;
13753      end >>>= 0;
13754      thisStart >>>= 0;
13755      thisEnd >>>= 0;
13756      if (this === target) return 0;
13757      let x = thisEnd - thisStart;
13758      let y = end - start;
13759      const len2 = Math.min(x, y);
13760      const thisCopy = this.slice(thisStart, thisEnd);
13761      const targetCopy = target.slice(start, end);
13762      for (let i2 = 0; i2 < len2; ++i2) {
13763        if (thisCopy[i2] !== targetCopy[i2]) {
13764          x = thisCopy[i2];
13765          y = targetCopy[i2];
13766          break;
13767        }
13768      }
13769      if (x < y) return -1;
13770      if (y < x) return 1;
13771      return 0;
13772    };
13773    function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
13774      if (buffer2.length === 0) return -1;
13775      if (typeof byteOffset === "string") {
13776        encoding = byteOffset;
13777        byteOffset = 0;
13778      } else if (byteOffset > 2147483647) {
13779        byteOffset = 2147483647;
13780      } else if (byteOffset < -2147483648) {
13781        byteOffset = -2147483648;
13782      }
13783      byteOffset = +byteOffset;
13784      if (numberIsNaN(byteOffset)) {
13785        byteOffset = dir ? 0 : buffer2.length - 1;
13786      }
13787      if (byteOffset < 0) byteOffset = buffer2.length + byteOffset;
13788      if (byteOffset >= buffer2.length) {
13789        if (dir) return -1;
13790        else byteOffset = buffer2.length - 1;
13791      } else if (byteOffset < 0) {
13792        if (dir) byteOffset = 0;
13793        else return -1;
13794      }
13795      if (typeof val === "string") {
13796        val = Buffer2.from(val, encoding);
13797      }
13798      if (Buffer2.isBuffer(val)) {
13799        if (val.length === 0) {
13800          return -1;
13801        }
13802        return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
13803      } else if (typeof val === "number") {
13804        val = val & 255;
13805        if (typeof GlobalUint8Array.prototype.indexOf === "function") {
13806          if (dir) {
13807            return GlobalUint8Array.prototype.indexOf.call(buffer2, val, byteOffset);
13808          } else {
13809            return GlobalUint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
13810          }
13811        }
13812        return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
13813      }
13814      throw new TypeError("val must be string, number or Buffer");
13815    }
13816    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
13817      let indexSize = 1;
13818      let arrLength = arr.length;
13819      let valLength = val.length;
13820      if (encoding !== void 0) {
13821        encoding = String(encoding).toLowerCase();
13822        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
13823          if (arr.length < 2 || val.length < 2) {
13824            return -1;
13825          }
13826          indexSize = 2;
13827          arrLength /= 2;
13828          valLength /= 2;
13829          byteOffset /= 2;
13830        }
13831      }
13832      function read(buf, i3) {
13833        if (indexSize === 1) {
13834          return buf[i3];
13835        } else {
13836          return buf.readUInt16BE(i3 * indexSize);
13837        }
13838      }
13839      let i2;
13840      if (dir) {
13841        let foundIndex = -1;
13842        for (i2 = byteOffset; i2 < arrLength; i2++) {
13843          if (read(arr, i2) === read(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
13844            if (foundIndex === -1) foundIndex = i2;
13845            if (i2 - foundIndex + 1 === valLength) return foundIndex * indexSize;
13846          } else {
13847            if (foundIndex !== -1) i2 -= i2 - foundIndex;
13848            foundIndex = -1;
13849          }
13850        }
13851      } else {
13852        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
13853        for (i2 = byteOffset; i2 >= 0; i2--) {
13854          let found = true;
13855          for (let j = 0; j < valLength; j++) {
13856            if (read(arr, i2 + j) !== read(val, j)) {
13857              found = false;
13858              break;
13859            }
13860          }
13861          if (found) return i2;
13862        }
13863      }
13864      return -1;
13865    }
13866    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
13867      return this.indexOf(val, byteOffset, encoding) !== -1;
13868    };
13869    Buffer2.prototype.indexOf = function indexOf2(val, byteOffset, encoding) {
13870      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
13871    };
13872    Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
13873      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
13874    };
13875    function hexWrite(buf, string, offset, length) {
13876      offset = Number(offset) || 0;
13877      const remaining = buf.length - offset;
13878      if (!length) {
13879        length = remaining;
13880      } else {
13881        length = Number(length);
13882        if (length > remaining) {
13883          length = remaining;
13884        }
13885      }
13886      const strLen = string.length;
13887      if (length > strLen / 2) {
13888        length = strLen / 2;
13889      }
13890      let i2;
13891      for (i2 = 0; i2 < length; ++i2) {
13892        const parsed = parseInt(string.substr(i2 * 2, 2), 16);
13893        if (numberIsNaN(parsed)) return i2;
13894        buf[offset + i2] = parsed;
13895      }
13896      return i2;
13897    }
13898    function utf8Write(buf, string, offset, length) {
13899      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
13900    }
13901    function asciiWrite(buf, string, offset, length) {
13902      return blitBuffer(asciiToBytes(string), buf, offset, length);
13903    }
13904    function base64Write(buf, string, offset, length) {
13905      return blitBuffer(base64ToBytes(string), buf, offset, length);
13906    }
13907    function ucs2Write(buf, string, offset, length) {
13908      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
13909    }
13910    Buffer2.prototype.write = function write(string, offset, length, encoding) {
13911      if (offset === void 0) {
13912        encoding = "utf8";
13913        length = this.length;
13914        offset = 0;
13915      } else if (length === void 0 && typeof offset === "string") {
13916        encoding = offset;
13917        length = this.length;
13918        offset = 0;
13919      } else if (isFinite(offset)) {
13920        offset = offset >>> 0;
13921        if (isFinite(length)) {
13922          length = length >>> 0;
13923          if (encoding === void 0) encoding = "utf8";
13924        } else {
13925          encoding = length;
13926          length = void 0;
13927        }
13928      } else {
13929        throw new Error(
13930          "Buffer.write(string, encoding, offset[, length]) is no longer supported"
13931        );
13932      }
13933      const remaining = this.length - offset;
13934      if (length === void 0 || length > remaining) length = remaining;
13935      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
13936        throw new RangeError("Attempt to write outside buffer bounds");
13937      }
13938      if (!encoding) encoding = "utf8";
13939      let loweredCase = false;
13940      for (; ; ) {
13941        switch (encoding) {
13942          case "hex":
13943            return hexWrite(this, string, offset, length);
13944          case "utf8":
13945          case "utf-8":
13946            return utf8Write(this, string, offset, length);
13947          case "ascii":
13948          case "latin1":
13949          case "binary":
13950            return asciiWrite(this, string, offset, length);
13951          case "base64":
13952            return base64Write(this, string, offset, length);
13953          case "ucs2":
13954          case "ucs-2":
13955          case "utf16le":
13956          case "utf-16le":
13957            return ucs2Write(this, string, offset, length);
13958          default:
13959            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
13960            encoding = ("" + encoding).toLowerCase();
13961            loweredCase = true;
13962        }
13963      }
13964    };
13965    Buffer2.prototype.toJSON = function toJSON() {
13966      return {
13967        type: "Buffer",
13968        data: Array.prototype.slice.call(this._arr || this, 0)
13969      };
13970    };
13971    function base64Slice(buf, start, end) {
13972      if (start === 0 && end === buf.length) {
13973        return base64.fromByteArray(buf);
13974      } else {
13975        return base64.fromByteArray(buf.slice(start, end));
13976      }
13977    }
13978    function utf8Slice(buf, start, end) {
13979      end = Math.min(buf.length, end);
13980      const res = [];
13981      let i2 = start;
13982      while (i2 < end) {
13983        const firstByte = buf[i2];
13984        let codePoint = null;
13985        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
13986        if (i2 + bytesPerSequence <= end) {
13987          let secondByte, thirdByte, fourthByte, tempCodePoint;
13988          switch (bytesPerSequence) {
13989            case 1:
13990              if (firstByte < 128) {
13991                codePoint = firstByte;
13992              }
13993              break;
13994            case 2:
13995              secondByte = buf[i2 + 1];
13996              if ((secondByte & 192) === 128) {
13997                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
13998                if (tempCodePoint > 127) {
13999                  codePoint = tempCodePoint;
14000                }
14001              }
14002              break;
14003            case 3:
14004              secondByte = buf[i2 + 1];
14005              thirdByte = buf[i2 + 2];
14006              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
14007                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
14008                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
14009                  codePoint = tempCodePoint;
14010                }
14011              }
14012              break;
14013            case 4:
14014              secondByte = buf[i2 + 1];
14015              thirdByte = buf[i2 + 2];
14016              fourthByte = buf[i2 + 3];
14017              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
14018                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
14019                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
14020                  codePoint = tempCodePoint;
14021                }
14022              }
14023          }
14024        }
14025        if (codePoint === null) {
14026          codePoint = 65533;
14027          bytesPerSequence = 1;
14028        } else if (codePoint > 65535) {
14029          codePoint -= 65536;
14030          res.push(codePoint >>> 10 & 1023 | 55296);
14031          codePoint = 56320 | codePoint & 1023;
14032        }
14033        res.push(codePoint);
14034        i2 += bytesPerSequence;
14035      }
14036      return decodeCodePointsArray(res);
14037    }
14038    const MAX_ARGUMENTS_LENGTH = 4096;
14039    function decodeCodePointsArray(codePoints) {
14040      const len2 = codePoints.length;
14041      if (len2 <= MAX_ARGUMENTS_LENGTH) {
14042        return String.fromCharCode.apply(String, codePoints);
14043      }
14044      let res = "";
14045      let i2 = 0;
14046      while (i2 < len2) {
14047        res += String.fromCharCode.apply(
14048          String,
14049          codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH)
14050        );
14051      }
14052      return res;
14053    }
14054    function asciiSlice(buf, start, end) {
14055      let ret = "";
14056      end = Math.min(buf.length, end);
14057      for (let i2 = start; i2 < end; ++i2) {
14058        ret += String.fromCharCode(buf[i2] & 127);
14059      }
14060      return ret;
14061    }
14062    function latin1Slice(buf, start, end) {
14063      let ret = "";
14064      end = Math.min(buf.length, end);
14065      for (let i2 = start; i2 < end; ++i2) {
14066        ret += String.fromCharCode(buf[i2]);
14067      }
14068      return ret;
14069    }
14070    function hexSlice(buf, start, end) {
14071      const len2 = buf.length;
14072      if (!start || start < 0) start = 0;
14073      if (!end || end < 0 || end > len2) end = len2;
14074      let out = "";
14075      for (let i2 = start; i2 < end; ++i2) {
14076        out += hexSliceLookupTable[buf[i2]];
14077      }
14078      return out;
14079    }
14080    function utf16leSlice(buf, start, end) {
14081      const bytes = buf.slice(start, end);
14082      let res = "";
14083      for (let i2 = 0; i2 < bytes.length - 1; i2 += 2) {
14084        res += String.fromCharCode(bytes[i2] + bytes[i2 + 1] * 256);
14085      }
14086      return res;
14087    }
14088    Buffer2.prototype.slice = function slice(start, end) {
14089      const len2 = this.length;
14090      start = ~~start;
14091      end = end === void 0 ? len2 : ~~end;
14092      if (start < 0) {
14093        start += len2;
14094        if (start < 0) start = 0;
14095      } else if (start > len2) {
14096        start = len2;
14097      }
14098      if (end < 0) {
14099        end += len2;
14100        if (end < 0) end = 0;
14101      } else if (end > len2) {
14102        end = len2;
14103      }
14104      if (end < start) end = start;
14105      const newBuf = this.subarray(start, end);
14106      Object.setPrototypeOf(newBuf, Buffer2.prototype);
14107      return newBuf;
14108    };
14109    function checkOffset(offset, ext, length) {
14110      if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
14111      if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
14112    }
14113    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength3, noAssert) {
14114      offset = offset >>> 0;
14115      byteLength3 = byteLength3 >>> 0;
14116      if (!noAssert) checkOffset(offset, byteLength3, this.length);
14117      let val = this[offset];
14118      let mul = 1;
14119      let i2 = 0;
14120      while (++i2 < byteLength3 && (mul *= 256)) {
14121        val += this[offset + i2] * mul;
14122      }
14123      return val;
14124    };
14125    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
14126      offset = offset >>> 0;
14127      byteLength3 = byteLength3 >>> 0;
14128      if (!noAssert) {
14129        checkOffset(offset, byteLength3, this.length);
14130      }
14131      let val = this[offset + --byteLength3];
14132      let mul = 1;
14133      while (byteLength3 > 0 && (mul *= 256)) {
14134        val += this[offset + --byteLength3] * mul;
14135      }
14136      return val;
14137    };
14138    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
14139      offset = offset >>> 0;
14140      if (!noAssert) checkOffset(offset, 1, this.length);
14141      return this[offset];
14142    };
14143    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
14144      offset = offset >>> 0;
14145      if (!noAssert) checkOffset(offset, 2, this.length);
14146      return this[offset] | this[offset + 1] << 8;
14147    };
14148    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
14149      offset = offset >>> 0;
14150      if (!noAssert) checkOffset(offset, 2, this.length);
14151      return this[offset] << 8 | this[offset + 1];
14152    };
14153    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
14154      offset = offset >>> 0;
14155      if (!noAssert) checkOffset(offset, 4, this.length);
14156      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
14157    };
14158    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
14159      offset = offset >>> 0;
14160      if (!noAssert) checkOffset(offset, 4, this.length);
14161      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
14162    };
14163    Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
14164      offset = offset >>> 0;
14165      validateNumber(offset, "offset");
14166      const first = this[offset];
14167      const last = this[offset + 7];
14168      if (first === void 0 || last === void 0) {
14169        boundsError(offset, this.length - 8);
14170      }
14171      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
14172      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
14173      return BigInt(lo) + (BigInt(hi) << BigInt(32));
14174    });
14175    Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
14176      offset = offset >>> 0;
14177      validateNumber(offset, "offset");
14178      const first = this[offset];
14179      const last = this[offset + 7];
14180      if (first === void 0 || last === void 0) {
14181        boundsError(offset, this.length - 8);
14182      }
14183      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
14184      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
14185      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
14186    });
14187    Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) {
14188      offset = offset >>> 0;
14189      byteLength3 = byteLength3 >>> 0;
14190      if (!noAssert) checkOffset(offset, byteLength3, this.length);
14191      let val = this[offset];
14192      let mul = 1;
14193      let i2 = 0;
14194      while (++i2 < byteLength3 && (mul *= 256)) {
14195        val += this[offset + i2] * mul;
14196      }
14197      mul *= 128;
14198      if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
14199      return val;
14200    };
14201    Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
14202      offset = offset >>> 0;
14203      byteLength3 = byteLength3 >>> 0;
14204      if (!noAssert) checkOffset(offset, byteLength3, this.length);
14205      let i2 = byteLength3;
14206      let mul = 1;
14207      let val = this[offset + --i2];
14208      while (i2 > 0 && (mul *= 256)) {
14209        val += this[offset + --i2] * mul;
14210      }
14211      mul *= 128;
14212      if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
14213      return val;
14214    };
14215    Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
14216      offset = offset >>> 0;
14217      if (!noAssert) checkOffset(offset, 1, this.length);
14218      if (!(this[offset] & 128)) return this[offset];
14219      return (255 - this[offset] + 1) * -1;
14220    };
14221    Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
14222      offset = offset >>> 0;
14223      if (!noAssert) checkOffset(offset, 2, this.length);
14224      const val = this[offset] | this[offset + 1] << 8;
14225      return val & 32768 ? val | 4294901760 : val;
14226    };
14227    Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
14228      offset = offset >>> 0;
14229      if (!noAssert) checkOffset(offset, 2, this.length);
14230      const val = this[offset + 1] | this[offset] << 8;
14231      return val & 32768 ? val | 4294901760 : val;
14232    };
14233    Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
14234      offset = offset >>> 0;
14235      if (!noAssert) checkOffset(offset, 4, this.length);
14236      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
14237    };
14238    Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
14239      offset = offset >>> 0;
14240      if (!noAssert) checkOffset(offset, 4, this.length);
14241      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
14242    };
14243    Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
14244      offset = offset >>> 0;
14245      validateNumber(offset, "offset");
14246      const first = this[offset];
14247      const last = this[offset + 7];
14248      if (first === void 0 || last === void 0) {
14249        boundsError(offset, this.length - 8);
14250      }
14251      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
14252      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
14253    });
14254    Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
14255      offset = offset >>> 0;
14256      validateNumber(offset, "offset");
14257      const first = this[offset];
14258      const last = this[offset + 7];
14259      if (first === void 0 || last === void 0) {
14260        boundsError(offset, this.length - 8);
14261      }
14262      const val = (first << 24) + // Overflow
14263      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
14264      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
14265    });
14266    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
14267      offset = offset >>> 0;
14268      if (!noAssert) checkOffset(offset, 4, this.length);
14269      return ieee754$1.read(this, offset, true, 23, 4);
14270    };
14271    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
14272      offset = offset >>> 0;
14273      if (!noAssert) checkOffset(offset, 4, this.length);
14274      return ieee754$1.read(this, offset, false, 23, 4);
14275    };
14276    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
14277      offset = offset >>> 0;
14278      if (!noAssert) checkOffset(offset, 8, this.length);
14279      return ieee754$1.read(this, offset, true, 52, 8);
14280    };
14281    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
14282      offset = offset >>> 0;
14283      if (!noAssert) checkOffset(offset, 8, this.length);
14284      return ieee754$1.read(this, offset, false, 52, 8);
14285    };
14286    function checkInt(buf, value, offset, ext, max2, min2) {
14287      if (!Buffer2.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
14288      if (value > max2 || value < min2) throw new RangeError('"value" argument is out of bounds');
14289      if (offset + ext > buf.length) throw new RangeError("Index out of range");
14290    }
14291    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength3, noAssert) {
14292      value = +value;
14293      offset = offset >>> 0;
14294      byteLength3 = byteLength3 >>> 0;
14295      if (!noAssert) {
14296        const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
14297        checkInt(this, value, offset, byteLength3, maxBytes, 0);
14298      }
14299      let mul = 1;
14300      let i2 = 0;
14301      this[offset] = value & 255;
14302      while (++i2 < byteLength3 && (mul *= 256)) {
14303        this[offset + i2] = value / mul & 255;
14304      }
14305      return offset + byteLength3;
14306    };
14307    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength3, noAssert) {
14308      value = +value;
14309      offset = offset >>> 0;
14310      byteLength3 = byteLength3 >>> 0;
14311      if (!noAssert) {
14312        const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
14313        checkInt(this, value, offset, byteLength3, maxBytes, 0);
14314      }
14315      let i2 = byteLength3 - 1;
14316      let mul = 1;
14317      this[offset + i2] = value & 255;
14318      while (--i2 >= 0 && (mul *= 256)) {
14319        this[offset + i2] = value / mul & 255;
14320      }
14321      return offset + byteLength3;
14322    };
14323    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
14324      value = +value;
14325      offset = offset >>> 0;
14326      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
14327      this[offset] = value & 255;
14328      return offset + 1;
14329    };

vendor: 4,759 bytes, lines 14330-14457

14330    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
14331      value = +value;
14332      offset = offset >>> 0;
14333      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
14334      this[offset] = value & 255;
14335      this[offset + 1] = value >>> 8;
14336      return offset + 2;
14337    };
14338    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
14339      value = +value;
14340      offset = offset >>> 0;
14341      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
14342      this[offset] = value >>> 8;
14343      this[offset + 1] = value & 255;
14344      return offset + 2;
14345    };
14346    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
14347      value = +value;
14348      offset = offset >>> 0;
14349      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
14350      this[offset + 3] = value >>> 24;
14351      this[offset + 2] = value >>> 16;
14352      this[offset + 1] = value >>> 8;
14353      this[offset] = value & 255;
14354      return offset + 4;
14355    };
14356    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
14357      value = +value;
14358      offset = offset >>> 0;
14359      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
14360      this[offset] = value >>> 24;
14361      this[offset + 1] = value >>> 16;
14362      this[offset + 2] = value >>> 8;
14363      this[offset + 3] = value & 255;
14364      return offset + 4;
14365    };
14366    function wrtBigUInt64LE(buf, value, offset, min2, max2) {
14367      checkIntBI(value, min2, max2, buf, offset, 7);
14368      let lo = Number(value & BigInt(4294967295));
14369      buf[offset++] = lo;
14370      lo = lo >> 8;
14371      buf[offset++] = lo;
14372      lo = lo >> 8;
14373      buf[offset++] = lo;
14374      lo = lo >> 8;
14375      buf[offset++] = lo;
14376      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
14377      buf[offset++] = hi;
14378      hi = hi >> 8;
14379      buf[offset++] = hi;
14380      hi = hi >> 8;
14381      buf[offset++] = hi;
14382      hi = hi >> 8;
14383      buf[offset++] = hi;
14384      return offset;
14385    }
14386    function wrtBigUInt64BE(buf, value, offset, min2, max2) {
14387      checkIntBI(value, min2, max2, buf, offset, 7);
14388      let lo = Number(value & BigInt(4294967295));
14389      buf[offset + 7] = lo;
14390      lo = lo >> 8;
14391      buf[offset + 6] = lo;
14392      lo = lo >> 8;
14393      buf[offset + 5] = lo;
14394      lo = lo >> 8;
14395      buf[offset + 4] = lo;
14396      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
14397      buf[offset + 3] = hi;
14398      hi = hi >> 8;
14399      buf[offset + 2] = hi;
14400      hi = hi >> 8;
14401      buf[offset + 1] = hi;
14402      hi = hi >> 8;
14403      buf[offset] = hi;
14404      return offset + 8;
14405    }
14406    Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
14407      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
14408    });
14409    Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
14410      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
14411    });
14412    Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength3, noAssert) {
14413      value = +value;
14414      offset = offset >>> 0;
14415      if (!noAssert) {
14416        const limit = Math.pow(2, 8 * byteLength3 - 1);
14417        checkInt(this, value, offset, byteLength3, limit - 1, -limit);
14418      }
14419      let i2 = 0;
14420      let mul = 1;
14421      let sub = 0;
14422      this[offset] = value & 255;
14423      while (++i2 < byteLength3 && (mul *= 256)) {
14424        if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0) {
14425          sub = 1;
14426        }
14427        this[offset + i2] = (value / mul >> 0) - sub & 255;
14428      }
14429      return offset + byteLength3;
14430    };
14431    Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength3, noAssert) {
14432      value = +value;
14433      offset = offset >>> 0;
14434      if (!noAssert) {
14435        const limit = Math.pow(2, 8 * byteLength3 - 1);
14436        checkInt(this, value, offset, byteLength3, limit - 1, -limit);
14437      }
14438      let i2 = byteLength3 - 1;
14439      let mul = 1;
14440      let sub = 0;
14441      this[offset + i2] = value & 255;
14442      while (--i2 >= 0 && (mul *= 256)) {
14443        if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0) {
14444          sub = 1;
14445        }
14446        this[offset + i2] = (value / mul >> 0) - sub & 255;
14447      }
14448      return offset + byteLength3;
14449    };
14450    Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
14451      value = +value;
14452      offset = offset >>> 0;
14453      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
14454      if (value < 0) value = 255 + value + 1;
14455      this[offset] = value & 255;
14456      return offset + 1;
14457    };

vendor: 10,859 bytes, lines 14458-14756

14458    Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
14459      value = +value;
14460      offset = offset >>> 0;
14461      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
14462      this[offset] = value & 255;
14463      this[offset + 1] = value >>> 8;
14464      return offset + 2;
14465    };
14466    Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
14467      value = +value;
14468      offset = offset >>> 0;
14469      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
14470      this[offset] = value >>> 8;
14471      this[offset + 1] = value & 255;
14472      return offset + 2;
14473    };
14474    Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
14475      value = +value;
14476      offset = offset >>> 0;
14477      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
14478      this[offset] = value & 255;
14479      this[offset + 1] = value >>> 8;
14480      this[offset + 2] = value >>> 16;
14481      this[offset + 3] = value >>> 24;
14482      return offset + 4;
14483    };
14484    Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
14485      value = +value;
14486      offset = offset >>> 0;
14487      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
14488      if (value < 0) value = 4294967295 + value + 1;
14489      this[offset] = value >>> 24;
14490      this[offset + 1] = value >>> 16;
14491      this[offset + 2] = value >>> 8;
14492      this[offset + 3] = value & 255;
14493      return offset + 4;
14494    };
14495    Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
14496      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
14497    });
14498    Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
14499      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
14500    });
14501    function checkIEEE754(buf, value, offset, ext, max2, min2) {
14502      if (offset + ext > buf.length) throw new RangeError("Index out of range");
14503      if (offset < 0) throw new RangeError("Index out of range");
14504    }
14505    function writeFloat(buf, value, offset, littleEndian, noAssert) {
14506      value = +value;
14507      offset = offset >>> 0;
14508      if (!noAssert) {
14509        checkIEEE754(buf, value, offset, 4);
14510      }
14511      ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
14512      return offset + 4;
14513    }
14514    Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
14515      return writeFloat(this, value, offset, true, noAssert);
14516    };
14517    Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
14518      return writeFloat(this, value, offset, false, noAssert);
14519    };
14520    function writeDouble(buf, value, offset, littleEndian, noAssert) {
14521      value = +value;
14522      offset = offset >>> 0;
14523      if (!noAssert) {
14524        checkIEEE754(buf, value, offset, 8);
14525      }
14526      ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
14527      return offset + 8;
14528    }
14529    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
14530      return writeDouble(this, value, offset, true, noAssert);
14531    };
14532    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
14533      return writeDouble(this, value, offset, false, noAssert);
14534    };
14535    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
14536      if (!Buffer2.isBuffer(target)) throw new TypeError("argument should be a Buffer");
14537      if (!start) start = 0;
14538      if (!end && end !== 0) end = this.length;
14539      if (targetStart >= target.length) targetStart = target.length;
14540      if (!targetStart) targetStart = 0;
14541      if (end > 0 && end < start) end = start;
14542      if (end === start) return 0;
14543      if (target.length === 0 || this.length === 0) return 0;
14544      if (targetStart < 0) {
14545        throw new RangeError("targetStart out of bounds");
14546      }
14547      if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
14548      if (end < 0) throw new RangeError("sourceEnd out of bounds");
14549      if (end > this.length) end = this.length;
14550      if (target.length - targetStart < end - start) {
14551        end = target.length - targetStart + start;
14552      }
14553      const len2 = end - start;
14554      if (this === target && typeof GlobalUint8Array.prototype.copyWithin === "function") {
14555        this.copyWithin(targetStart, start, end);
14556      } else {
14557        GlobalUint8Array.prototype.set.call(
14558          target,
14559          this.subarray(start, end),
14560          targetStart
14561        );
14562      }
14563      return len2;
14564    };
14565    Buffer2.prototype.fill = function fill(val, start, end, encoding) {
14566      if (typeof val === "string") {
14567        if (typeof start === "string") {
14568          encoding = start;
14569          start = 0;
14570          end = this.length;
14571        } else if (typeof end === "string") {
14572          encoding = end;
14573          end = this.length;
14574        }
14575        if (encoding !== void 0 && typeof encoding !== "string") {
14576          throw new TypeError("encoding must be a string");
14577        }
14578        if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
14579          throw new TypeError("Unknown encoding: " + encoding);
14580        }
14581        if (val.length === 1) {
14582          const code2 = val.charCodeAt(0);
14583          if (encoding === "utf8" && code2 < 128 || encoding === "latin1") {
14584            val = code2;
14585          }
14586        }
14587      } else if (typeof val === "number") {
14588        val = val & 255;
14589      } else if (typeof val === "boolean") {
14590        val = Number(val);
14591      }
14592      if (start < 0 || this.length < start || this.length < end) {
14593        throw new RangeError("Out of range index");
14594      }
14595      if (end <= start) {
14596        return this;
14597      }
14598      start = start >>> 0;
14599      end = end === void 0 ? this.length : end >>> 0;
14600      if (!val) val = 0;
14601      let i2;
14602      if (typeof val === "number") {
14603        for (i2 = start; i2 < end; ++i2) {
14604          this[i2] = val;
14605        }
14606      } else {
14607        const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
14608        const len2 = bytes.length;
14609        if (len2 === 0) {
14610          throw new TypeError('The value "' + val + '" is invalid for argument "value"');
14611        }
14612        for (i2 = 0; i2 < end - start; ++i2) {
14613          this[i2 + start] = bytes[i2 % len2];
14614        }
14615      }
14616      return this;
14617    };
14618    const errors2 = {};
14619    function E(sym, getMessage, Base) {
14620      errors2[sym] = class NodeError extends Base {
14621        constructor() {
14622          super();
14623          Object.defineProperty(this, "message", {
14624            value: getMessage.apply(this, arguments),
14625            writable: true,
14626            configurable: true
14627          });
14628          this.name = `${this.name} [${sym}]`;
14629          this.stack;
14630          delete this.name;
14631        }
14632        get code() {
14633          return sym;
14634        }
14635        set code(value) {
14636          Object.defineProperty(this, "code", {
14637            configurable: true,
14638            enumerable: true,
14639            value,
14640            writable: true
14641          });
14642        }
14643        toString() {
14644          return `${this.name} [${sym}]: ${this.message}`;
14645        }
14646      };
14647    }
14648    E(
14649      "ERR_BUFFER_OUT_OF_BOUNDS",
14650      function(name) {
14651        if (name) {
14652          return `${name} is outside of buffer bounds`;
14653        }
14654        return "Attempt to access memory outside buffer bounds";
14655      },
14656      RangeError
14657    );
14658    E(
14659      "ERR_INVALID_ARG_TYPE",
14660      function(name, actual) {
14661        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
14662      },
14663      TypeError
14664    );
14665    E(
14666      "ERR_OUT_OF_RANGE",
14667      function(str, range2, input) {
14668        let msg = `The value of "${str}" is out of range.`;
14669        let received = input;
14670        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
14671          received = addNumericalSeparator(String(input));
14672        } else if (typeof input === "bigint") {
14673          received = String(input);
14674          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
14675            received = addNumericalSeparator(received);
14676          }
14677          received += "n";
14678        }
14679        msg += ` It must be ${range2}. Received ${received}`;
14680        return msg;
14681      },
14682      RangeError
14683    );
14684    function addNumericalSeparator(val) {
14685      let res = "";
14686      let i2 = val.length;
14687      const start = val[0] === "-" ? 1 : 0;
14688      for (; i2 >= start + 4; i2 -= 3) {
14689        res = `_${val.slice(i2 - 3, i2)}${res}`;
14690      }
14691      return `${val.slice(0, i2)}${res}`;
14692    }
14693    function checkBounds(buf, offset, byteLength3) {
14694      validateNumber(offset, "offset");
14695      if (buf[offset] === void 0 || buf[offset + byteLength3] === void 0) {
14696        boundsError(offset, buf.length - (byteLength3 + 1));
14697      }
14698    }
14699    function checkIntBI(value, min2, max2, buf, offset, byteLength3) {
14700      if (value > max2 || value < min2) {
14701        const n = typeof min2 === "bigint" ? "n" : "";
14702        let range2;
14703        {
14704          if (min2 === 0 || min2 === BigInt(0)) {
14705            range2 = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
14706          } else {
14707            range2 = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
14708          }
14709        }
14710        throw new errors2.ERR_OUT_OF_RANGE("value", range2, value);
14711      }
14712      checkBounds(buf, offset, byteLength3);
14713    }
14714    function validateNumber(value, name) {
14715      if (typeof value !== "number") {
14716        throw new errors2.ERR_INVALID_ARG_TYPE(name, "number", value);
14717      }
14718    }
14719    function boundsError(value, length, type2) {
14720      if (Math.floor(value) !== value) {
14721        validateNumber(value, type2);
14722        throw new errors2.ERR_OUT_OF_RANGE("offset", "an integer", value);
14723      }
14724      if (length < 0) {
14725        throw new errors2.ERR_BUFFER_OUT_OF_BOUNDS();
14726      }
14727      throw new errors2.ERR_OUT_OF_RANGE(
14728        "offset",
14729        `>= ${0} and <= ${length}`,
14730        value
14731      );
14732    }
14733    const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
14734    function base64clean(str) {
14735      str = str.split("=")[0];
14736      str = str.trim().replace(INVALID_BASE64_RE, "");
14737      if (str.length < 2) return "";
14738      while (str.length % 4 !== 0) {
14739        str = str + "=";
14740      }
14741      return str;
14742    }
14743    function utf8ToBytes(string, units) {
14744      units = units || Infinity;
14745      let codePoint;
14746      const length = string.length;
14747      let leadSurrogate = null;
14748      const bytes = [];
14749      for (let i2 = 0; i2 < length; ++i2) {
14750        codePoint = string.charCodeAt(i2);
14751        if (codePoint > 55295 && codePoint < 57344) {
14752          if (!leadSurrogate) {
14753            if (codePoint > 56319) {
14754              if ((units -= 3) > -1) bytes.push(239, 191, 189);
14755              continue;
14756            }

vendor: 5,360 bytes, lines 14756-14937

14756 else if (i2 + 1 === length) {
14757              if ((units -= 3) > -1) bytes.push(239, 191, 189);
14758              continue;
14759            }
14760            leadSurrogate = codePoint;
14761            continue;
14762          }
14763          if (codePoint < 56320) {
14764            if ((units -= 3) > -1) bytes.push(239, 191, 189);
14765            leadSurrogate = codePoint;
14766            continue;
14767          }
14768          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
14769        } else if (leadSurrogate) {
14770          if ((units -= 3) > -1) bytes.push(239, 191, 189);
14771        }
14772        leadSurrogate = null;
14773        if (codePoint < 128) {
14774          if ((units -= 1) < 0) break;
14775          bytes.push(codePoint);
14776        } else if (codePoint < 2048) {
14777          if ((units -= 2) < 0) break;
14778          bytes.push(
14779            codePoint >> 6 | 192,
14780            codePoint & 63 | 128
14781          );
14782        } else if (codePoint < 65536) {
14783          if ((units -= 3) < 0) break;
14784          bytes.push(
14785            codePoint >> 12 | 224,
14786            codePoint >> 6 & 63 | 128,
14787            codePoint & 63 | 128
14788          );
14789        } else if (codePoint < 1114112) {
14790          if ((units -= 4) < 0) break;
14791          bytes.push(
14792            codePoint >> 18 | 240,
14793            codePoint >> 12 & 63 | 128,
14794            codePoint >> 6 & 63 | 128,
14795            codePoint & 63 | 128
14796          );
14797        } else {
14798          throw new Error("Invalid code point");
14799        }
14800      }
14801      return bytes;
14802    }
14803    function asciiToBytes(str) {
14804      const byteArray = [];
14805      for (let i2 = 0; i2 < str.length; ++i2) {
14806        byteArray.push(str.charCodeAt(i2) & 255);
14807      }
14808      return byteArray;
14809    }
14810    function utf16leToBytes(str, units) {
14811      let c, hi, lo;
14812      const byteArray = [];
14813      for (let i2 = 0; i2 < str.length; ++i2) {
14814        if ((units -= 2) < 0) break;
14815        c = str.charCodeAt(i2);
14816        hi = c >> 8;
14817        lo = c % 256;
14818        byteArray.push(lo);
14819        byteArray.push(hi);
14820      }
14821      return byteArray;
14822    }
14823    function base64ToBytes(str) {
14824      return base64.toByteArray(base64clean(str));
14825    }
14826    function blitBuffer(src2, dst, offset, length) {
14827      let i2;
14828      for (i2 = 0; i2 < length; ++i2) {
14829        if (i2 + offset >= dst.length || i2 >= src2.length) break;
14830        dst[i2 + offset] = src2[i2];
14831      }
14832      return i2;
14833    }
14834    function isInstance(obj, type2) {
14835      return obj instanceof type2 || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type2.name;
14836    }
14837    function numberIsNaN(obj) {
14838      return obj !== obj;
14839    }
14840    const hexSliceLookupTable = (function() {
14841      const alphabet = "0123456789abcdef";
14842      const table = new Array(256);
14843      for (let i2 = 0; i2 < 16; ++i2) {
14844        const i16 = i2 * 16;
14845        for (let j = 0; j < 16; ++j) {
14846          table[i16 + j] = alphabet[i2] + alphabet[j];
14847        }
14848      }
14849      return table;
14850    })();
14851    function defineBigIntMethod(fn) {
14852      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
14853    }
14854    function BufferBigIntNotDefined() {
14855      throw new Error("BigInt not supported");
14856    }
14857  })(buffer$1);
14858  const Buffer = buffer$1.Buffer;
14859  const ignoreDuplicateOf = utils$5.toObjectSet([
14860    "age",
14861    "authorization",
14862    "content-length",
14863    "content-type",
14864    "etag",
14865    "expires",
14866    "from",
14867    "host",
14868    "if-modified-since",
14869    "if-unmodified-since",
14870    "last-modified",
14871    "location",
14872    "max-forwards",
14873    "proxy-authorization",
14874    "referer",
14875    "retry-after",
14876    "user-agent"
14877  ]);
14878  const parseHeaders = (rawHeaders) => {
14879    const parsed = {};
14880    let key2;
14881    let val;
14882    let i2;
14883    rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
14884      i2 = line.indexOf(":");
14885      key2 = line.substring(0, i2).trim().toLowerCase();
14886      val = line.substring(i2 + 1).trim();
14887      if (!key2 || parsed[key2] && ignoreDuplicateOf[key2]) {
14888        return;
14889      }
14890      if (key2 === "set-cookie") {
14891        if (parsed[key2]) {
14892          parsed[key2].push(val);
14893        } else {
14894          parsed[key2] = [val];
14895        }
14896      } else {
14897        parsed[key2] = parsed[key2] ? parsed[key2] + ", " + val : val;
14898      }
14899    });
14900    return parsed;
14901  };
14902  const $internals = Symbol("internals");
14903  const INVALID_HEADER_VALUE_CHARS_RE = /[^\x09\x20-\x7E\x80-\xFF]/g;
14904  function trimSPorHTAB(str) {
14905    let start = 0;
14906    let end = str.length;
14907    while (start < end) {
14908      const code2 = str.charCodeAt(start);
14909      if (code2 !== 9 && code2 !== 32) {
14910        break;
14911      }
14912      start += 1;
14913    }
14914    while (end > start) {
14915      const code2 = str.charCodeAt(end - 1);
14916      if (code2 !== 9 && code2 !== 32) {
14917        break;
14918      }
14919      end -= 1;
14920    }
14921    return start === 0 && end === str.length ? str : str.slice(start, end);
14922  }
14923  function normalizeHeader(header) {
14924    return header && String(header).trim().toLowerCase();
14925  }
14926  function sanitizeHeaderValue(str) {
14927    return trimSPorHTAB(str.replace(INVALID_HEADER_VALUE_CHARS_RE, ""));
14928  }
14929  function normalizeValue(value) {
14930    if (value === false || value == null) {
14931      return value;
14932    }
14933    return utils$5.isArray(value) ? value.map(normalizeValue) : sanitizeHeaderValue(String(value));
14934  }
14935  function parseTokens(str) {
14936    const tokens = /* @__PURE__ */ Object.create(null);
14937    const tokensRE = /([^\s,;

vendor: 4,162 bytes, lines 14937-15049

14937=]+)\s*(?:=\s*([^,;]+))?/g;
14938    let match;
14939    while (match = tokensRE.exec(str)) {
14940      tokens[match[1]] = match[2];
14941    }
14942    return tokens;
14943  }
14944  const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
14945  function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
14946    if (utils$5.isFunction(filter)) {
14947      return filter.call(this, value, header);
14948    }
14949    if (isHeaderNameFilter) {
14950      value = header;
14951    }
14952    if (!utils$5.isString(value)) return;
14953    if (utils$5.isString(filter)) {
14954      return value.indexOf(filter) !== -1;
14955    }
14956    if (utils$5.isRegExp(filter)) {
14957      return filter.test(value);
14958    }
14959  }
14960  function formatHeader(header) {
14961    return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
14962      return char.toUpperCase() + str;
14963    });
14964  }
14965  function buildAccessors(obj, header) {
14966    const accessorName = utils$5.toCamelCase(" " + header);
14967    ["get", "set", "has"].forEach((methodName) => {
14968      Object.defineProperty(obj, methodName + accessorName, {
14969        // Null-proto descriptor so a polluted Object.prototype.get cannot turn
14970        // this data descriptor into an accessor descriptor on the way in.
14971        __proto__: null,
14972        value: function(arg1, arg2, arg3) {
14973          return this[methodName].call(this, header, arg1, arg2, arg3);
14974        },
14975        configurable: true
14976      });
14977    });
14978  }
14979  let AxiosHeaders$1 = class AxiosHeaders {
14980    constructor(headers) {
14981      headers && this.set(headers);
14982    }
14983    set(header, valueOrRewrite, rewrite) {
14984      const self2 = this;
14985      function setHeader(_value, _header, _rewrite) {
14986        const lHeader = normalizeHeader(_header);
14987        if (!lHeader) {
14988          throw new Error("header name must be a non-empty string");
14989        }
14990        const key2 = utils$5.findKey(self2, lHeader);
14991        if (!key2 || self2[key2] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key2] !== false) {
14992          self2[key2 || _header] = normalizeValue(_value);
14993        }
14994      }
14995      const setHeaders = (headers, _rewrite) => utils$5.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
14996      if (utils$5.isPlainObject(header) || header instanceof this.constructor) {
14997        setHeaders(header, valueOrRewrite);
14998      } else if (utils$5.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
14999        setHeaders(parseHeaders(header), valueOrRewrite);
15000      } else if (utils$5.isObject(header) && utils$5.isIterable(header)) {
15001        let obj = {}, dest, key2;
15002        for (const entry of header) {
15003          if (!utils$5.isArray(entry)) {
15004            throw TypeError("Object iterator must return a key-value pair");
15005          }
15006          obj[key2 = entry[0]] = (dest = obj[key2]) ? utils$5.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
15007        }
15008        setHeaders(obj, valueOrRewrite);
15009      } else {
15010        header != null && setHeader(valueOrRewrite, header, rewrite);
15011      }
15012      return this;
15013    }
15014    get(header, parser) {
15015      header = normalizeHeader(header);
15016      if (header) {
15017        const key2 = utils$5.findKey(this, header);
15018        if (key2) {
15019          const value = this[key2];
15020          if (!parser) {
15021            return value;
15022          }
15023          if (parser === true) {
15024            return parseTokens(value);
15025          }
15026          if (utils$5.isFunction(parser)) {
15027            return parser.call(this, value, key2);
15028          }
15029          if (utils$5.isRegExp(parser)) {
15030            return parser.exec(value);
15031          }
15032          throw new TypeError("parser must be boolean|regexp|function");
15033        }
15034      }
15035    }
15036    has(header, matcher) {
15037      header = normalizeHeader(header);
15038      if (header) {
15039        const key2 = utils$5.findKey(this, header);
15040        return !!(key2 && this[key2] !== void 0 && (!matcher || matchHeaderValue(this, this[key2], key2, matcher)));
15041      }
15042      return false;
15043    }
15044    delete(header, matcher) {
15045      const self2 = this;
15046      let deleted = false;
15047      function deleteHeader(_header) {
15048        _header = normalizeHeader(_header);
15049        if (_header) {

vendor: 5,054 bytes, lines 15050-15212

15050          const key2 = utils$5.findKey(self2, _header);
15051          if (key2 && (!matcher || matchHeaderValue(self2, self2[key2], key2, matcher))) {
15052            delete self2[key2];
15053            deleted = true;
15054          }
15055        }
15056      }
15057      if (utils$5.isArray(header)) {
15058        header.forEach(deleteHeader);
15059      } else {
15060        deleteHeader(header);
15061      }
15062      return deleted;
15063    }
15064    clear(matcher) {
15065      const keys = Object.keys(this);
15066      let i2 = keys.length;
15067      let deleted = false;
15068      while (i2--) {
15069        const key2 = keys[i2];
15070        if (!matcher || matchHeaderValue(this, this[key2], key2, matcher, true)) {
15071          delete this[key2];
15072          deleted = true;
15073        }
15074      }
15075      return deleted;
15076    }
15077    normalize(format) {
15078      const self2 = this;
15079      const headers = {};
15080      utils$5.forEach(this, (value, header) => {
15081        const key2 = utils$5.findKey(headers, header);
15082        if (key2) {
15083          self2[key2] = normalizeValue(value);
15084          delete self2[header];
15085          return;
15086        }
15087        const normalized = format ? formatHeader(header) : String(header).trim();
15088        if (normalized !== header) {
15089          delete self2[header];
15090        }
15091        self2[normalized] = normalizeValue(value);
15092        headers[normalized] = true;
15093      });
15094      return this;
15095    }
15096    concat(...targets) {
15097      return this.constructor.concat(this, ...targets);
15098    }
15099    toJSON(asStrings) {
15100      const obj = /* @__PURE__ */ Object.create(null);
15101      utils$5.forEach(this, (value, header) => {
15102        value != null && value !== false && (obj[header] = asStrings && utils$5.isArray(value) ? value.join(", ") : value);
15103      });
15104      return obj;
15105    }
15106    [Symbol.iterator]() {
15107      return Object.entries(this.toJSON())[Symbol.iterator]();
15108    }
15109    toString() {
15110      return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
15111    }
15112    getSetCookie() {
15113      return this.get("set-cookie") || [];
15114    }
15115    get [Symbol.toStringTag]() {
15116      return "AxiosHeaders";
15117    }
15118    static from(thing) {
15119      return thing instanceof this ? thing : new this(thing);
15120    }
15121    static concat(first, ...targets) {
15122      const computed = new this(first);
15123      targets.forEach((target) => computed.set(target));
15124      return computed;
15125    }
15126    static accessor(header) {
15127      const internals = this[$internals] = this[$internals] = {
15128        accessors: {}
15129      };
15130      const accessors = internals.accessors;
15131      const prototype2 = this.prototype;
15132      function defineAccessor(_header) {
15133        const lHeader = normalizeHeader(_header);
15134        if (!accessors[lHeader]) {
15135          buildAccessors(prototype2, _header);
15136          accessors[lHeader] = true;
15137        }
15138      }
15139      utils$5.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
15140      return this;
15141    }
15142  };
15143  AxiosHeaders$1.accessor([
15144    "Content-Type",
15145    "Content-Length",
15146    "Accept",
15147    "Accept-Encoding",
15148    "User-Agent",
15149    "Authorization"
15150  ]);
15151  utils$5.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key2) => {
15152    let mapped = key2[0].toUpperCase() + key2.slice(1);
15153    return {
15154      get: () => value,
15155      set(headerValue) {
15156        this[mapped] = headerValue;
15157      }
15158    };
15159  });
15160  utils$5.freezeMethods(AxiosHeaders$1);
15161  const REDACTED = "[REDACTED ****]";
15162  function hasOwnOrPrototypeToJSON(source) {
15163    if (utils$5.hasOwnProp(source, "toJSON")) {
15164      return true;
15165    }
15166    let prototype2 = Object.getPrototypeOf(source);
15167    while (prototype2 && prototype2 !== Object.prototype) {
15168      if (utils$5.hasOwnProp(prototype2, "toJSON")) {
15169        return true;
15170      }
15171      prototype2 = Object.getPrototypeOf(prototype2);
15172    }
15173    return false;
15174  }
15175  function redactConfig(config, redactKeys) {
15176    const lowerKeys = new Set(redactKeys.map((k) => String(k).toLowerCase()));
15177    const seen = [];
15178    const visit = (source) => {
15179      if (source === null || typeof source !== "object") return source;
15180      if (utils$5.isBuffer(source)) return source;
15181      if (seen.indexOf(source) !== -1) return void 0;
15182      if (source instanceof AxiosHeaders$1) {
15183        source = source.toJSON();
15184      }
15185      seen.push(source);
15186      let result;
15187      if (utils$5.isArray(source)) {
15188        result = [];
15189        source.forEach((v, i2) => {
15190          const reducedValue = visit(v);
15191          if (!utils$5.isUndefined(reducedValue)) {
15192            result[i2] = reducedValue;
15193          }
15194        });
15195      } else {
15196        if (!utils$5.isPlainObject(source) && hasOwnOrPrototypeToJSON(source)) {
15197          seen.pop();
15198          return source;
15199        }
15200        result = /* @__PURE__ */ Object.create(null);
15201        for (const [key2, value] of Object.entries(source)) {
15202          const reducedValue = lowerKeys.has(key2.toLowerCase()) ? REDACTED : visit(value);
15203          if (!utils$5.isUndefined(reducedValue)) {
15204            result[key2] = reducedValue;
15205          }
15206        }
15207      }
15208      seen.pop();
15209      return result;
15210    };
15211    return visit(config);
15212  }

vendor: 4,149 bytes, lines 15213-15325

15213  let AxiosError$1 = class AxiosError2 extends Error {
15214    static from(error, code2, config, request2, response2, customProps) {
15215      const axiosError = new AxiosError2(error.message, code2 || error.code, config, request2, response2);
15216      axiosError.cause = error;
15217      axiosError.name = error.name;
15218      if (error.status != null && axiosError.status == null) {
15219        axiosError.status = error.status;
15220      }
15221      customProps && Object.assign(axiosError, customProps);
15222      return axiosError;
15223    }
15224    /**
15225     * Create an Error with the specified message, config, error code, request and response.
15226     *
15227     * @param {string} message The error message.
15228     * @param {string} [code] The error code (for example, 'ECONNABORTED').
15229     * @param {Object} [config] The config.
15230     * @param {Object} [request] The request.
15231     * @param {Object} [response] The response.
15232     *
15233     * @returns {Error} The created error.
15234     */
15235    constructor(message, code2, config, request2, response2) {
15236      super(message);
15237      Object.defineProperty(this, "message", {
15238        // Null-proto descriptor so a polluted Object.prototype.get cannot turn
15239        // this data descriptor into an accessor descriptor on the way in.
15240        __proto__: null,
15241        value: message,
15242        enumerable: true,
15243        writable: true,
15244        configurable: true
15245      });
15246      this.name = "AxiosError";
15247      this.isAxiosError = true;
15248      code2 && (this.code = code2);
15249      config && (this.config = config);
15250      request2 && (this.request = request2);
15251      if (response2) {
15252        this.response = response2;
15253        this.status = response2.status;
15254      }
15255    }
15256    toJSON() {
15257      const config = this.config;
15258      const redactKeys = config && utils$5.hasOwnProp(config, "redact") ? config.redact : void 0;
15259      const serializedConfig = utils$5.isArray(redactKeys) && redactKeys.length > 0 ? redactConfig(config, redactKeys) : utils$5.toJSONObject(config);
15260      return {
15261        // Standard
15262        message: this.message,
15263        name: this.name,
15264        // Microsoft
15265        description: this.description,
15266        number: this.number,
15267        // Mozilla
15268        fileName: this.fileName,
15269        lineNumber: this.lineNumber,
15270        columnNumber: this.columnNumber,
15271        stack: this.stack,
15272        // Axios
15273        config: serializedConfig,
15274        code: this.code,
15275        status: this.status
15276      };
15277    }
15278  };
15279  AxiosError$1.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
15280  AxiosError$1.ERR_BAD_OPTION = "ERR_BAD_OPTION";
15281  AxiosError$1.ECONNABORTED = "ECONNABORTED";
15282  AxiosError$1.ETIMEDOUT = "ETIMEDOUT";
15283  AxiosError$1.ECONNREFUSED = "ECONNREFUSED";
15284  AxiosError$1.ERR_NETWORK = "ERR_NETWORK";
15285  AxiosError$1.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
15286  AxiosError$1.ERR_DEPRECATED = "ERR_DEPRECATED";
15287  AxiosError$1.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
15288  AxiosError$1.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
15289  AxiosError$1.ERR_CANCELED = "ERR_CANCELED";
15290  AxiosError$1.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
15291  AxiosError$1.ERR_INVALID_URL = "ERR_INVALID_URL";
15292  AxiosError$1.ERR_FORM_DATA_DEPTH_EXCEEDED = "ERR_FORM_DATA_DEPTH_EXCEEDED";
15293  var util$2 = {};
15294  var types = {};
15295  var shams$1;
15296  var hasRequiredShams$1;
15297  function requireShams$1() {
15298    if (hasRequiredShams$1) return shams$1;
15299    hasRequiredShams$1 = 1;
15300    shams$1 = function hasSymbols2() {
15301      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
15302        return false;
15303      }
15304      if (typeof Symbol.iterator === "symbol") {
15305        return true;
15306      }
15307      var obj = {};
15308      var sym = Symbol("test");
15309      var symObj = Object(sym);
15310      if (typeof sym === "string") {
15311        return false;
15312      }
15313      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
15314        return false;
15315      }
15316      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
15317        return false;
15318      }
15319      var symVal = 42;
15320      obj[sym] = symVal;
15321      for (var _2 in obj) {
15322        return false;
15323      }
15324      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
15325        return false;

vendor: 4,464 bytes, lines 15326-15511

15326      }
15327      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
15328        return false;
15329      }
15330      var syms = Object.getOwnPropertySymbols(obj);
15331      if (syms.length !== 1 || syms[0] !== sym) {
15332        return false;
15333      }
15334      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
15335        return false;
15336      }
15337      if (typeof Object.getOwnPropertyDescriptor === "function") {
15338        var descriptor = (
15339          /** @type {PropertyDescriptor} */
15340          Object.getOwnPropertyDescriptor(obj, sym)
15341        );
15342        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
15343          return false;
15344        }
15345      }
15346      return true;
15347    };
15348    return shams$1;
15349  }
15350  var shams;
15351  var hasRequiredShams;
15352  function requireShams() {
15353    if (hasRequiredShams) return shams;
15354    hasRequiredShams = 1;
15355    var hasSymbols2 = requireShams$1();
15356    shams = function hasToStringTagShams() {
15357      return hasSymbols2() && !!Symbol.toStringTag;
15358    };
15359    return shams;
15360  }
15361  var esObjectAtoms;
15362  var hasRequiredEsObjectAtoms;
15363  function requireEsObjectAtoms() {
15364    if (hasRequiredEsObjectAtoms) return esObjectAtoms;
15365    hasRequiredEsObjectAtoms = 1;
15366    esObjectAtoms = Object;
15367    return esObjectAtoms;
15368  }
15369  var esErrors;
15370  var hasRequiredEsErrors;
15371  function requireEsErrors() {
15372    if (hasRequiredEsErrors) return esErrors;
15373    hasRequiredEsErrors = 1;
15374    esErrors = Error;
15375    return esErrors;
15376  }
15377  var _eval;
15378  var hasRequired_eval;
15379  function require_eval() {
15380    if (hasRequired_eval) return _eval;
15381    hasRequired_eval = 1;
15382    _eval = EvalError;
15383    return _eval;
15384  }
15385  var range;
15386  var hasRequiredRange;
15387  function requireRange() {
15388    if (hasRequiredRange) return range;
15389    hasRequiredRange = 1;
15390    range = RangeError;
15391    return range;
15392  }
15393  var ref;
15394  var hasRequiredRef;
15395  function requireRef() {
15396    if (hasRequiredRef) return ref;
15397    hasRequiredRef = 1;
15398    ref = ReferenceError;
15399    return ref;
15400  }
15401  var syntax;
15402  var hasRequiredSyntax;
15403  function requireSyntax() {
15404    if (hasRequiredSyntax) return syntax;
15405    hasRequiredSyntax = 1;
15406    syntax = SyntaxError;
15407    return syntax;
15408  }
15409  var type;
15410  var hasRequiredType;
15411  function requireType() {
15412    if (hasRequiredType) return type;
15413    hasRequiredType = 1;
15414    type = TypeError;
15415    return type;
15416  }
15417  var uri;
15418  var hasRequiredUri;
15419  function requireUri() {
15420    if (hasRequiredUri) return uri;
15421    hasRequiredUri = 1;
15422    uri = URIError;
15423    return uri;
15424  }
15425  var abs;
15426  var hasRequiredAbs;
15427  function requireAbs() {
15428    if (hasRequiredAbs) return abs;
15429    hasRequiredAbs = 1;
15430    abs = Math.abs;
15431    return abs;
15432  }
15433  var floor;
15434  var hasRequiredFloor;
15435  function requireFloor() {
15436    if (hasRequiredFloor) return floor;
15437    hasRequiredFloor = 1;
15438    floor = Math.floor;
15439    return floor;
15440  }
15441  var max;
15442  var hasRequiredMax;
15443  function requireMax() {
15444    if (hasRequiredMax) return max;
15445    hasRequiredMax = 1;
15446    max = Math.max;
15447    return max;
15448  }
15449  var min;
15450  var hasRequiredMin;
15451  function requireMin() {
15452    if (hasRequiredMin) return min;
15453    hasRequiredMin = 1;
15454    min = Math.min;
15455    return min;
15456  }
15457  var pow;
15458  var hasRequiredPow;
15459  function requirePow() {
15460    if (hasRequiredPow) return pow;
15461    hasRequiredPow = 1;
15462    pow = Math.pow;
15463    return pow;
15464  }
15465  var round;
15466  var hasRequiredRound;
15467  function requireRound() {
15468    if (hasRequiredRound) return round;
15469    hasRequiredRound = 1;
15470    round = Math.round;
15471    return round;
15472  }
15473  var _isNaN;
15474  var hasRequired_isNaN;
15475  function require_isNaN() {
15476    if (hasRequired_isNaN) return _isNaN;
15477    hasRequired_isNaN = 1;
15478    _isNaN = Number.isNaN || function isNaN2(a) {
15479      return a !== a;
15480    };
15481    return _isNaN;
15482  }
15483  var sign;
15484  var hasRequiredSign;
15485  function requireSign() {
15486    if (hasRequiredSign) return sign;
15487    hasRequiredSign = 1;
15488    var $isNaN = /* @__PURE__ */ require_isNaN();
15489    sign = function sign2(number) {
15490      if ($isNaN(number) || number === 0) {
15491        return number;
15492      }
15493      return number < 0 ? -1 : 1;
15494    };
15495    return sign;
15496  }
15497  var gOPD;
15498  var hasRequiredGOPD;
15499  function requireGOPD() {
15500    if (hasRequiredGOPD) return gOPD;
15501    hasRequiredGOPD = 1;
15502    gOPD = Object.getOwnPropertyDescriptor;
15503    return gOPD;
15504  }
15505  var gopd;
15506  var hasRequiredGopd;
15507  function requireGopd() {
15508    if (hasRequiredGopd) return gopd;
15509    hasRequiredGopd = 1;
15510    var $gOPD = /* @__PURE__ */ requireGOPD();
15511    if ($gOPD) {

vendor: 9,729 bytes, lines 15512-15800

15512      try {
15513        $gOPD([], "length");
15514      } catch (e) {
15515        $gOPD = null;
15516      }
15517    }
15518    gopd = $gOPD;
15519    return gopd;
15520  }
15521  var esDefineProperty;
15522  var hasRequiredEsDefineProperty;
15523  function requireEsDefineProperty() {
15524    if (hasRequiredEsDefineProperty) return esDefineProperty;
15525    hasRequiredEsDefineProperty = 1;
15526    var $defineProperty = Object.defineProperty || false;
15527    if ($defineProperty) {
15528      try {
15529        $defineProperty({}, "a", { value: 1 });
15530      } catch (e) {
15531        $defineProperty = false;
15532      }
15533    }
15534    esDefineProperty = $defineProperty;
15535    return esDefineProperty;
15536  }
15537  var hasSymbols;
15538  var hasRequiredHasSymbols;
15539  function requireHasSymbols() {
15540    if (hasRequiredHasSymbols) return hasSymbols;
15541    hasRequiredHasSymbols = 1;
15542    var origSymbol = typeof Symbol !== "undefined" && Symbol;
15543    var hasSymbolSham = requireShams$1();
15544    hasSymbols = function hasNativeSymbols() {
15545      if (typeof origSymbol !== "function") {
15546        return false;
15547      }
15548      if (typeof Symbol !== "function") {
15549        return false;
15550      }
15551      if (typeof origSymbol("foo") !== "symbol") {
15552        return false;
15553      }
15554      if (typeof Symbol("bar") !== "symbol") {
15555        return false;
15556      }
15557      return hasSymbolSham();
15558    };
15559    return hasSymbols;
15560  }
15561  var Reflect_getPrototypeOf;
15562  var hasRequiredReflect_getPrototypeOf;
15563  function requireReflect_getPrototypeOf() {
15564    if (hasRequiredReflect_getPrototypeOf) return Reflect_getPrototypeOf;
15565    hasRequiredReflect_getPrototypeOf = 1;
15566    Reflect_getPrototypeOf = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
15567    return Reflect_getPrototypeOf;
15568  }
15569  var Object_getPrototypeOf;
15570  var hasRequiredObject_getPrototypeOf;
15571  function requireObject_getPrototypeOf() {
15572    if (hasRequiredObject_getPrototypeOf) return Object_getPrototypeOf;
15573    hasRequiredObject_getPrototypeOf = 1;
15574    var $Object = /* @__PURE__ */ requireEsObjectAtoms();
15575    Object_getPrototypeOf = $Object.getPrototypeOf || null;
15576    return Object_getPrototypeOf;
15577  }
15578  var implementation$4;
15579  var hasRequiredImplementation$4;
15580  function requireImplementation$4() {
15581    if (hasRequiredImplementation$4) return implementation$4;
15582    hasRequiredImplementation$4 = 1;
15583    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
15584    var toStr = Object.prototype.toString;
15585    var max2 = Math.max;
15586    var funcType = "[object Function]";
15587    var concatty = function concatty2(a, b) {
15588      var arr = [];
15589      for (var i2 = 0; i2 < a.length; i2 += 1) {
15590        arr[i2] = a[i2];
15591      }
15592      for (var j = 0; j < b.length; j += 1) {
15593        arr[j + a.length] = b[j];
15594      }
15595      return arr;
15596    };
15597    var slicy = function slicy2(arrLike, offset) {
15598      var arr = [];
15599      for (var i2 = offset, j = 0; i2 < arrLike.length; i2 += 1, j += 1) {
15600        arr[j] = arrLike[i2];
15601      }
15602      return arr;
15603    };
15604    var joiny = function(arr, joiner) {
15605      var str = "";
15606      for (var i2 = 0; i2 < arr.length; i2 += 1) {
15607        str += arr[i2];
15608        if (i2 + 1 < arr.length) {
15609          str += joiner;
15610        }
15611      }
15612      return str;
15613    };
15614    implementation$4 = function bind2(that) {
15615      var target = this;
15616      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
15617        throw new TypeError(ERROR_MESSAGE + target);
15618      }
15619      var args = slicy(arguments, 1);
15620      var bound;
15621      var binder = function() {
15622        if (this instanceof bound) {
15623          var result = target.apply(
15624            this,
15625            concatty(args, arguments)
15626          );
15627          if (Object(result) === result) {
15628            return result;
15629          }
15630          return this;
15631        }
15632        return target.apply(
15633          that,
15634          concatty(args, arguments)
15635        );
15636      };
15637      var boundLength = max2(0, target.length - args.length);
15638      var boundArgs = [];
15639      for (var i2 = 0; i2 < boundLength; i2++) {
15640        boundArgs[i2] = "$" + i2;
15641      }
15642      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
15643      if (target.prototype) {
15644        var Empty = function Empty2() {
15645        };
15646        Empty.prototype = target.prototype;
15647        bound.prototype = new Empty();
15648        Empty.prototype = null;
15649      }
15650      return bound;
15651    };
15652    return implementation$4;
15653  }
15654  var functionBind;
15655  var hasRequiredFunctionBind;
15656  function requireFunctionBind() {
15657    if (hasRequiredFunctionBind) return functionBind;
15658    hasRequiredFunctionBind = 1;
15659    var implementation2 = requireImplementation$4();
15660    functionBind = Function.prototype.bind || implementation2;
15661    return functionBind;
15662  }
15663  var functionCall;
15664  var hasRequiredFunctionCall;
15665  function requireFunctionCall() {
15666    if (hasRequiredFunctionCall) return functionCall;
15667    hasRequiredFunctionCall = 1;
15668    functionCall = Function.prototype.call;
15669    return functionCall;
15670  }
15671  var functionApply;
15672  var hasRequiredFunctionApply;
15673  function requireFunctionApply() {
15674    if (hasRequiredFunctionApply) return functionApply;
15675    hasRequiredFunctionApply = 1;
15676    functionApply = Function.prototype.apply;
15677    return functionApply;
15678  }
15679  var reflectApply;
15680  var hasRequiredReflectApply;
15681  function requireReflectApply() {
15682    if (hasRequiredReflectApply) return reflectApply;
15683    hasRequiredReflectApply = 1;
15684    reflectApply = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
15685    return reflectApply;
15686  }
15687  var actualApply;
15688  var hasRequiredActualApply;
15689  function requireActualApply() {
15690    if (hasRequiredActualApply) return actualApply;
15691    hasRequiredActualApply = 1;
15692    var bind2 = requireFunctionBind();
15693    var $apply = requireFunctionApply();
15694    var $call = requireFunctionCall();
15695    var $reflectApply = requireReflectApply();
15696    actualApply = $reflectApply || bind2.call($call, $apply);
15697    return actualApply;
15698  }
15699  var callBindApplyHelpers;
15700  var hasRequiredCallBindApplyHelpers;
15701  function requireCallBindApplyHelpers() {
15702    if (hasRequiredCallBindApplyHelpers) return callBindApplyHelpers;
15703    hasRequiredCallBindApplyHelpers = 1;
15704    var bind2 = requireFunctionBind();
15705    var $TypeError = /* @__PURE__ */ requireType();
15706    var $call = requireFunctionCall();
15707    var $actualApply = requireActualApply();
15708    callBindApplyHelpers = function callBindBasic(args) {
15709      if (args.length < 1 || typeof args[0] !== "function") {
15710        throw new $TypeError("a function is required");
15711      }
15712      return $actualApply(bind2, $call, args);
15713    };
15714    return callBindApplyHelpers;
15715  }
15716  var get;
15717  var hasRequiredGet;
15718  function requireGet() {
15719    if (hasRequiredGet) return get;
15720    hasRequiredGet = 1;
15721    var callBind2 = requireCallBindApplyHelpers();
15722    var gOPD2 = /* @__PURE__ */ requireGopd();
15723    var hasProtoAccessor;
15724    try {
15725      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
15726      [].__proto__ === Array.prototype;
15727    } catch (e) {
15728      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
15729        throw e;
15730      }
15731    }
15732    var desc = !!hasProtoAccessor && gOPD2 && gOPD2(
15733      Object.prototype,
15734      /** @type {keyof typeof Object.prototype} */
15735      "__proto__"
15736    );
15737    var $Object = Object;
15738    var $getPrototypeOf = $Object.getPrototypeOf;
15739    get = desc && typeof desc.get === "function" ? callBind2([desc.get]) : typeof $getPrototypeOf === "function" ? (
15740      /** @type {import('./get')} */
15741      function getDunder(value) {
15742        return $getPrototypeOf(value == null ? value : $Object(value));
15743      }
15744    ) : false;
15745    return get;
15746  }
15747  var getProto;
15748  var hasRequiredGetProto;
15749  function requireGetProto() {
15750    if (hasRequiredGetProto) return getProto;
15751    hasRequiredGetProto = 1;
15752    var reflectGetProto = requireReflect_getPrototypeOf();
15753    var originalGetProto = requireObject_getPrototypeOf();
15754    var getDunderProto = /* @__PURE__ */ requireGet();
15755    getProto = reflectGetProto ? function getProto2(O) {
15756      return reflectGetProto(O);
15757    } : originalGetProto ? function getProto2(O) {
15758      if (!O || typeof O !== "object" && typeof O !== "function") {
15759        throw new TypeError("getProto: not an object");
15760      }
15761      return originalGetProto(O);
15762    } : getDunderProto ? function getProto2(O) {
15763      return getDunderProto(O);
15764    } : null;
15765    return getProto;
15766  }
15767  var hasown;
15768  var hasRequiredHasown;
15769  function requireHasown() {
15770    if (hasRequiredHasown) return hasown;
15771    hasRequiredHasown = 1;
15772    var call = Function.prototype.call;
15773    var $hasOwn = Object.prototype.hasOwnProperty;
15774    var bind2 = requireFunctionBind();
15775    hasown = bind2.call(call, $hasOwn);
15776    return hasown;
15777  }
15778  var getIntrinsic;
15779  var hasRequiredGetIntrinsic;
15780  function requireGetIntrinsic() {
15781    if (hasRequiredGetIntrinsic) return getIntrinsic;
15782    hasRequiredGetIntrinsic = 1;
15783    var undefined$1;
15784    var $Object = /* @__PURE__ */ requireEsObjectAtoms();
15785    var $Error = /* @__PURE__ */ requireEsErrors();
15786    var $EvalError = /* @__PURE__ */ require_eval();
15787    var $RangeError = /* @__PURE__ */ requireRange();
15788    var $ReferenceError = /* @__PURE__ */ requireRef();
15789    var $SyntaxError = /* @__PURE__ */ requireSyntax();
15790    var $TypeError = /* @__PURE__ */ requireType();
15791    var $URIError = /* @__PURE__ */ requireUri();
15792    var abs2 = /* @__PURE__ */ requireAbs();
15793    var floor2 = /* @__PURE__ */ requireFloor();
15794    var max2 = /* @__PURE__ */ requireMax();
15795    var min2 = /* @__PURE__ */ requireMin();
15796    var pow2 = /* @__PURE__ */ requirePow();
15797    var round2 = /* @__PURE__ */ requireRound();
15798    var sign2 = /* @__PURE__ */ requireSign();
15799    var $Function = Function;
15800    var getEvalledConstructor = function(expressionSyntax) {

vendor: 5,787 bytes, lines 15801-15915

15801      try {
15802        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
15803      } catch (e) {
15804      }
15805    };
15806    var $gOPD = /* @__PURE__ */ requireGopd();
15807    var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
15808    var throwTypeError = function() {
15809      throw new $TypeError();
15810    };
15811    var ThrowTypeError = $gOPD ? (function() {
15812      try {
15813        arguments.callee;
15814        return throwTypeError;
15815      } catch (calleeThrows) {
15816        try {
15817          return $gOPD(arguments, "callee").get;
15818        } catch (gOPDthrows) {
15819          return throwTypeError;
15820        }
15821      }
15822    })() : throwTypeError;
15823    var hasSymbols2 = requireHasSymbols()();
15824    var getProto2 = requireGetProto();
15825    var $ObjectGPO = requireObject_getPrototypeOf();
15826    var $ReflectGPO = requireReflect_getPrototypeOf();
15827    var $apply = requireFunctionApply();
15828    var $call = requireFunctionCall();
15829    var needsEval = {};
15830    var TypedArray = typeof Uint8Array === "undefined" || !getProto2 ? undefined$1 : getProto2(Uint8Array);
15831    var INTRINSICS = {
15832      __proto__: null,
15833      "%AggregateError%": typeof AggregateError === "undefined" ? undefined$1 : AggregateError,
15834      "%Array%": Array,
15835      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined$1 : ArrayBuffer,
15836      "%ArrayIteratorPrototype%": hasSymbols2 && getProto2 ? getProto2([][Symbol.iterator]()) : undefined$1,
15837      "%AsyncFromSyncIteratorPrototype%": undefined$1,
15838      "%AsyncFunction%": needsEval,
15839      "%AsyncGenerator%": needsEval,
15840      "%AsyncGeneratorFunction%": needsEval,
15841      "%AsyncIteratorPrototype%": needsEval,
15842      "%Atomics%": typeof Atomics === "undefined" ? undefined$1 : Atomics,
15843      "%BigInt%": typeof BigInt === "undefined" ? undefined$1 : BigInt,
15844      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined$1 : BigInt64Array,
15845      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined$1 : BigUint64Array,
15846      "%Boolean%": Boolean,
15847      "%DataView%": typeof DataView === "undefined" ? undefined$1 : DataView,
15848      "%Date%": Date,
15849      "%decodeURI%": decodeURI,
15850      "%decodeURIComponent%": decodeURIComponent,
15851      "%encodeURI%": encodeURI,
15852      "%encodeURIComponent%": encodeURIComponent,
15853      "%Error%": $Error,
15854      "%eval%": eval,
15855      // eslint-disable-line no-eval
15856      "%EvalError%": $EvalError,
15857      "%Float16Array%": typeof Float16Array === "undefined" ? undefined$1 : Float16Array,
15858      "%Float32Array%": typeof Float32Array === "undefined" ? undefined$1 : Float32Array,
15859      "%Float64Array%": typeof Float64Array === "undefined" ? undefined$1 : Float64Array,
15860      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined$1 : FinalizationRegistry,
15861      "%Function%": $Function,
15862      "%GeneratorFunction%": needsEval,
15863      "%Int8Array%": typeof Int8Array === "undefined" ? undefined$1 : Int8Array,
15864      "%Int16Array%": typeof Int16Array === "undefined" ? undefined$1 : Int16Array,
15865      "%Int32Array%": typeof Int32Array === "undefined" ? undefined$1 : Int32Array,
15866      "%isFinite%": isFinite,
15867      "%isNaN%": isNaN,
15868      "%IteratorPrototype%": hasSymbols2 && getProto2 ? getProto2(getProto2([][Symbol.iterator]())) : undefined$1,
15869      "%JSON%": typeof JSON === "object" ? JSON : undefined$1,
15870      "%Map%": typeof Map === "undefined" ? undefined$1 : Map,
15871      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols2 || !getProto2 ? undefined$1 : getProto2((/* @__PURE__ */ new Map())[Symbol.iterator]()),
15872      "%Math%": Math,
15873      "%Number%": Number,
15874      "%Object%": $Object,
15875      "%Object.getOwnPropertyDescriptor%": $gOPD,
15876      "%parseFloat%": parseFloat,
15877      "%parseInt%": parseInt,
15878      "%Promise%": typeof Promise === "undefined" ? undefined$1 : Promise,
15879      "%Proxy%": typeof Proxy === "undefined" ? undefined$1 : Proxy,
15880      "%RangeError%": $RangeError,
15881      "%ReferenceError%": $ReferenceError,
15882      "%Reflect%": typeof Reflect === "undefined" ? undefined$1 : Reflect,
15883      "%RegExp%": RegExp,
15884      "%Set%": typeof Set === "undefined" ? undefined$1 : Set,
15885      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols2 || !getProto2 ? undefined$1 : getProto2((/* @__PURE__ */ new Set())[Symbol.iterator]()),
15886      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined$1 : SharedArrayBuffer,
15887      "%String%": String,
15888      "%StringIteratorPrototype%": hasSymbols2 && getProto2 ? getProto2(""[Symbol.iterator]()) : undefined$1,
15889      "%Symbol%": hasSymbols2 ? Symbol : undefined$1,
15890      "%SyntaxError%": $SyntaxError,
15891      "%ThrowTypeError%": ThrowTypeError,
15892      "%TypedArray%": TypedArray,
15893      "%TypeError%": $TypeError,
15894      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array,
15895      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray,
15896      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array,
15897      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined$1 : Uint32Array,
15898      "%URIError%": $URIError,
15899      "%WeakMap%": typeof WeakMap === "undefined" ? undefined$1 : WeakMap,
15900      "%WeakRef%": typeof WeakRef === "undefined" ? undefined$1 : WeakRef,
15901      "%WeakSet%": typeof WeakSet === "undefined" ? undefined$1 : WeakSet,
15902      "%Function.prototype.call%": $call,
15903      "%Function.prototype.apply%": $apply,
15904      "%Object.defineProperty%": $defineProperty,
15905      "%Object.getPrototypeOf%": $ObjectGPO,
15906      "%Math.abs%": abs2,
15907      "%Math.floor%": floor2,
15908      "%Math.max%": max2,
15909      "%Math.min%": min2,
15910      "%Math.pow%": pow2,
15911      "%Math.round%": round2,
15912      "%Math.sign%": sign2,
15913      "%Reflect.getPrototypeOf%": $ReflectGPO
15914    };
15915    if (getProto2) {

vendor: 6,879 bytes, lines 15916-16060

15916      try {
15917        null.error;
15918      } catch (e) {
15919        var errorProto = getProto2(getProto2(e));
15920        INTRINSICS["%Error.prototype%"] = errorProto;
15921      }
15922    }
15923    var doEval = function doEval2(name) {
15924      var value;
15925      if (name === "%AsyncFunction%") {
15926        value = getEvalledConstructor("async function () {}");
15927      } else if (name === "%GeneratorFunction%") {
15928        value = getEvalledConstructor("function* () {}");
15929      } else if (name === "%AsyncGeneratorFunction%") {
15930        value = getEvalledConstructor("async function* () {}");
15931      } else if (name === "%AsyncGenerator%") {
15932        var fn = doEval2("%AsyncGeneratorFunction%");
15933        if (fn) {
15934          value = fn.prototype;
15935        }
15936      } else if (name === "%AsyncIteratorPrototype%") {
15937        var gen = doEval2("%AsyncGenerator%");
15938        if (gen && getProto2) {
15939          value = getProto2(gen.prototype);
15940        }
15941      }
15942      INTRINSICS[name] = value;
15943      return value;
15944    };
15945    var LEGACY_ALIASES = {
15946      __proto__: null,
15947      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
15948      "%ArrayPrototype%": ["Array", "prototype"],
15949      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
15950      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
15951      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
15952      "%ArrayProto_values%": ["Array", "prototype", "values"],
15953      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
15954      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
15955      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
15956      "%BooleanPrototype%": ["Boolean", "prototype"],
15957      "%DataViewPrototype%": ["DataView", "prototype"],
15958      "%DatePrototype%": ["Date", "prototype"],
15959      "%ErrorPrototype%": ["Error", "prototype"],
15960      "%EvalErrorPrototype%": ["EvalError", "prototype"],
15961      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
15962      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
15963      "%FunctionPrototype%": ["Function", "prototype"],
15964      "%Generator%": ["GeneratorFunction", "prototype"],
15965      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
15966      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
15967      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
15968      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
15969      "%JSONParse%": ["JSON", "parse"],
15970      "%JSONStringify%": ["JSON", "stringify"],
15971      "%MapPrototype%": ["Map", "prototype"],
15972      "%NumberPrototype%": ["Number", "prototype"],
15973      "%ObjectPrototype%": ["Object", "prototype"],
15974      "%ObjProto_toString%": ["Object", "prototype", "toString"],
15975      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
15976      "%PromisePrototype%": ["Promise", "prototype"],
15977      "%PromiseProto_then%": ["Promise", "prototype", "then"],
15978      "%Promise_all%": ["Promise", "all"],
15979      "%Promise_reject%": ["Promise", "reject"],
15980      "%Promise_resolve%": ["Promise", "resolve"],
15981      "%RangeErrorPrototype%": ["RangeError", "prototype"],
15982      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
15983      "%RegExpPrototype%": ["RegExp", "prototype"],
15984      "%SetPrototype%": ["Set", "prototype"],
15985      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
15986      "%StringPrototype%": ["String", "prototype"],
15987      "%SymbolPrototype%": ["Symbol", "prototype"],
15988      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
15989      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
15990      "%TypeErrorPrototype%": ["TypeError", "prototype"],
15991      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
15992      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
15993      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
15994      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
15995      "%URIErrorPrototype%": ["URIError", "prototype"],
15996      "%WeakMapPrototype%": ["WeakMap", "prototype"],
15997      "%WeakSetPrototype%": ["WeakSet", "prototype"]
15998    };
15999    var bind2 = requireFunctionBind();
16000    var hasOwn = /* @__PURE__ */ requireHasown();
16001    var $concat = bind2.call($call, Array.prototype.concat);
16002    var $spliceApply = bind2.call($apply, Array.prototype.splice);
16003    var $replace = bind2.call($call, String.prototype.replace);
16004    var $strSlice = bind2.call($call, String.prototype.slice);
16005    var $exec = bind2.call($call, RegExp.prototype.exec);
16006    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
16007    var reEscapeChar = /\\(\\)?/g;
16008    var stringToPath = function stringToPath2(string) {
16009      var first = $strSlice(string, 0, 1);
16010      var last = $strSlice(string, -1);
16011      if (first === "%" && last !== "%") {
16012        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
16013      } else if (last === "%" && first !== "%") {
16014        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
16015      }
16016      var result = [];
16017      $replace(string, rePropName, function(match, number, quote, subString) {
16018        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
16019      });
16020      return result;
16021    };
16022    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
16023      var intrinsicName = name;
16024      var alias;
16025      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
16026        alias = LEGACY_ALIASES[intrinsicName];
16027        intrinsicName = "%" + alias[0] + "%";
16028      }
16029      if (hasOwn(INTRINSICS, intrinsicName)) {
16030        var value = INTRINSICS[intrinsicName];
16031        if (value === needsEval) {
16032          value = doEval(intrinsicName);
16033        }
16034        if (typeof value === "undefined" && !allowMissing) {
16035          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
16036        }
16037        return {
16038          alias,
16039          name: intrinsicName,
16040          value
16041        };
16042      }
16043      throw new $SyntaxError("intrinsic " + name + " does not exist!");
16044    };
16045    getIntrinsic = function GetIntrinsic(name, allowMissing) {
16046      if (typeof name !== "string" || name.length === 0) {
16047        throw new $TypeError("intrinsic name must be a non-empty string");
16048      }
16049      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
16050        throw new $TypeError('"allowMissing" argument must be a boolean');
16051      }
16052      if ($exec(/^%?[^%]*%?$/, name) === null) {
16053        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
16054      }
16055      var parts = stringToPath(name);
16056      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
16057      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
16058      var intrinsicRealName = intrinsic.name;
16059      var value = intrinsic.value;
16060      var skipFurtherCaching = false;

vendor: 41,114 bytes, lines 16061-17195

16061      var alias = intrinsic.alias;
16062      if (alias) {
16063        intrinsicBaseName = alias[0];
16064        $spliceApply(parts, $concat([0, 1], alias));
16065      }
16066      for (var i2 = 1, isOwn = true; i2 < parts.length; i2 += 1) {
16067        var part = parts[i2];
16068        var first = $strSlice(part, 0, 1);
16069        var last = $strSlice(part, -1);
16070        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
16071          throw new $SyntaxError("property names with quotes must have matching quotes");
16072        }
16073        if (part === "constructor" || !isOwn) {
16074          skipFurtherCaching = true;
16075        }
16076        intrinsicBaseName += "." + part;
16077        intrinsicRealName = "%" + intrinsicBaseName + "%";
16078        if (hasOwn(INTRINSICS, intrinsicRealName)) {
16079          value = INTRINSICS[intrinsicRealName];
16080        } else if (value != null) {
16081          if (!(part in value)) {
16082            if (!allowMissing) {
16083              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
16084            }
16085            return void undefined$1;
16086          }
16087          if ($gOPD && i2 + 1 >= parts.length) {
16088            var desc = $gOPD(value, part);
16089            isOwn = !!desc;
16090            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
16091              value = desc.get;
16092            } else {
16093              value = value[part];
16094            }
16095          } else {
16096            isOwn = hasOwn(value, part);
16097            value = value[part];
16098          }
16099          if (isOwn && !skipFurtherCaching) {
16100            INTRINSICS[intrinsicRealName] = value;
16101          }
16102        }
16103      }
16104      return value;
16105    };
16106    return getIntrinsic;
16107  }
16108  var callBound$1;
16109  var hasRequiredCallBound$1;
16110  function requireCallBound$1() {
16111    if (hasRequiredCallBound$1) return callBound$1;
16112    hasRequiredCallBound$1 = 1;
16113    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
16114    var callBindBasic = requireCallBindApplyHelpers();
16115    var $indexOf = callBindBasic([GetIntrinsic("%String.prototype.indexOf%")]);
16116    callBound$1 = function callBoundIntrinsic(name, allowMissing) {
16117      var intrinsic = (
16118        /** @type {(this: unknown, ...args: unknown[]) => unknown} */
16119        GetIntrinsic(name, !!allowMissing)
16120      );
16121      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
16122        return callBindBasic(
16123          /** @type {const} */
16124          [intrinsic]
16125        );
16126      }
16127      return intrinsic;
16128    };
16129    return callBound$1;
16130  }
16131  var isArguments$1;
16132  var hasRequiredIsArguments$1;
16133  function requireIsArguments$1() {
16134    if (hasRequiredIsArguments$1) return isArguments$1;
16135    hasRequiredIsArguments$1 = 1;
16136    var hasToStringTag = requireShams()();
16137    var callBound2 = /* @__PURE__ */ requireCallBound$1();
16138    var $toString = callBound2("Object.prototype.toString");
16139    var isStandardArguments = function isArguments2(value) {
16140      if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) {
16141        return false;
16142      }
16143      return $toString(value) === "[object Arguments]";
16144    };
16145    var isLegacyArguments = function isArguments2(value) {
16146      if (isStandardArguments(value)) {
16147        return true;
16148      }
16149      return value !== null && typeof value === "object" && "length" in value && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && "callee" in value && $toString(value.callee) === "[object Function]";
16150    };
16151    var supportsStandardArguments = (function() {
16152      return isStandardArguments(arguments);
16153    })();
16154    isStandardArguments.isLegacyArguments = isLegacyArguments;
16155    isArguments$1 = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
16156    return isArguments$1;
16157  }
16158  var isRegex;
16159  var hasRequiredIsRegex;
16160  function requireIsRegex() {
16161    if (hasRequiredIsRegex) return isRegex;
16162    hasRequiredIsRegex = 1;
16163    var callBound2 = /* @__PURE__ */ requireCallBound$1();
16164    var hasToStringTag = requireShams()();
16165    var hasOwn = /* @__PURE__ */ requireHasown();
16166    var gOPD2 = /* @__PURE__ */ requireGopd();
16167    var fn;
16168    if (hasToStringTag) {
16169      var $exec = callBound2("RegExp.prototype.exec");
16170      var isRegexMarker = {};
16171      var throwRegexMarker = function() {
16172        throw isRegexMarker;
16173      };
16174      var badStringifier = {
16175        toString: throwRegexMarker,
16176        valueOf: throwRegexMarker
16177      };
16178      if (typeof Symbol.toPrimitive === "symbol") {
16179        badStringifier[Symbol.toPrimitive] = throwRegexMarker;
16180      }
16181      fn = function isRegex2(value) {
16182        if (!value || typeof value !== "object") {
16183          return false;
16184        }
16185        var descriptor = (
16186          /** @type {NonNullable<typeof gOPD>} */
16187          gOPD2(
16188            /** @type {{ lastIndex?: unknown }} */
16189            value,
16190            "lastIndex"
16191          )
16192        );
16193        var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, "value");
16194        if (!hasLastIndexDataProperty) {
16195          return false;
16196        }
16197        try {
16198          $exec(
16199            value,
16200            /** @type {string} */
16201            /** @type {unknown} */
16202            badStringifier
16203          );
16204        } catch (e) {
16205          return e === isRegexMarker;
16206        }
16207      };
16208    } else {
16209      var $toString = callBound2("Object.prototype.toString");
16210      var regexClass = "[object RegExp]";
16211      fn = function isRegex2(value) {
16212        if (!value || typeof value !== "object" && typeof value !== "function") {
16213          return false;
16214        }
16215        return $toString(value) === regexClass;
16216      };
16217    }
16218    isRegex = fn;
16219    return isRegex;
16220  }
16221  var safeRegexTest;
16222  var hasRequiredSafeRegexTest;
16223  function requireSafeRegexTest() {
16224    if (hasRequiredSafeRegexTest) return safeRegexTest;
16225    hasRequiredSafeRegexTest = 1;
16226    var callBound2 = /* @__PURE__ */ requireCallBound$1();
16227    var isRegex2 = requireIsRegex();
16228    var $exec = callBound2("RegExp.prototype.exec");
16229    var $TypeError = /* @__PURE__ */ requireType();
16230    safeRegexTest = function regexTester(regex) {
16231      if (!isRegex2(regex)) {
16232        throw new $TypeError("`regex` must be a RegExp");
16233      }
16234      return function test2(s) {
16235        return $exec(regex, s) !== null;
16236      };
16237    };
16238    return safeRegexTest;
16239  }
16240  var generatorFunction;
16241  var hasRequiredGeneratorFunction;
16242  function requireGeneratorFunction() {
16243    if (hasRequiredGeneratorFunction) return generatorFunction;
16244    hasRequiredGeneratorFunction = 1;
16245    const cached = (
16246      /** @type {GeneratorFunctionConstructor} */
16247      (function* () {
16248      }).constructor
16249    );
16250    generatorFunction = () => cached;
16251    return generatorFunction;
16252  }
16253  var isGeneratorFunction;
16254  var hasRequiredIsGeneratorFunction;
16255  function requireIsGeneratorFunction() {
16256    if (hasRequiredIsGeneratorFunction) return isGeneratorFunction;
16257    hasRequiredIsGeneratorFunction = 1;
16258    var callBound2 = /* @__PURE__ */ requireCallBound$1();
16259    var safeRegexTest2 = /* @__PURE__ */ requireSafeRegexTest();
16260    var isFnRegex = safeRegexTest2(/^\s*(?:function)?\*/);
16261    var hasToStringTag = requireShams()();
16262    var getProto2 = requireGetProto();
16263    var toStr = callBound2("Object.prototype.toString");
16264    var fnToStr = callBound2("Function.prototype.toString");
16265    var getGeneratorFunction = /* @__PURE__ */ requireGeneratorFunction();
16266    isGeneratorFunction = function isGeneratorFunction2(fn) {
16267      if (typeof fn !== "function") {
16268        return false;
16269      }
16270      if (isFnRegex(fnToStr(fn))) {
16271        return true;
16272      }
16273      if (!hasToStringTag) {
16274        var str = toStr(fn);
16275        return str === "[object GeneratorFunction]";
16276      }
16277      if (!getProto2) {
16278        return false;
16279      }
16280      var GeneratorFunction = getGeneratorFunction();
16281      return GeneratorFunction && getProto2(fn) === GeneratorFunction.prototype;
16282    };
16283    return isGeneratorFunction;
16284  }
16285  var isCallable;
16286  var hasRequiredIsCallable;
16287  function requireIsCallable() {
16288    if (hasRequiredIsCallable) return isCallable;
16289    hasRequiredIsCallable = 1;
16290    var fnToStr = Function.prototype.toString;
16291    var reflectApply2 = typeof Reflect === "object" && Reflect !== null && Reflect.apply;
16292    var badArrayLike;
16293    var isCallableMarker;
16294    if (typeof reflectApply2 === "function" && typeof Object.defineProperty === "function") {
16295      try {
16296        badArrayLike = Object.defineProperty({}, "length", {
16297          get: function() {
16298            throw isCallableMarker;
16299          }
16300        });
16301        isCallableMarker = {};
16302        reflectApply2(function() {
16303          throw 42;
16304        }, null, badArrayLike);
16305      } catch (_2) {
16306        if (_2 !== isCallableMarker) {
16307          reflectApply2 = null;
16308        }
16309      }
16310    } else {
16311      reflectApply2 = null;
16312    }
16313    var constructorRegex = /^\s*class\b/;
16314    var isES6ClassFn = function isES6ClassFunction(value) {
16315      try {
16316        var fnStr = fnToStr.call(value);
16317        return constructorRegex.test(fnStr);
16318      } catch (e) {
16319        return false;
16320      }
16321    };
16322    var tryFunctionObject = function tryFunctionToStr(value) {
16323      try {
16324        if (isES6ClassFn(value)) {
16325          return false;
16326        }
16327        fnToStr.call(value);
16328        return true;
16329      } catch (e) {
16330        return false;
16331      }
16332    };
16333    var toStr = Object.prototype.toString;
16334    var objectClass = "[object Object]";
16335    var fnClass = "[object Function]";
16336    var genClass = "[object GeneratorFunction]";
16337    var ddaClass = "[object HTMLAllCollection]";
16338    var ddaClass2 = "[object HTML document.all class]";
16339    var ddaClass3 = "[object HTMLCollection]";
16340    var hasToStringTag = typeof Symbol === "function" && !!Symbol.toStringTag;
16341    var isIE68 = !(0 in [,]);
16342    var isDDA = function isDocumentDotAll() {
16343      return false;
16344    };
16345    if (typeof document === "object") {
16346      var all2 = document.all;
16347      if (toStr.call(all2) === toStr.call(document.all)) {
16348        isDDA = function isDocumentDotAll(value) {
16349          if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
16350            try {
16351              var str = toStr.call(value);
16352              return (str === ddaClass || str === ddaClass2 || str === ddaClass3 || str === objectClass) && value("") == null;
16353            } catch (e) {
16354            }
16355          }
16356          return false;
16357        };
16358      }
16359    }
16360    isCallable = reflectApply2 ? function isCallable2(value) {
16361      if (isDDA(value)) {
16362        return true;
16363      }
16364      if (!value) {
16365        return false;
16366      }
16367      if (typeof value !== "function" && typeof value !== "object") {
16368        return false;
16369      }
16370      try {
16371        reflectApply2(value, null, badArrayLike);
16372      } catch (e) {
16373        if (e !== isCallableMarker) {
16374          return false;
16375        }
16376      }
16377      return !isES6ClassFn(value) && tryFunctionObject(value);
16378    } : function isCallable2(value) {
16379      if (isDDA(value)) {
16380        return true;
16381      }
16382      if (!value) {
16383        return false;
16384      }
16385      if (typeof value !== "function" && typeof value !== "object") {
16386        return false;
16387      }
16388      if (hasToStringTag) {
16389        return tryFunctionObject(value);
16390      }
16391      if (isES6ClassFn(value)) {
16392        return false;
16393      }
16394      var strClass = toStr.call(value);
16395      if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
16396        return false;
16397      }
16398      return tryFunctionObject(value);
16399    };
16400    return isCallable;
16401  }
16402  var forEach;
16403  var hasRequiredForEach;
16404  function requireForEach() {
16405    if (hasRequiredForEach) return forEach;
16406    hasRequiredForEach = 1;
16407    var isCallable2 = requireIsCallable();
16408    var toStr = Object.prototype.toString;
16409    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
16410    var forEachArray = function forEachArray2(array, iterator2, receiver) {
16411      for (var i2 = 0, len2 = array.length; i2 < len2; i2++) {
16412        if (hasOwnProperty2.call(array, i2)) {
16413          if (receiver == null) {
16414            iterator2(array[i2], i2, array);
16415          } else {
16416            iterator2.call(receiver, array[i2], i2, array);
16417          }
16418        }
16419      }
16420    };
16421    var forEachString = function forEachString2(string, iterator2, receiver) {
16422      for (var i2 = 0, len2 = string.length; i2 < len2; i2++) {
16423        if (receiver == null) {
16424          iterator2(string.charAt(i2), i2, string);
16425        } else {
16426          iterator2.call(receiver, string.charAt(i2), i2, string);
16427        }
16428      }
16429    };
16430    var forEachObject = function forEachObject2(object, iterator2, receiver) {
16431      for (var k in object) {
16432        if (hasOwnProperty2.call(object, k)) {
16433          if (receiver == null) {
16434            iterator2(object[k], k, object);
16435          } else {
16436            iterator2.call(receiver, object[k], k, object);
16437          }
16438        }
16439      }
16440    };
16441    function isArray2(x) {
16442      return toStr.call(x) === "[object Array]";
16443    }
16444    forEach = function forEach2(list, iterator2, thisArg) {
16445      if (!isCallable2(iterator2)) {
16446        throw new TypeError("iterator must be a function");
16447      }
16448      var receiver;
16449      if (arguments.length >= 3) {
16450        receiver = thisArg;
16451      }
16452      if (isArray2(list)) {
16453        forEachArray(list, iterator2, receiver);
16454      } else if (typeof list === "string") {
16455        forEachString(list, iterator2, receiver);
16456      } else {
16457        forEachObject(list, iterator2, receiver);
16458      }
16459    };
16460    return forEach;
16461  }
16462  var possibleTypedArrayNames;
16463  var hasRequiredPossibleTypedArrayNames;
16464  function requirePossibleTypedArrayNames() {
16465    if (hasRequiredPossibleTypedArrayNames) return possibleTypedArrayNames;
16466    hasRequiredPossibleTypedArrayNames = 1;
16467    possibleTypedArrayNames = [
16468      "Float16Array",
16469      "Float32Array",
16470      "Float64Array",
16471      "Int8Array",
16472      "Int16Array",
16473      "Int32Array",
16474      "Uint8Array",
16475      "Uint8ClampedArray",
16476      "Uint16Array",
16477      "Uint32Array",
16478      "BigInt64Array",
16479      "BigUint64Array"
16480    ];
16481    return possibleTypedArrayNames;
16482  }
16483  var availableTypedArrays;
16484  var hasRequiredAvailableTypedArrays;
16485  function requireAvailableTypedArrays() {
16486    if (hasRequiredAvailableTypedArrays) return availableTypedArrays;
16487    hasRequiredAvailableTypedArrays = 1;
16488    var possibleNames = /* @__PURE__ */ requirePossibleTypedArrayNames();
16489    var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
16490    availableTypedArrays = function availableTypedArrays2() {
16491      var out = [];
16492      for (var i2 = 0; i2 < possibleNames.length; i2++) {
16493        if (typeof g[possibleNames[i2]] === "function") {
16494          out[out.length] = possibleNames[i2];
16495        }
16496      }
16497      return out;
16498    };
16499    return availableTypedArrays;
16500  }
16501  var callBind = { exports: {} };
16502  var defineDataProperty;
16503  var hasRequiredDefineDataProperty;
16504  function requireDefineDataProperty() {
16505    if (hasRequiredDefineDataProperty) return defineDataProperty;
16506    hasRequiredDefineDataProperty = 1;
16507    var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
16508    var $SyntaxError = /* @__PURE__ */ requireSyntax();
16509    var $TypeError = /* @__PURE__ */ requireType();
16510    var gopd2 = /* @__PURE__ */ requireGopd();
16511    defineDataProperty = function defineDataProperty2(obj, property, value) {
16512      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
16513        throw new $TypeError("`obj` must be an object or a function`");
16514      }
16515      if (typeof property !== "string" && typeof property !== "symbol") {
16516        throw new $TypeError("`property` must be a string or a symbol`");
16517      }
16518      if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
16519        throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
16520      }
16521      if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
16522        throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
16523      }
16524      if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
16525        throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
16526      }
16527      if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
16528        throw new $TypeError("`loose`, if provided, must be a boolean");
16529      }
16530      var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
16531      var nonWritable = arguments.length > 4 ? arguments[4] : null;
16532      var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
16533      var loose = arguments.length > 6 ? arguments[6] : false;
16534      var desc = !!gopd2 && gopd2(obj, property);
16535      if ($defineProperty) {
16536        $defineProperty(obj, property, {
16537          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
16538          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
16539          value,
16540          writable: nonWritable === null && desc ? desc.writable : !nonWritable
16541        });
16542      } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
16543        obj[property] = value;
16544      } else {
16545        throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
16546      }
16547    };
16548    return defineDataProperty;
16549  }
16550  var hasPropertyDescriptors_1;
16551  var hasRequiredHasPropertyDescriptors;
16552  function requireHasPropertyDescriptors() {
16553    if (hasRequiredHasPropertyDescriptors) return hasPropertyDescriptors_1;
16554    hasRequiredHasPropertyDescriptors = 1;
16555    var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
16556    var hasPropertyDescriptors = function hasPropertyDescriptors2() {
16557      return !!$defineProperty;
16558    };
16559    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
16560      if (!$defineProperty) {
16561        return null;
16562      }
16563      try {
16564        return $defineProperty([], "length", { value: 1 }).length !== 1;
16565      } catch (e) {
16566        return true;
16567      }
16568    };
16569    hasPropertyDescriptors_1 = hasPropertyDescriptors;
16570    return hasPropertyDescriptors_1;
16571  }
16572  var setFunctionLength;
16573  var hasRequiredSetFunctionLength;
16574  function requireSetFunctionLength() {
16575    if (hasRequiredSetFunctionLength) return setFunctionLength;
16576    hasRequiredSetFunctionLength = 1;
16577    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
16578    var define = /* @__PURE__ */ requireDefineDataProperty();
16579    var hasDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()();
16580    var gOPD2 = /* @__PURE__ */ requireGopd();
16581    var $TypeError = /* @__PURE__ */ requireType();
16582    var $floor = GetIntrinsic("%Math.floor%");
16583    setFunctionLength = function setFunctionLength2(fn, length) {
16584      if (typeof fn !== "function") {
16585        throw new $TypeError("`fn` is not a function");
16586      }
16587      if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
16588        throw new $TypeError("`length` must be a positive 32-bit integer");
16589      }
16590      var loose = arguments.length > 2 && !!arguments[2];
16591      var functionLengthIsConfigurable = true;
16592      var functionLengthIsWritable = true;
16593      if ("length" in fn && gOPD2) {
16594        var desc = gOPD2(fn, "length");
16595        if (desc && !desc.configurable) {
16596          functionLengthIsConfigurable = false;
16597        }
16598        if (desc && !desc.writable) {
16599          functionLengthIsWritable = false;
16600        }
16601      }
16602      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
16603        if (hasDescriptors) {
16604          define(
16605            /** @type {Parameters<define>[0]} */
16606            fn,
16607            "length",
16608            length,
16609            true,
16610            true
16611          );
16612        } else {
16613          define(
16614            /** @type {Parameters<define>[0]} */
16615            fn,
16616            "length",
16617            length
16618          );
16619        }
16620      }
16621      return fn;
16622    };
16623    return setFunctionLength;
16624  }
16625  var applyBind;
16626  var hasRequiredApplyBind;
16627  function requireApplyBind() {
16628    if (hasRequiredApplyBind) return applyBind;
16629    hasRequiredApplyBind = 1;
16630    var bind2 = requireFunctionBind();
16631    var $apply = requireFunctionApply();
16632    var actualApply2 = requireActualApply();
16633    applyBind = function applyBind2() {
16634      return actualApply2(bind2, $apply, arguments);
16635    };
16636    return applyBind;
16637  }
16638  var hasRequiredCallBind;
16639  function requireCallBind() {
16640    if (hasRequiredCallBind) return callBind.exports;
16641    hasRequiredCallBind = 1;
16642    (function(module) {
16643      var setFunctionLength2 = /* @__PURE__ */ requireSetFunctionLength();
16644      var $defineProperty = /* @__PURE__ */ requireEsDefineProperty();
16645      var callBindBasic = requireCallBindApplyHelpers();
16646      var applyBind2 = requireApplyBind();
16647      module.exports = function callBind2(originalFunction) {
16648        var func = callBindBasic(arguments);
16649        var adjustedLength = 1 + originalFunction.length - (arguments.length - 1);
16650        return setFunctionLength2(
16651          func,
16652          adjustedLength > 0 ? adjustedLength : 0,
16653          true
16654        );
16655      };
16656      if ($defineProperty) {
16657        $defineProperty(module.exports, "apply", { value: applyBind2 });
16658      } else {
16659        module.exports.apply = applyBind2;
16660      }
16661    })(callBind);
16662    return callBind.exports;
16663  }
16664  var whichTypedArray;
16665  var hasRequiredWhichTypedArray;
16666  function requireWhichTypedArray() {
16667    if (hasRequiredWhichTypedArray) return whichTypedArray;
16668    hasRequiredWhichTypedArray = 1;
16669    var forEach2 = requireForEach();
16670    var availableTypedArrays2 = /* @__PURE__ */ requireAvailableTypedArrays();
16671    var callBind2 = requireCallBind();
16672    var callBound2 = /* @__PURE__ */ requireCallBound$1();
16673    var gOPD2 = /* @__PURE__ */ requireGopd();
16674    var getProto2 = requireGetProto();
16675    var $toString = callBound2("Object.prototype.toString");
16676    var hasToStringTag = requireShams()();
16677    var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
16678    var typedArrays = availableTypedArrays2();
16679    var $slice = callBound2("String.prototype.slice");
16680    var $indexOf = callBound2("Array.prototype.indexOf", true) || function indexOf2(array, value) {
16681      for (var i2 = 0; i2 < array.length; i2 += 1) {
16682        if (array[i2] === value) {
16683          return i2;
16684        }
16685      }
16686      return -1;
16687    };
16688    var cache2 = { __proto__: null };
16689    if (hasToStringTag && gOPD2 && getProto2) {
16690      forEach2(typedArrays, function(typedArray) {
16691        var arr = new g[typedArray]();
16692        if (Symbol.toStringTag in arr && getProto2) {
16693          var proto = getProto2(arr);
16694          var descriptor = gOPD2(proto, Symbol.toStringTag);
16695          if (!descriptor && proto) {
16696            var superProto = getProto2(proto);
16697            descriptor = gOPD2(superProto, Symbol.toStringTag);
16698          }
16699          if (descriptor && descriptor.get) {
16700            var bound = callBind2(descriptor.get);
16701            cache2[
16702              /** @type {`$${import('.').TypedArrayName}`} */
16703              "$" + typedArray
16704            ] = bound;
16705          }
16706        }
16707      });
16708    } else {
16709      forEach2(typedArrays, function(typedArray) {
16710        var arr = new g[typedArray]();
16711        var fn = arr.slice || arr.set;
16712        if (fn) {
16713          var bound = (
16714            /** @type {import('./types').BoundSlice | import('./types').BoundSet} */
16715            // @ts-expect-error TODO FIXME
16716            callBind2(fn)
16717          );
16718          cache2[
16719            /** @type {`$${import('.').TypedArrayName}`} */
16720            "$" + typedArray
16721          ] = bound;
16722        }
16723      });
16724    }
16725    var tryTypedArrays = function tryAllTypedArrays(value) {
16726      var found = false;
16727      forEach2(
16728        /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
16729        cache2,
16730        /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
16731        function(getter, typedArray) {
16732          if (!found) {
16733            try {
16734              if ("$" + getter(value) === typedArray) {
16735                found = /** @type {import('.').TypedArrayName} */
16736                $slice(typedArray, 1);
16737              }
16738            } catch (e) {
16739            }
16740          }
16741        }
16742      );
16743      return found;
16744    };
16745    var trySlices = function tryAllSlices(value) {
16746      var found = false;
16747      forEach2(
16748        /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */
16749        cache2,
16750        /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
16751        function(getter, name) {
16752          if (!found) {
16753            try {
16754              getter(value);
16755              found = /** @type {import('.').TypedArrayName} */
16756              $slice(name, 1);
16757            } catch (e) {
16758            }
16759          }
16760        }
16761      );
16762      return found;
16763    };
16764    whichTypedArray = function whichTypedArray2(value) {
16765      if (!value || typeof value !== "object") {
16766        return false;
16767      }
16768      if (!hasToStringTag) {
16769        var tag = $slice($toString(value), 8, -1);
16770        if ($indexOf(typedArrays, tag) > -1) {
16771          return tag;
16772        }
16773        if (tag !== "Object") {
16774          return false;
16775        }
16776        return trySlices(value);
16777      }
16778      if (!gOPD2) {
16779        return null;
16780      }
16781      return tryTypedArrays(value);
16782    };
16783    return whichTypedArray;
16784  }
16785  var isTypedArray;
16786  var hasRequiredIsTypedArray;
16787  function requireIsTypedArray() {
16788    if (hasRequiredIsTypedArray) return isTypedArray;
16789    hasRequiredIsTypedArray = 1;
16790    var whichTypedArray2 = /* @__PURE__ */ requireWhichTypedArray();
16791    isTypedArray = function isTypedArray2(value) {
16792      return !!whichTypedArray2(value);
16793    };
16794    return isTypedArray;
16795  }
16796  var hasRequiredTypes;
16797  function requireTypes() {
16798    if (hasRequiredTypes) return types;
16799    hasRequiredTypes = 1;
16800    (function(exports$12) {
16801      var isArgumentsObject = /* @__PURE__ */ requireIsArguments$1();
16802      var isGeneratorFunction2 = requireIsGeneratorFunction();
16803      var whichTypedArray2 = /* @__PURE__ */ requireWhichTypedArray();
16804      var isTypedArray2 = /* @__PURE__ */ requireIsTypedArray();
16805      function uncurryThis(f) {
16806        return f.call.bind(f);
16807      }
16808      var BigIntSupported = typeof BigInt !== "undefined";
16809      var SymbolSupported = typeof Symbol !== "undefined";
16810      var ObjectToString = uncurryThis(Object.prototype.toString);
16811      var numberValue = uncurryThis(Number.prototype.valueOf);
16812      var stringValue = uncurryThis(String.prototype.valueOf);
16813      var booleanValue = uncurryThis(Boolean.prototype.valueOf);
16814      if (BigIntSupported) {
16815        var bigIntValue = uncurryThis(BigInt.prototype.valueOf);
16816      }
16817      if (SymbolSupported) {
16818        var symbolValue = uncurryThis(Symbol.prototype.valueOf);
16819      }
16820      function checkBoxedPrimitive(value, prototypeValueOf) {
16821        if (typeof value !== "object") {
16822          return false;
16823        }
16824        try {
16825          prototypeValueOf(value);
16826          return true;
16827        } catch (e) {
16828          return false;
16829        }
16830      }
16831      exports$12.isArgumentsObject = isArgumentsObject;
16832      exports$12.isGeneratorFunction = isGeneratorFunction2;
16833      exports$12.isTypedArray = isTypedArray2;
16834      function isPromise(input) {
16835        return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
16836      }
16837      exports$12.isPromise = isPromise;
16838      function isArrayBufferView2(value) {
16839        if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
16840          return ArrayBuffer.isView(value);
16841        }
16842        return isTypedArray2(value) || isDataView(value);
16843      }
16844      exports$12.isArrayBufferView = isArrayBufferView2;
16845      function isUint8Array(value) {
16846        return whichTypedArray2(value) === "Uint8Array";
16847      }
16848      exports$12.isUint8Array = isUint8Array;
16849      function isUint8ClampedArray(value) {
16850        return whichTypedArray2(value) === "Uint8ClampedArray";
16851      }
16852      exports$12.isUint8ClampedArray = isUint8ClampedArray;
16853      function isUint16Array(value) {
16854        return whichTypedArray2(value) === "Uint16Array";
16855      }
16856      exports$12.isUint16Array = isUint16Array;
16857      function isUint32Array(value) {
16858        return whichTypedArray2(value) === "Uint32Array";
16859      }
16860      exports$12.isUint32Array = isUint32Array;
16861      function isInt8Array(value) {
16862        return whichTypedArray2(value) === "Int8Array";
16863      }
16864      exports$12.isInt8Array = isInt8Array;
16865      function isInt16Array(value) {
16866        return whichTypedArray2(value) === "Int16Array";
16867      }
16868      exports$12.isInt16Array = isInt16Array;
16869      function isInt32Array(value) {
16870        return whichTypedArray2(value) === "Int32Array";
16871      }
16872      exports$12.isInt32Array = isInt32Array;
16873      function isFloat32Array(value) {
16874        return whichTypedArray2(value) === "Float32Array";
16875      }
16876      exports$12.isFloat32Array = isFloat32Array;
16877      function isFloat64Array(value) {
16878        return whichTypedArray2(value) === "Float64Array";
16879      }
16880      exports$12.isFloat64Array = isFloat64Array;
16881      function isBigInt64Array(value) {
16882        return whichTypedArray2(value) === "BigInt64Array";
16883      }
16884      exports$12.isBigInt64Array = isBigInt64Array;
16885      function isBigUint64Array(value) {
16886        return whichTypedArray2(value) === "BigUint64Array";
16887      }
16888      exports$12.isBigUint64Array = isBigUint64Array;
16889      function isMapToString(value) {
16890        return ObjectToString(value) === "[object Map]";
16891      }
16892      isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
16893      function isMap(value) {
16894        if (typeof Map === "undefined") {
16895          return false;
16896        }
16897        return isMapToString.working ? isMapToString(value) : value instanceof Map;
16898      }
16899      exports$12.isMap = isMap;
16900      function isSetToString(value) {
16901        return ObjectToString(value) === "[object Set]";
16902      }
16903      isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
16904      function isSet(value) {
16905        if (typeof Set === "undefined") {
16906          return false;
16907        }
16908        return isSetToString.working ? isSetToString(value) : value instanceof Set;
16909      }
16910      exports$12.isSet = isSet;
16911      function isWeakMapToString(value) {
16912        return ObjectToString(value) === "[object WeakMap]";
16913      }
16914      isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
16915      function isWeakMap(value) {
16916        if (typeof WeakMap === "undefined") {
16917          return false;
16918        }
16919        return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
16920      }
16921      exports$12.isWeakMap = isWeakMap;
16922      function isWeakSetToString(value) {
16923        return ObjectToString(value) === "[object WeakSet]";
16924      }
16925      isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet());
16926      function isWeakSet(value) {
16927        return isWeakSetToString(value);
16928      }
16929      exports$12.isWeakSet = isWeakSet;
16930      function isArrayBufferToString(value) {
16931        return ObjectToString(value) === "[object ArrayBuffer]";
16932      }
16933      isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(new ArrayBuffer());
16934      function isArrayBuffer2(value) {
16935        if (typeof ArrayBuffer === "undefined") {
16936          return false;
16937        }
16938        return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;
16939      }
16940      exports$12.isArrayBuffer = isArrayBuffer2;
16941      function isDataViewToString(value) {
16942        return ObjectToString(value) === "[object DataView]";
16943      }
16944      isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));
16945      function isDataView(value) {
16946        if (typeof DataView === "undefined") {
16947          return false;
16948        }
16949        return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;
16950      }
16951      exports$12.isDataView = isDataView;
16952      var SharedArrayBufferCopy = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0;
16953      function isSharedArrayBufferToString(value) {
16954        return ObjectToString(value) === "[object SharedArrayBuffer]";
16955      }
16956      function isSharedArrayBuffer(value) {
16957        if (typeof SharedArrayBufferCopy === "undefined") {
16958          return false;
16959        }
16960        if (typeof isSharedArrayBufferToString.working === "undefined") {
16961          isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
16962        }
16963        return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy;
16964      }
16965      exports$12.isSharedArrayBuffer = isSharedArrayBuffer;
16966      function isAsyncFunction(value) {
16967        return ObjectToString(value) === "[object AsyncFunction]";
16968      }
16969      exports$12.isAsyncFunction = isAsyncFunction;
16970      function isMapIterator(value) {
16971        return ObjectToString(value) === "[object Map Iterator]";
16972      }
16973      exports$12.isMapIterator = isMapIterator;
16974      function isSetIterator(value) {
16975        return ObjectToString(value) === "[object Set Iterator]";
16976      }
16977      exports$12.isSetIterator = isSetIterator;
16978      function isGeneratorObject(value) {
16979        return ObjectToString(value) === "[object Generator]";
16980      }
16981      exports$12.isGeneratorObject = isGeneratorObject;
16982      function isWebAssemblyCompiledModule(value) {
16983        return ObjectToString(value) === "[object WebAssembly.Module]";
16984      }
16985      exports$12.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
16986      function isNumberObject(value) {
16987        return checkBoxedPrimitive(value, numberValue);
16988      }
16989      exports$12.isNumberObject = isNumberObject;
16990      function isStringObject(value) {
16991        return checkBoxedPrimitive(value, stringValue);
16992      }
16993      exports$12.isStringObject = isStringObject;
16994      function isBooleanObject(value) {
16995        return checkBoxedPrimitive(value, booleanValue);
16996      }
16997      exports$12.isBooleanObject = isBooleanObject;
16998      function isBigIntObject(value) {
16999        return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
17000      }
17001      exports$12.isBigIntObject = isBigIntObject;
17002      function isSymbolObject(value) {
17003        return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
17004      }
17005      exports$12.isSymbolObject = isSymbolObject;
17006      function isBoxedPrimitive(value) {
17007        return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);
17008      }
17009      exports$12.isBoxedPrimitive = isBoxedPrimitive;
17010      function isAnyArrayBuffer(value) {
17011        return typeof Uint8Array !== "undefined" && (isArrayBuffer2(value) || isSharedArrayBuffer(value));
17012      }
17013      exports$12.isAnyArrayBuffer = isAnyArrayBuffer;
17014      ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(method) {
17015        Object.defineProperty(exports$12, method, {
17016          enumerable: false,
17017          value: function() {
17018            throw new Error(method + " is not supported in userland");
17019          }
17020        });
17021      });
17022    })(types);
17023    return types;
17024  }
17025  var isBuffer;
17026  var hasRequiredIsBuffer;
17027  function requireIsBuffer() {
17028    if (hasRequiredIsBuffer) return isBuffer;
17029    hasRequiredIsBuffer = 1;
17030    isBuffer = function isBuffer2(arg) {
17031      return arg instanceof Buffer;
17032    };
17033    return isBuffer;
17034  }
17035  var inherits = { exports: {} };
17036  var inherits_browser = { exports: {} };
17037  var hasRequiredInherits_browser;
17038  function requireInherits_browser() {
17039    if (hasRequiredInherits_browser) return inherits_browser.exports;
17040    hasRequiredInherits_browser = 1;
17041    if (typeof Object.create === "function") {
17042      inherits_browser.exports = function inherits2(ctor, superCtor) {
17043        if (superCtor) {
17044          ctor.super_ = superCtor;
17045          ctor.prototype = Object.create(superCtor.prototype, {
17046            constructor: {
17047              value: ctor,
17048              enumerable: false,
17049              writable: true,
17050              configurable: true
17051            }
17052          });
17053        }
17054      };
17055    } else {
17056      inherits_browser.exports = function inherits2(ctor, superCtor) {
17057        if (superCtor) {
17058          ctor.super_ = superCtor;
17059          var TempCtor = function() {
17060          };
17061          TempCtor.prototype = superCtor.prototype;
17062          ctor.prototype = new TempCtor();
17063          ctor.prototype.constructor = ctor;
17064        }
17065      };
17066    }
17067    return inherits_browser.exports;
17068  }
17069  var hasRequiredInherits;
17070  function requireInherits() {
17071    if (hasRequiredInherits) return inherits.exports;
17072    hasRequiredInherits = 1;
17073    try {
17074      var util2 = requireUtil$1();
17075      if (typeof util2.inherits !== "function") throw "";
17076      inherits.exports = util2.inherits;
17077    } catch (e) {
17078      inherits.exports = requireInherits_browser();
17079    }
17080    return inherits.exports;
17081  }
17082  var hasRequiredUtil$1;
17083  function requireUtil$1() {
17084    if (hasRequiredUtil$1) return util$2;
17085    hasRequiredUtil$1 = 1;
17086    (function(exports$12) {
17087      var define_process_env_default2 = {};
17088      var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
17089        var keys = Object.keys(obj);
17090        var descriptors = {};
17091        for (var i2 = 0; i2 < keys.length; i2++) {
17092          descriptors[keys[i2]] = Object.getOwnPropertyDescriptor(obj, keys[i2]);
17093        }
17094        return descriptors;
17095      };
17096      var formatRegExp = /%[sdj%]/g;
17097      exports$12.format = function(f) {
17098        if (!isString2(f)) {
17099          var objects = [];
17100          for (var i2 = 0; i2 < arguments.length; i2++) {
17101            objects.push(inspect(arguments[i2]));
17102          }
17103          return objects.join(" ");
17104        }
17105        var i2 = 1;
17106        var args = arguments;
17107        var len2 = args.length;
17108        var str = String(f).replace(formatRegExp, function(x2) {
17109          if (x2 === "%%") return "%";
17110          if (i2 >= len2) return x2;
17111          switch (x2) {
17112            case "%s":
17113              return String(args[i2++]);
17114            case "%d":
17115              return Number(args[i2++]);
17116            case "%j":
17117              try {
17118                return JSON.stringify(args[i2++]);
17119              } catch (_2) {
17120                return "[Circular]";
17121              }
17122            default:
17123              return x2;
17124          }
17125        });
17126        for (var x = args[i2]; i2 < len2; x = args[++i2]) {
17127          if (isNull(x) || !isObject2(x)) {
17128            str += " " + x;
17129          } else {
17130            str += " " + inspect(x);
17131          }
17132        }
17133        return str;
17134      };
17135      exports$12.deprecate = function(fn, msg) {
17136        if (typeof process$1 !== "undefined" && process$1.noDeprecation === true) {
17137          return fn;
17138        }
17139        if (typeof process$1 === "undefined") {
17140          return function() {
17141            return exports$12.deprecate(fn, msg).apply(this, arguments);
17142          };
17143        }
17144        var warned = false;
17145        function deprecated() {
17146          if (!warned) {
17147            if (process$1.throwDeprecation) {
17148              throw new Error(msg);
17149            } else if (process$1.traceDeprecation) {
17150              console.trace(msg);
17151            } else {
17152              console.error(msg);
17153            }
17154            warned = true;
17155          }
17156          return fn.apply(this, arguments);
17157        }
17158        return deprecated;
17159      };
17160      var debugs = {};
17161      var debugEnvRegex = /^$/;
17162      if (define_process_env_default2.NODE_DEBUG) {
17163        var debugEnv = define_process_env_default2.NODE_DEBUG;
17164        debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase();
17165        debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
17166      }
17167      exports$12.debuglog = function(set) {
17168        set = set.toUpperCase();
17169        if (!debugs[set]) {
17170          if (debugEnvRegex.test(set)) {
17171            var pid = process$1.pid;
17172            debugs[set] = function() {
17173              var msg = exports$12.format.apply(exports$12, arguments);
17174              console.error("%s %d: %s", set, pid, msg);
17175            };
17176          } else {
17177            debugs[set] = function() {
17178            };
17179          }
17180        }
17181        return debugs[set];
17182      };
17183      function inspect(obj, opts) {
17184        var ctx = {
17185          seen: [],
17186          stylize: stylizeNoColor
17187        };
17188        if (arguments.length >= 3) ctx.depth = arguments[2];
17189        if (arguments.length >= 4) ctx.colors = arguments[3];
17190        if (isBoolean2(opts)) {
17191          ctx.showHidden = opts;
17192        } else if (opts) {
17193          exports$12._extend(ctx, opts);
17194        }
17195        if (isUndefined2(ctx.showHidden)) ctx.showHidden = false;

vendor: 6,404 bytes, lines 17196-17381

17196        if (isUndefined2(ctx.depth)) ctx.depth = 2;
17197        if (isUndefined2(ctx.colors)) ctx.colors = false;
17198        if (isUndefined2(ctx.customInspect)) ctx.customInspect = true;
17199        if (ctx.colors) ctx.stylize = stylizeWithColor;
17200        return formatValue(ctx, obj, ctx.depth);
17201      }
17202      exports$12.inspect = inspect;
17203      inspect.colors = {
17204        "bold": [1, 22],
17205        "italic": [3, 23],
17206        "underline": [4, 24],
17207        "inverse": [7, 27],
17208        "white": [37, 39],
17209        "grey": [90, 39],
17210        "black": [30, 39],
17211        "blue": [34, 39],
17212        "cyan": [36, 39],
17213        "green": [32, 39],
17214        "magenta": [35, 39],
17215        "red": [31, 39],
17216        "yellow": [33, 39]
17217      };
17218      inspect.styles = {
17219        "special": "cyan",
17220        "number": "yellow",
17221        "boolean": "yellow",
17222        "undefined": "grey",
17223        "null": "bold",
17224        "string": "green",
17225        "date": "magenta",
17226        // "name": intentionally not styling
17227        "regexp": "red"
17228      };
17229      function stylizeWithColor(str, styleType) {
17230        var style = inspect.styles[styleType];
17231        if (style) {
17232          return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
17233        } else {
17234          return str;
17235        }
17236      }
17237      function stylizeNoColor(str, styleType) {
17238        return str;
17239      }
17240      function arrayToHash(array) {
17241        var hash2 = {};
17242        array.forEach(function(val, idx) {
17243          hash2[val] = true;
17244        });
17245        return hash2;
17246      }
17247      function formatValue(ctx, value, recurseTimes) {
17248        if (ctx.customInspect && value && isFunction2(value.inspect) && // Filter out the util module, it's inspect function is special
17249        value.inspect !== exports$12.inspect && // Also filter out any prototype objects using the circular check.
17250        !(value.constructor && value.constructor.prototype === value)) {
17251          var ret = value.inspect(recurseTimes, ctx);
17252          if (!isString2(ret)) {
17253            ret = formatValue(ctx, ret, recurseTimes);
17254          }
17255          return ret;
17256        }
17257        var primitive = formatPrimitive(ctx, value);
17258        if (primitive) {
17259          return primitive;
17260        }
17261        var keys = Object.keys(value);
17262        var visibleKeys = arrayToHash(keys);
17263        if (ctx.showHidden) {
17264          keys = Object.getOwnPropertyNames(value);
17265        }
17266        if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
17267          return formatError(value);
17268        }
17269        if (keys.length === 0) {
17270          if (isFunction2(value)) {
17271            var name = value.name ? ": " + value.name : "";
17272            return ctx.stylize("[Function" + name + "]", "special");
17273          }
17274          if (isRegExp2(value)) {
17275            return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
17276          }
17277          if (isDate2(value)) {
17278            return ctx.stylize(Date.prototype.toString.call(value), "date");
17279          }
17280          if (isError(value)) {
17281            return formatError(value);
17282          }
17283        }
17284        var base2 = "", array = false, braces = ["{", "}"];
17285        if (isArray2(value)) {
17286          array = true;
17287          braces = ["[", "]"];
17288        }
17289        if (isFunction2(value)) {
17290          var n = value.name ? ": " + value.name : "";
17291          base2 = " [Function" + n + "]";
17292        }
17293        if (isRegExp2(value)) {
17294          base2 = " " + RegExp.prototype.toString.call(value);
17295        }
17296        if (isDate2(value)) {
17297          base2 = " " + Date.prototype.toUTCString.call(value);
17298        }
17299        if (isError(value)) {
17300          base2 = " " + formatError(value);
17301        }
17302        if (keys.length === 0 && (!array || value.length == 0)) {
17303          return braces[0] + base2 + braces[1];
17304        }
17305        if (recurseTimes < 0) {
17306          if (isRegExp2(value)) {
17307            return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
17308          } else {
17309            return ctx.stylize("[Object]", "special");
17310          }
17311        }
17312        ctx.seen.push(value);
17313        var output;
17314        if (array) {
17315          output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
17316        } else {
17317          output = keys.map(function(key2) {
17318            return formatProperty(ctx, value, recurseTimes, visibleKeys, key2, array);
17319          });
17320        }
17321        ctx.seen.pop();
17322        return reduceToSingleString(output, base2, braces);
17323      }
17324      function formatPrimitive(ctx, value) {
17325        if (isUndefined2(value))
17326          return ctx.stylize("undefined", "undefined");
17327        if (isString2(value)) {
17328          var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
17329          return ctx.stylize(simple, "string");
17330        }
17331        if (isNumber2(value))
17332          return ctx.stylize("" + value, "number");
17333        if (isBoolean2(value))
17334          return ctx.stylize("" + value, "boolean");
17335        if (isNull(value))
17336          return ctx.stylize("null", "null");
17337      }
17338      function formatError(value) {
17339        return "[" + Error.prototype.toString.call(value) + "]";
17340      }
17341      function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
17342        var output = [];
17343        for (var i2 = 0, l = value.length; i2 < l; ++i2) {
17344          if (hasOwnProperty2(value, String(i2))) {
17345            output.push(formatProperty(
17346              ctx,
17347              value,
17348              recurseTimes,
17349              visibleKeys,
17350              String(i2),
17351              true
17352            ));
17353          } else {
17354            output.push("");
17355          }
17356        }
17357        keys.forEach(function(key2) {
17358          if (!key2.match(/^\d+$/)) {
17359            output.push(formatProperty(
17360              ctx,
17361              value,
17362              recurseTimes,
17363              visibleKeys,
17364              key2,
17365              true
17366            ));
17367          }
17368        });
17369        return output;
17370      }
17371      function formatProperty(ctx, value, recurseTimes, visibleKeys, key2, array) {
17372        var name, str, desc;
17373        desc = Object.getOwnPropertyDescriptor(value, key2) || { value: value[key2] };
17374        if (desc.get) {
17375          if (desc.set) {
17376            str = ctx.stylize("[Getter/Setter]", "special");
17377          } else {
17378            str = ctx.stylize("[Getter]", "special");
17379          }
17380        } else {
17381          if (desc.set) {

vendor: 10,940 bytes, lines 17382-17692

17382            str = ctx.stylize("[Setter]", "special");
17383          }
17384        }
17385        if (!hasOwnProperty2(visibleKeys, key2)) {
17386          name = "[" + key2 + "]";
17387        }
17388        if (!str) {
17389          if (ctx.seen.indexOf(desc.value) < 0) {
17390            if (isNull(recurseTimes)) {
17391              str = formatValue(ctx, desc.value, null);
17392            } else {
17393              str = formatValue(ctx, desc.value, recurseTimes - 1);
17394            }
17395            if (str.indexOf("\n") > -1) {
17396              if (array) {
17397                str = str.split("\n").map(function(line) {
17398                  return "  " + line;
17399                }).join("\n").slice(2);
17400              } else {
17401                str = "\n" + str.split("\n").map(function(line) {
17402                  return "   " + line;
17403                }).join("\n");
17404              }
17405            }
17406          } else {
17407            str = ctx.stylize("[Circular]", "special");
17408          }
17409        }
17410        if (isUndefined2(name)) {
17411          if (array && key2.match(/^\d+$/)) {
17412            return str;
17413          }
17414          name = JSON.stringify("" + key2);
17415          if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
17416            name = name.slice(1, -1);
17417            name = ctx.stylize(name, "name");
17418          } else {
17419            name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
17420            name = ctx.stylize(name, "string");
17421          }
17422        }
17423        return name + ": " + str;
17424      }
17425      function reduceToSingleString(output, base2, braces) {
17426        var length = output.reduce(function(prev, cur) {
17427          if (cur.indexOf("\n") >= 0) ;
17428          return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
17429        }, 0);
17430        if (length > 60) {
17431          return braces[0] + (base2 === "" ? "" : base2 + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
17432        }
17433        return braces[0] + base2 + " " + output.join(", ") + " " + braces[1];
17434      }
17435      exports$12.types = requireTypes();
17436      function isArray2(ar) {
17437        return Array.isArray(ar);
17438      }
17439      exports$12.isArray = isArray2;
17440      function isBoolean2(arg) {
17441        return typeof arg === "boolean";
17442      }
17443      exports$12.isBoolean = isBoolean2;
17444      function isNull(arg) {
17445        return arg === null;
17446      }
17447      exports$12.isNull = isNull;
17448      function isNullOrUndefined(arg) {
17449        return arg == null;
17450      }
17451      exports$12.isNullOrUndefined = isNullOrUndefined;
17452      function isNumber2(arg) {
17453        return typeof arg === "number";
17454      }
17455      exports$12.isNumber = isNumber2;
17456      function isString2(arg) {
17457        return typeof arg === "string";
17458      }
17459      exports$12.isString = isString2;
17460      function isSymbol(arg) {
17461        return typeof arg === "symbol";
17462      }
17463      exports$12.isSymbol = isSymbol;
17464      function isUndefined2(arg) {
17465        return arg === void 0;
17466      }
17467      exports$12.isUndefined = isUndefined2;
17468      function isRegExp2(re) {
17469        return isObject2(re) && objectToString(re) === "[object RegExp]";
17470      }
17471      exports$12.isRegExp = isRegExp2;
17472      exports$12.types.isRegExp = isRegExp2;
17473      function isObject2(arg) {
17474        return typeof arg === "object" && arg !== null;
17475      }
17476      exports$12.isObject = isObject2;
17477      function isDate2(d) {
17478        return isObject2(d) && objectToString(d) === "[object Date]";
17479      }
17480      exports$12.isDate = isDate2;
17481      exports$12.types.isDate = isDate2;
17482      function isError(e) {
17483        return isObject2(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
17484      }
17485      exports$12.isError = isError;
17486      exports$12.types.isNativeError = isError;
17487      function isFunction2(arg) {
17488        return typeof arg === "function";
17489      }
17490      exports$12.isFunction = isFunction2;
17491      function isPrimitive(arg) {
17492        return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
17493        typeof arg === "undefined";
17494      }
17495      exports$12.isPrimitive = isPrimitive;
17496      exports$12.isBuffer = requireIsBuffer();
17497      function objectToString(o) {
17498        return Object.prototype.toString.call(o);
17499      }
17500      function pad(n) {
17501        return n < 10 ? "0" + n.toString(10) : n.toString(10);
17502      }
17503      var months = [
17504        "Jan",
17505        "Feb",
17506        "Mar",
17507        "Apr",
17508        "May",
17509        "Jun",
17510        "Jul",
17511        "Aug",
17512        "Sep",
17513        "Oct",
17514        "Nov",
17515        "Dec"
17516      ];
17517      function timestamp() {
17518        var d = /* @__PURE__ */ new Date();
17519        var time = [
17520          pad(d.getHours()),
17521          pad(d.getMinutes()),
17522          pad(d.getSeconds())
17523        ].join(":");
17524        return [d.getDate(), months[d.getMonth()], time].join(" ");
17525      }
17526      exports$12.log = function() {
17527        console.log("%s - %s", timestamp(), exports$12.format.apply(exports$12, arguments));
17528      };
17529      exports$12.inherits = requireInherits();
17530      exports$12._extend = function(origin2, add) {
17531        if (!add || !isObject2(add)) return origin2;
17532        var keys = Object.keys(add);
17533        var i2 = keys.length;
17534        while (i2--) {
17535          origin2[keys[i2]] = add[keys[i2]];
17536        }
17537        return origin2;
17538      };
17539      function hasOwnProperty2(obj, prop) {
17540        return Object.prototype.hasOwnProperty.call(obj, prop);
17541      }
17542      var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
17543      exports$12.promisify = function promisify(original) {
17544        if (typeof original !== "function")
17545          throw new TypeError('The "original" argument must be of type Function');
17546        if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
17547          var fn = original[kCustomPromisifiedSymbol];
17548          if (typeof fn !== "function") {
17549            throw new TypeError('The "util.promisify.custom" argument must be of type Function');
17550          }
17551          Object.defineProperty(fn, kCustomPromisifiedSymbol, {
17552            value: fn,
17553            enumerable: false,
17554            writable: false,
17555            configurable: true
17556          });
17557          return fn;
17558        }
17559        function fn() {
17560          var promiseResolve, promiseReject;
17561          var promise = new Promise(function(resolve, reject) {
17562            promiseResolve = resolve;
17563            promiseReject = reject;
17564          });
17565          var args = [];
17566          for (var i2 = 0; i2 < arguments.length; i2++) {
17567            args.push(arguments[i2]);
17568          }
17569          args.push(function(err, value) {
17570            if (err) {
17571              promiseReject(err);
17572            } else {
17573              promiseResolve(value);
17574            }
17575          });
17576          try {
17577            original.apply(this, args);
17578          } catch (err) {
17579            promiseReject(err);
17580          }
17581          return promise;
17582        }
17583        Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
17584        if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
17585          value: fn,
17586          enumerable: false,
17587          writable: false,
17588          configurable: true
17589        });
17590        return Object.defineProperties(
17591          fn,
17592          getOwnPropertyDescriptors(original)
17593        );
17594      };
17595      exports$12.promisify.custom = kCustomPromisifiedSymbol;
17596      function callbackifyOnRejected(reason, cb) {
17597        if (!reason) {
17598          var newReason = new Error("Promise was rejected with a falsy value");
17599          newReason.reason = reason;
17600          reason = newReason;
17601        }
17602        return cb(reason);
17603      }
17604      function callbackify2(original) {
17605        if (typeof original !== "function") {
17606          throw new TypeError('The "original" argument must be of type Function');
17607        }
17608        function callbackified() {
17609          var args = [];
17610          for (var i2 = 0; i2 < arguments.length; i2++) {
17611            args.push(arguments[i2]);
17612          }
17613          var maybeCb = args.pop();
17614          if (typeof maybeCb !== "function") {
17615            throw new TypeError("The last argument must be of type Function");
17616          }
17617          var self2 = this;
17618          var cb = function() {
17619            return maybeCb.apply(self2, arguments);
17620          };
17621          original.apply(this, args).then(
17622            function(ret) {
17623              process$1.nextTick(cb.bind(null, null, ret));
17624            },
17625            function(rej) {
17626              process$1.nextTick(callbackifyOnRejected.bind(null, rej, cb));
17627            }
17628          );
17629        }
17630        Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
17631        Object.defineProperties(
17632          callbackified,
17633          getOwnPropertyDescriptors(original)
17634        );
17635        return callbackified;
17636      }
17637      exports$12.callbackify = callbackify2;
17638    })(util$2);
17639    return util$2;
17640  }
17641  var events = { exports: {} };
17642  var hasRequiredEvents;
17643  function requireEvents() {
17644    if (hasRequiredEvents) return events.exports;
17645    hasRequiredEvents = 1;
17646    var R = typeof Reflect === "object" ? Reflect : null;
17647    var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
17648      return Function.prototype.apply.call(target, receiver, args);
17649    };
17650    var ReflectOwnKeys;
17651    if (R && typeof R.ownKeys === "function") {
17652      ReflectOwnKeys = R.ownKeys;
17653    } else if (Object.getOwnPropertySymbols) {
17654      ReflectOwnKeys = function ReflectOwnKeys2(target) {
17655        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
17656      };
17657    } else {
17658      ReflectOwnKeys = function ReflectOwnKeys2(target) {
17659        return Object.getOwnPropertyNames(target);
17660      };
17661    }
17662    function ProcessEmitWarning(warning) {
17663      if (console && console.warn) console.warn(warning);
17664    }
17665    var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
17666      return value !== value;
17667    };
17668    function EventEmitter() {
17669      EventEmitter.init.call(this);
17670    }
17671    events.exports = EventEmitter;
17672    events.exports.once = once;
17673    EventEmitter.EventEmitter = EventEmitter;
17674    EventEmitter.prototype._events = void 0;
17675    EventEmitter.prototype._eventsCount = 0;
17676    EventEmitter.prototype._maxListeners = void 0;
17677    var defaultMaxListeners = 10;
17678    function checkListener(listener) {
17679      if (typeof listener !== "function") {
17680        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
17681      }
17682    }
17683    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
17684      enumerable: true,
17685      get: function() {
17686        return defaultMaxListeners;
17687      },
17688      set: function(arg) {
17689        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
17690          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
17691        }
17692        defaultMaxListeners = arg;

vendor: 12,094 bytes, lines 17693-18032

17693      }
17694    });
17695    EventEmitter.init = function() {
17696      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
17697        this._events = /* @__PURE__ */ Object.create(null);
17698        this._eventsCount = 0;
17699      }
17700      this._maxListeners = this._maxListeners || void 0;
17701    };
17702    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
17703      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
17704        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
17705      }
17706      this._maxListeners = n;
17707      return this;
17708    };
17709    function _getMaxListeners(that) {
17710      if (that._maxListeners === void 0)
17711        return EventEmitter.defaultMaxListeners;
17712      return that._maxListeners;
17713    }
17714    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
17715      return _getMaxListeners(this);
17716    };
17717    EventEmitter.prototype.emit = function emit(type2) {
17718      var args = [];
17719      for (var i2 = 1; i2 < arguments.length; i2++) args.push(arguments[i2]);
17720      var doError = type2 === "error";
17721      var events2 = this._events;
17722      if (events2 !== void 0)
17723        doError = doError && events2.error === void 0;
17724      else if (!doError)
17725        return false;
17726      if (doError) {
17727        var er;
17728        if (args.length > 0)
17729          er = args[0];
17730        if (er instanceof Error) {
17731          throw er;
17732        }
17733        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
17734        err.context = er;
17735        throw err;
17736      }
17737      var handler = events2[type2];
17738      if (handler === void 0)
17739        return false;
17740      if (typeof handler === "function") {
17741        ReflectApply(handler, this, args);
17742      } else {
17743        var len2 = handler.length;
17744        var listeners = arrayClone(handler, len2);
17745        for (var i2 = 0; i2 < len2; ++i2)
17746          ReflectApply(listeners[i2], this, args);
17747      }
17748      return true;
17749    };
17750    function _addListener(target, type2, listener, prepend) {
17751      var m;
17752      var events2;
17753      var existing;
17754      checkListener(listener);
17755      events2 = target._events;
17756      if (events2 === void 0) {
17757        events2 = target._events = /* @__PURE__ */ Object.create(null);
17758        target._eventsCount = 0;
17759      } else {
17760        if (events2.newListener !== void 0) {
17761          target.emit(
17762            "newListener",
17763            type2,
17764            listener.listener ? listener.listener : listener
17765          );
17766          events2 = target._events;
17767        }
17768        existing = events2[type2];
17769      }
17770      if (existing === void 0) {
17771        existing = events2[type2] = listener;
17772        ++target._eventsCount;
17773      } else {
17774        if (typeof existing === "function") {
17775          existing = events2[type2] = prepend ? [listener, existing] : [existing, listener];
17776        } else if (prepend) {
17777          existing.unshift(listener);
17778        } else {
17779          existing.push(listener);
17780        }
17781        m = _getMaxListeners(target);
17782        if (m > 0 && existing.length > m && !existing.warned) {
17783          existing.warned = true;
17784          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type2) + " listeners added. Use emitter.setMaxListeners() to increase limit");
17785          w.name = "MaxListenersExceededWarning";
17786          w.emitter = target;
17787          w.type = type2;
17788          w.count = existing.length;
17789          ProcessEmitWarning(w);
17790        }
17791      }
17792      return target;
17793    }
17794    EventEmitter.prototype.addListener = function addListener(type2, listener) {
17795      return _addListener(this, type2, listener, false);
17796    };
17797    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
17798    EventEmitter.prototype.prependListener = function prependListener(type2, listener) {
17799      return _addListener(this, type2, listener, true);
17800    };
17801    function onceWrapper() {
17802      if (!this.fired) {
17803        this.target.removeListener(this.type, this.wrapFn);
17804        this.fired = true;
17805        if (arguments.length === 0)
17806          return this.listener.call(this.target);
17807        return this.listener.apply(this.target, arguments);
17808      }
17809    }
17810    function _onceWrap(target, type2, listener) {
17811      var state2 = { fired: false, wrapFn: void 0, target, type: type2, listener };
17812      var wrapped = onceWrapper.bind(state2);
17813      wrapped.listener = listener;
17814      state2.wrapFn = wrapped;
17815      return wrapped;
17816    }
17817    EventEmitter.prototype.once = function once2(type2, listener) {
17818      checkListener(listener);
17819      this.on(type2, _onceWrap(this, type2, listener));
17820      return this;
17821    };
17822    EventEmitter.prototype.prependOnceListener = function prependOnceListener(type2, listener) {
17823      checkListener(listener);
17824      this.prependListener(type2, _onceWrap(this, type2, listener));
17825      return this;
17826    };
17827    EventEmitter.prototype.removeListener = function removeListener(type2, listener) {
17828      var list, events2, position, i2, originalListener;
17829      checkListener(listener);
17830      events2 = this._events;
17831      if (events2 === void 0)
17832        return this;
17833      list = events2[type2];
17834      if (list === void 0)
17835        return this;
17836      if (list === listener || list.listener === listener) {
17837        if (--this._eventsCount === 0)
17838          this._events = /* @__PURE__ */ Object.create(null);
17839        else {
17840          delete events2[type2];
17841          if (events2.removeListener)
17842            this.emit("removeListener", type2, list.listener || listener);
17843        }
17844      } else if (typeof list !== "function") {
17845        position = -1;
17846        for (i2 = list.length - 1; i2 >= 0; i2--) {
17847          if (list[i2] === listener || list[i2].listener === listener) {
17848            originalListener = list[i2].listener;
17849            position = i2;
17850            break;
17851          }
17852        }
17853        if (position < 0)
17854          return this;
17855        if (position === 0)
17856          list.shift();
17857        else {
17858          spliceOne(list, position);
17859        }
17860        if (list.length === 1)
17861          events2[type2] = list[0];
17862        if (events2.removeListener !== void 0)
17863          this.emit("removeListener", type2, originalListener || listener);
17864      }
17865      return this;
17866    };
17867    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
17868    EventEmitter.prototype.removeAllListeners = function removeAllListeners(type2) {
17869      var listeners, events2, i2;
17870      events2 = this._events;
17871      if (events2 === void 0)
17872        return this;
17873      if (events2.removeListener === void 0) {
17874        if (arguments.length === 0) {
17875          this._events = /* @__PURE__ */ Object.create(null);
17876          this._eventsCount = 0;
17877        } else if (events2[type2] !== void 0) {
17878          if (--this._eventsCount === 0)
17879            this._events = /* @__PURE__ */ Object.create(null);
17880          else
17881            delete events2[type2];
17882        }
17883        return this;
17884      }
17885      if (arguments.length === 0) {
17886        var keys = Object.keys(events2);
17887        var key2;
17888        for (i2 = 0; i2 < keys.length; ++i2) {
17889          key2 = keys[i2];
17890          if (key2 === "removeListener") continue;
17891          this.removeAllListeners(key2);
17892        }
17893        this.removeAllListeners("removeListener");
17894        this._events = /* @__PURE__ */ Object.create(null);
17895        this._eventsCount = 0;
17896        return this;
17897      }
17898      listeners = events2[type2];
17899      if (typeof listeners === "function") {
17900        this.removeListener(type2, listeners);
17901      } else if (listeners !== void 0) {
17902        for (i2 = listeners.length - 1; i2 >= 0; i2--) {
17903          this.removeListener(type2, listeners[i2]);
17904        }
17905      }
17906      return this;
17907    };
17908    function _listeners(target, type2, unwrap) {
17909      var events2 = target._events;
17910      if (events2 === void 0)
17911        return [];
17912      var evlistener = events2[type2];
17913      if (evlistener === void 0)
17914        return [];
17915      if (typeof evlistener === "function")
17916        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
17917      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
17918    }
17919    EventEmitter.prototype.listeners = function listeners(type2) {
17920      return _listeners(this, type2, true);
17921    };
17922    EventEmitter.prototype.rawListeners = function rawListeners(type2) {
17923      return _listeners(this, type2, false);
17924    };
17925    EventEmitter.listenerCount = function(emitter, type2) {
17926      if (typeof emitter.listenerCount === "function") {
17927        return emitter.listenerCount(type2);
17928      } else {
17929        return listenerCount.call(emitter, type2);
17930      }
17931    };
17932    EventEmitter.prototype.listenerCount = listenerCount;
17933    function listenerCount(type2) {
17934      var events2 = this._events;
17935      if (events2 !== void 0) {
17936        var evlistener = events2[type2];
17937        if (typeof evlistener === "function") {
17938          return 1;
17939        } else if (evlistener !== void 0) {
17940          return evlistener.length;
17941        }
17942      }
17943      return 0;
17944    }
17945    EventEmitter.prototype.eventNames = function eventNames() {
17946      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
17947    };
17948    function arrayClone(arr, n) {
17949      var copy = new Array(n);
17950      for (var i2 = 0; i2 < n; ++i2)
17951        copy[i2] = arr[i2];
17952      return copy;
17953    }
17954    function spliceOne(list, index) {
17955      for (; index + 1 < list.length; index++)
17956        list[index] = list[index + 1];
17957      list.pop();
17958    }
17959    function unwrapListeners(arr) {
17960      var ret = new Array(arr.length);
17961      for (var i2 = 0; i2 < ret.length; ++i2) {
17962        ret[i2] = arr[i2].listener || arr[i2];
17963      }
17964      return ret;
17965    }
17966    function once(emitter, name) {
17967      return new Promise(function(resolve, reject) {
17968        function errorListener(err) {
17969          emitter.removeListener(name, resolver);
17970          reject(err);
17971        }
17972        function resolver() {
17973          if (typeof emitter.removeListener === "function") {
17974            emitter.removeListener("error", errorListener);
17975          }
17976          resolve([].slice.call(arguments));
17977        }
17978        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
17979        if (name !== "error") {
17980          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
17981        }
17982      });
17983    }
17984    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
17985      if (typeof emitter.on === "function") {
17986        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
17987      }
17988    }
17989    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
17990      if (typeof emitter.on === "function") {
17991        if (flags.once) {
17992          emitter.once(name, listener);
17993        } else {
17994          emitter.on(name, listener);
17995        }
17996      } else if (typeof emitter.addEventListener === "function") {
17997        emitter.addEventListener(name, function wrapListener(arg) {
17998          if (flags.once) {
17999            emitter.removeEventListener(name, wrapListener);
18000          }
18001          listener(arg);
18002        });
18003      } else {
18004        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
18005      }
18006    }
18007    return events.exports;
18008  }
18009  var stream$2;
18010  var hasRequiredStream$1;
18011  function requireStream$1() {
18012    if (hasRequiredStream$1) return stream$2;
18013    hasRequiredStream$1 = 1;
18014    stream$2 = requireStreamBrowserify();
18015    return stream$2;
18016  }
18017  var dist = {};
18018  var hasRequiredDist;
18019  function requireDist() {
18020    if (hasRequiredDist) return dist;
18021    hasRequiredDist = 1;
18022    (function(exports$12) {
18023      Object.defineProperties(exports$12, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
18024      var buffer2 = {};
18025      var base64Js2 = {};
18026      base64Js2.byteLength = byteLength2;
18027      base64Js2.toByteArray = toByteArray2;
18028      base64Js2.fromByteArray = fromByteArray2;
18029      var lookup2 = [];
18030      var revLookup2 = [];
18031      var Arr2 = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
18032      var code2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

vendor: 6,020 bytes, lines 18032-18193

18032+/";
18033      for (var i2 = 0, len2 = code2.length; i2 < len2; ++i2) {
18034        lookup2[i2] = code2[i2];
18035        revLookup2[code2.charCodeAt(i2)] = i2;
18036      }
18037      revLookup2["-".charCodeAt(0)] = 62;
18038      revLookup2["_".charCodeAt(0)] = 63;
18039      function getLens2(b64) {
18040        var len3 = b64.length;
18041        if (len3 % 4 > 0) {
18042          throw new Error("Invalid string. Length must be a multiple of 4");
18043        }
18044        var validLen = b64.indexOf("=");
18045        if (validLen === -1) validLen = len3;
18046        var placeHoldersLen = validLen === len3 ? 0 : 4 - validLen % 4;
18047        return [validLen, placeHoldersLen];
18048      }
18049      function byteLength2(b64) {
18050        var lens = getLens2(b64);
18051        var validLen = lens[0];
18052        var placeHoldersLen = lens[1];
18053        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
18054      }
18055      function _byteLength2(b64, validLen, placeHoldersLen) {
18056        return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
18057      }
18058      function toByteArray2(b64) {
18059        var tmp;
18060        var lens = getLens2(b64);
18061        var validLen = lens[0];
18062        var placeHoldersLen = lens[1];
18063        var arr = new Arr2(_byteLength2(b64, validLen, placeHoldersLen));
18064        var curByte = 0;
18065        var len3 = placeHoldersLen > 0 ? validLen - 4 : validLen;
18066        var i3;
18067        for (i3 = 0; i3 < len3; i3 += 4) {
18068          tmp = revLookup2[b64.charCodeAt(i3)] << 18 | revLookup2[b64.charCodeAt(i3 + 1)] << 12 | revLookup2[b64.charCodeAt(i3 + 2)] << 6 | revLookup2[b64.charCodeAt(i3 + 3)];
18069          arr[curByte++] = tmp >> 16 & 255;
18070          arr[curByte++] = tmp >> 8 & 255;
18071          arr[curByte++] = tmp & 255;
18072        }
18073        if (placeHoldersLen === 2) {
18074          tmp = revLookup2[b64.charCodeAt(i3)] << 2 | revLookup2[b64.charCodeAt(i3 + 1)] >> 4;
18075          arr[curByte++] = tmp & 255;
18076        }
18077        if (placeHoldersLen === 1) {
18078          tmp = revLookup2[b64.charCodeAt(i3)] << 10 | revLookup2[b64.charCodeAt(i3 + 1)] << 4 | revLookup2[b64.charCodeAt(i3 + 2)] >> 2;
18079          arr[curByte++] = tmp >> 8 & 255;
18080          arr[curByte++] = tmp & 255;
18081        }
18082        return arr;
18083      }
18084      function tripletToBase642(num) {
18085        return lookup2[num >> 18 & 63] + lookup2[num >> 12 & 63] + lookup2[num >> 6 & 63] + lookup2[num & 63];
18086      }
18087      function encodeChunk2(uint8, start, end) {
18088        var tmp;
18089        var output = [];
18090        for (var i3 = start; i3 < end; i3 += 3) {
18091          tmp = (uint8[i3] << 16 & 16711680) + (uint8[i3 + 1] << 8 & 65280) + (uint8[i3 + 2] & 255);
18092          output.push(tripletToBase642(tmp));
18093        }
18094        return output.join("");
18095      }
18096      function fromByteArray2(uint8) {
18097        var tmp;
18098        var len3 = uint8.length;
18099        var extraBytes = len3 % 3;
18100        var parts = [];
18101        var maxChunkLength = 16383;
18102        for (var i3 = 0, len22 = len3 - extraBytes; i3 < len22; i3 += maxChunkLength) {
18103          parts.push(encodeChunk2(uint8, i3, i3 + maxChunkLength > len22 ? len22 : i3 + maxChunkLength));
18104        }
18105        if (extraBytes === 1) {
18106          tmp = uint8[len3 - 1];
18107          parts.push(
18108            lookup2[tmp >> 2] + lookup2[tmp << 4 & 63] + "=="
18109          );
18110        } else if (extraBytes === 2) {
18111          tmp = (uint8[len3 - 2] << 8) + uint8[len3 - 1];
18112          parts.push(
18113            lookup2[tmp >> 10] + lookup2[tmp >> 4 & 63] + lookup2[tmp << 2 & 63] + "="
18114          );
18115        }
18116        return parts.join("");
18117      }
18118      var ieee7542 = {};
18119      /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
18120      ieee7542.read = function(buffer3, offset, isLE, mLen, nBytes) {
18121        var e, m;
18122        var eLen = nBytes * 8 - mLen - 1;
18123        var eMax = (1 << eLen) - 1;
18124        var eBias = eMax >> 1;
18125        var nBits = -7;
18126        var i3 = isLE ? nBytes - 1 : 0;
18127        var d = isLE ? -1 : 1;
18128        var s = buffer3[offset + i3];
18129        i3 += d;
18130        e = s & (1 << -nBits) - 1;
18131        s >>= -nBits;
18132        nBits += eLen;
18133        for (; nBits > 0; e = e * 256 + buffer3[offset + i3], i3 += d, nBits -= 8) {
18134        }
18135        m = e & (1 << -nBits) - 1;
18136        e >>= -nBits;
18137        nBits += mLen;
18138        for (; nBits > 0; m = m * 256 + buffer3[offset + i3], i3 += d, nBits -= 8) {
18139        }
18140        if (e === 0) {
18141          e = 1 - eBias;
18142        } else if (e === eMax) {
18143          return m ? NaN : (s ? -1 : 1) * Infinity;
18144        } else {
18145          m = m + Math.pow(2, mLen);
18146          e = e - eBias;
18147        }
18148        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
18149      };
18150      ieee7542.write = function(buffer3, value, offset, isLE, mLen, nBytes) {
18151        var e, m, c;
18152        var eLen = nBytes * 8 - mLen - 1;
18153        var eMax = (1 << eLen) - 1;
18154        var eBias = eMax >> 1;
18155        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
18156        var i3 = isLE ? 0 : nBytes - 1;
18157        var d = isLE ? 1 : -1;
18158        var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
18159        value = Math.abs(value);
18160        if (isNaN(value) || value === Infinity) {
18161          m = isNaN(value) ? 1 : 0;
18162          e = eMax;
18163        } else {
18164          e = Math.floor(Math.log(value) / Math.LN2);
18165          if (value * (c = Math.pow(2, -e)) < 1) {
18166            e--;
18167            c *= 2;
18168          }
18169          if (e + eBias >= 1) {
18170            value += rt / c;
18171          } else {
18172            value += rt * Math.pow(2, 1 - eBias);
18173          }
18174          if (value * c >= 2) {
18175            e++;
18176            c /= 2;
18177          }
18178          if (e + eBias >= eMax) {
18179            m = 0;
18180            e = eMax;
18181          } else if (e + eBias >= 1) {
18182            m = (value * c - 1) * Math.pow(2, mLen);
18183            e = e + eBias;
18184          } else {
18185            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
18186            e = 0;
18187          }
18188        }
18189        for (; mLen >= 8; buffer3[offset + i3] = m & 255, i3 += d, m /= 256, mLen -= 8) {
18190        }
18191        e = e << mLen | m;
18192        eLen += mLen;
18193        for (; eLen > 0;

vendor: 43,100 bytes, lines 18193-19260

18193 buffer3[offset + i3] = e & 255, i3 += d, e /= 256, eLen -= 8) {
18194        }
18195        buffer3[offset + i3 - d] |= s * 128;
18196      };
18197      /*!
18198       * The buffer module from node.js, for the browser.
18199       *
18200       * @author   Feross Aboukhadijeh <https://feross.org>
18201       * @license  MIT
18202       */
18203      (function(exports$13) {
18204        const base64 = base64Js2;
18205        const ieee754$1 = ieee7542;
18206        const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
18207        exports$13.Buffer = Buffer3;
18208        exports$13.SlowBuffer = SlowBuffer;
18209        exports$13.INSPECT_MAX_BYTES = 50;
18210        const K_MAX_LENGTH = 2147483647;
18211        exports$13.kMaxLength = K_MAX_LENGTH;
18212        const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
18213        Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
18214        if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
18215          console.error(
18216            "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
18217          );
18218        }
18219        function typedArraySupport() {
18220          try {
18221            const arr = new GlobalUint8Array(1);
18222            const proto = { foo: function() {
18223              return 42;
18224            } };
18225            Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
18226            Object.setPrototypeOf(arr, proto);
18227            return arr.foo() === 42;
18228          } catch (e) {
18229            return false;
18230          }
18231        }
18232        Object.defineProperty(Buffer3.prototype, "parent", {
18233          enumerable: true,
18234          get: function() {
18235            if (!Buffer3.isBuffer(this)) return void 0;
18236            return this.buffer;
18237          }
18238        });
18239        Object.defineProperty(Buffer3.prototype, "offset", {
18240          enumerable: true,
18241          get: function() {
18242            if (!Buffer3.isBuffer(this)) return void 0;
18243            return this.byteOffset;
18244          }
18245        });
18246        function createBuffer(length) {
18247          if (length > K_MAX_LENGTH) {
18248            throw new RangeError('The value "' + length + '" is invalid for option "size"');
18249          }
18250          const buf = new GlobalUint8Array(length);
18251          Object.setPrototypeOf(buf, Buffer3.prototype);
18252          return buf;
18253        }
18254        function Buffer3(arg, encodingOrOffset, length) {
18255          if (typeof arg === "number") {
18256            if (typeof encodingOrOffset === "string") {
18257              throw new TypeError(
18258                'The "string" argument must be of type string. Received type number'
18259              );
18260            }
18261            return allocUnsafe(arg);
18262          }
18263          return from(arg, encodingOrOffset, length);
18264        }
18265        Buffer3.poolSize = 8192;
18266        function from(value, encodingOrOffset, length) {
18267          if (typeof value === "string") {
18268            return fromString(value, encodingOrOffset);
18269          }
18270          if (GlobalArrayBuffer.isView(value)) {
18271            return fromArrayView(value);
18272          }
18273          if (value == null) {
18274            throw new TypeError(
18275              "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
18276            );
18277          }
18278          if (isInstance(value, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) {
18279            return fromArrayBuffer(value, encodingOrOffset, length);
18280          }
18281          if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) {
18282            return fromArrayBuffer(value, encodingOrOffset, length);
18283          }
18284          if (typeof value === "number") {
18285            throw new TypeError(
18286              'The "value" argument must not be of type number. Received type number'
18287            );
18288          }
18289          const valueOf = value.valueOf && value.valueOf();
18290          if (valueOf != null && valueOf !== value) {
18291            return Buffer3.from(valueOf, encodingOrOffset, length);
18292          }
18293          const b = fromObject(value);
18294          if (b) return b;
18295          if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
18296            return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
18297          }
18298          throw new TypeError(
18299            "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
18300          );
18301        }
18302        Buffer3.from = function(value, encodingOrOffset, length) {
18303          return from(value, encodingOrOffset, length);
18304        };
18305        Object.setPrototypeOf(Buffer3.prototype, GlobalUint8Array.prototype);
18306        Object.setPrototypeOf(Buffer3, GlobalUint8Array);
18307        function assertSize(size) {
18308          if (typeof size !== "number") {
18309            throw new TypeError('"size" argument must be of type number');
18310          } else if (size < 0) {
18311            throw new RangeError('The value "' + size + '" is invalid for option "size"');
18312          }
18313        }
18314        function alloc(size, fill, encoding) {
18315          assertSize(size);
18316          if (size <= 0) {
18317            return createBuffer(size);
18318          }
18319          if (fill !== void 0) {
18320            return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
18321          }
18322          return createBuffer(size);
18323        }
18324        Buffer3.alloc = function(size, fill, encoding) {
18325          return alloc(size, fill, encoding);
18326        };
18327        function allocUnsafe(size) {
18328          assertSize(size);
18329          return createBuffer(size < 0 ? 0 : checked(size) | 0);
18330        }
18331        Buffer3.allocUnsafe = function(size) {
18332          return allocUnsafe(size);
18333        };
18334        Buffer3.allocUnsafeSlow = function(size) {
18335          return allocUnsafe(size);
18336        };
18337        function fromString(string, encoding) {
18338          if (typeof encoding !== "string" || encoding === "") {
18339            encoding = "utf8";
18340          }
18341          if (!Buffer3.isEncoding(encoding)) {
18342            throw new TypeError("Unknown encoding: " + encoding);
18343          }
18344          const length = byteLength3(string, encoding) | 0;
18345          let buf = createBuffer(length);
18346          const actual = buf.write(string, encoding);
18347          if (actual !== length) {
18348            buf = buf.slice(0, actual);
18349          }
18350          return buf;
18351        }
18352        function fromArrayLike(array) {
18353          const length = array.length < 0 ? 0 : checked(array.length) | 0;
18354          const buf = createBuffer(length);
18355          for (let i3 = 0; i3 < length; i3 += 1) {
18356            buf[i3] = array[i3] & 255;
18357          }
18358          return buf;
18359        }
18360        function fromArrayView(arrayView) {
18361          if (isInstance(arrayView, GlobalUint8Array)) {
18362            const copy = new GlobalUint8Array(arrayView);
18363            return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
18364          }
18365          return fromArrayLike(arrayView);
18366        }
18367        function fromArrayBuffer(array, byteOffset, length) {
18368          if (byteOffset < 0 || array.byteLength < byteOffset) {
18369            throw new RangeError('"offset" is outside of buffer bounds');
18370          }
18371          if (array.byteLength < byteOffset + (length || 0)) {
18372            throw new RangeError('"length" is outside of buffer bounds');
18373          }
18374          let buf;
18375          if (byteOffset === void 0 && length === void 0) {
18376            buf = new GlobalUint8Array(array);
18377          } else if (length === void 0) {
18378            buf = new GlobalUint8Array(array, byteOffset);
18379          } else {
18380            buf = new GlobalUint8Array(array, byteOffset, length);
18381          }
18382          Object.setPrototypeOf(buf, Buffer3.prototype);
18383          return buf;
18384        }
18385        function fromObject(obj) {
18386          if (Buffer3.isBuffer(obj)) {
18387            const len3 = checked(obj.length) | 0;
18388            const buf = createBuffer(len3);
18389            if (buf.length === 0) {
18390              return buf;
18391            }
18392            obj.copy(buf, 0, 0, len3);
18393            return buf;
18394          }
18395          if (obj.length !== void 0) {
18396            if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
18397              return createBuffer(0);
18398            }
18399            return fromArrayLike(obj);
18400          }
18401          if (obj.type === "Buffer" && Array.isArray(obj.data)) {
18402            return fromArrayLike(obj.data);
18403          }
18404        }
18405        function checked(length) {
18406          if (length >= K_MAX_LENGTH) {
18407            throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
18408          }
18409          return length | 0;
18410        }
18411        function SlowBuffer(length) {
18412          if (+length != length) {
18413            length = 0;
18414          }
18415          return Buffer3.alloc(+length);
18416        }
18417        Buffer3.isBuffer = function isBuffer2(b) {
18418          return b != null && b._isBuffer === true && b !== Buffer3.prototype;
18419        };
18420        Buffer3.compare = function compare(a, b) {
18421          if (isInstance(a, GlobalUint8Array)) a = Buffer3.from(a, a.offset, a.byteLength);
18422          if (isInstance(b, GlobalUint8Array)) b = Buffer3.from(b, b.offset, b.byteLength);
18423          if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
18424            throw new TypeError(
18425              'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
18426            );
18427          }
18428          if (a === b) return 0;
18429          let x = a.length;
18430          let y = b.length;
18431          for (let i3 = 0, len3 = Math.min(x, y); i3 < len3; ++i3) {
18432            if (a[i3] !== b[i3]) {
18433              x = a[i3];
18434              y = b[i3];
18435              break;
18436            }
18437          }
18438          if (x < y) return -1;
18439          if (y < x) return 1;
18440          return 0;
18441        };
18442        Buffer3.isEncoding = function isEncoding(encoding) {
18443          switch (String(encoding).toLowerCase()) {
18444            case "hex":
18445            case "utf8":
18446            case "utf-8":
18447            case "ascii":
18448            case "latin1":
18449            case "binary":
18450            case "base64":
18451            case "ucs2":
18452            case "ucs-2":
18453            case "utf16le":
18454            case "utf-16le":
18455              return true;
18456            default:
18457              return false;
18458          }
18459        };
18460        Buffer3.concat = function concat(list, length) {
18461          if (!Array.isArray(list)) {
18462            throw new TypeError('"list" argument must be an Array of Buffers');
18463          }
18464          if (list.length === 0) {
18465            return Buffer3.alloc(0);
18466          }
18467          let i3;
18468          if (length === void 0) {
18469            length = 0;
18470            for (i3 = 0; i3 < list.length; ++i3) {
18471              length += list[i3].length;
18472            }
18473          }
18474          const buffer3 = Buffer3.allocUnsafe(length);
18475          let pos = 0;
18476          for (i3 = 0; i3 < list.length; ++i3) {
18477            let buf = list[i3];
18478            if (isInstance(buf, GlobalUint8Array)) {
18479              if (pos + buf.length > buffer3.length) {
18480                if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
18481                buf.copy(buffer3, pos);
18482              } else {
18483                GlobalUint8Array.prototype.set.call(
18484                  buffer3,
18485                  buf,
18486                  pos
18487                );
18488              }
18489            } else if (!Buffer3.isBuffer(buf)) {
18490              throw new TypeError('"list" argument must be an Array of Buffers');
18491            } else {
18492              buf.copy(buffer3, pos);
18493            }
18494            pos += buf.length;
18495          }
18496          return buffer3;
18497        };
18498        function byteLength3(string, encoding) {
18499          if (Buffer3.isBuffer(string)) {
18500            return string.length;
18501          }
18502          if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) {
18503            return string.byteLength;
18504          }
18505          if (typeof string !== "string") {
18506            throw new TypeError(
18507              'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
18508            );
18509          }
18510          const len3 = string.length;
18511          const mustMatch = arguments.length > 2 && arguments[2] === true;
18512          if (!mustMatch && len3 === 0) return 0;
18513          let loweredCase = false;
18514          for (; ; ) {
18515            switch (encoding) {
18516              case "ascii":
18517              case "latin1":
18518              case "binary":
18519                return len3;
18520              case "utf8":
18521              case "utf-8":
18522                return utf8ToBytes(string).length;
18523              case "ucs2":
18524              case "ucs-2":
18525              case "utf16le":
18526              case "utf-16le":
18527                return len3 * 2;
18528              case "hex":
18529                return len3 >>> 1;
18530              case "base64":
18531                return base64ToBytes(string).length;
18532              default:
18533                if (loweredCase) {
18534                  return mustMatch ? -1 : utf8ToBytes(string).length;
18535                }
18536                encoding = ("" + encoding).toLowerCase();
18537                loweredCase = true;
18538            }
18539          }
18540        }
18541        Buffer3.byteLength = byteLength3;
18542        function slowToString(encoding, start, end) {
18543          let loweredCase = false;
18544          if (start === void 0 || start < 0) {
18545            start = 0;
18546          }
18547          if (start > this.length) {
18548            return "";
18549          }
18550          if (end === void 0 || end > this.length) {
18551            end = this.length;
18552          }
18553          if (end <= 0) {
18554            return "";
18555          }
18556          end >>>= 0;
18557          start >>>= 0;
18558          if (end <= start) {
18559            return "";
18560          }
18561          if (!encoding) encoding = "utf8";
18562          while (true) {
18563            switch (encoding) {
18564              case "hex":
18565                return hexSlice(this, start, end);
18566              case "utf8":
18567              case "utf-8":
18568                return utf8Slice(this, start, end);
18569              case "ascii":
18570                return asciiSlice(this, start, end);
18571              case "latin1":
18572              case "binary":
18573                return latin1Slice(this, start, end);
18574              case "base64":
18575                return base64Slice(this, start, end);
18576              case "ucs2":
18577              case "ucs-2":
18578              case "utf16le":
18579              case "utf-16le":
18580                return utf16leSlice(this, start, end);
18581              default:
18582                if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
18583                encoding = (encoding + "").toLowerCase();
18584                loweredCase = true;
18585            }
18586          }
18587        }
18588        Buffer3.prototype._isBuffer = true;
18589        function swap(b, n, m) {
18590          const i3 = b[n];
18591          b[n] = b[m];
18592          b[m] = i3;
18593        }
18594        Buffer3.prototype.swap16 = function swap16() {
18595          const len3 = this.length;
18596          if (len3 % 2 !== 0) {
18597            throw new RangeError("Buffer size must be a multiple of 16-bits");
18598          }
18599          for (let i3 = 0; i3 < len3; i3 += 2) {
18600            swap(this, i3, i3 + 1);
18601          }
18602          return this;
18603        };
18604        Buffer3.prototype.swap32 = function swap32() {
18605          const len3 = this.length;
18606          if (len3 % 4 !== 0) {
18607            throw new RangeError("Buffer size must be a multiple of 32-bits");
18608          }
18609          for (let i3 = 0; i3 < len3; i3 += 4) {
18610            swap(this, i3, i3 + 3);
18611            swap(this, i3 + 1, i3 + 2);
18612          }
18613          return this;
18614        };
18615        Buffer3.prototype.swap64 = function swap64() {
18616          const len3 = this.length;
18617          if (len3 % 8 !== 0) {
18618            throw new RangeError("Buffer size must be a multiple of 64-bits");
18619          }
18620          for (let i3 = 0; i3 < len3; i3 += 8) {
18621            swap(this, i3, i3 + 7);
18622            swap(this, i3 + 1, i3 + 6);
18623            swap(this, i3 + 2, i3 + 5);
18624            swap(this, i3 + 3, i3 + 4);
18625          }
18626          return this;
18627        };
18628        Buffer3.prototype.toString = function toString2() {
18629          const length = this.length;
18630          if (length === 0) return "";
18631          if (arguments.length === 0) return utf8Slice(this, 0, length);
18632          return slowToString.apply(this, arguments);
18633        };
18634        Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
18635        Buffer3.prototype.equals = function equals(b) {
18636          if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
18637          if (this === b) return true;
18638          return Buffer3.compare(this, b) === 0;
18639        };
18640        Buffer3.prototype.inspect = function inspect() {
18641          let str = "";
18642          const max2 = exports$13.INSPECT_MAX_BYTES;
18643          str = this.toString("hex", 0, max2).replace(/(.{2})/g, "$1 ").trim();
18644          if (this.length > max2) str += " ... ";
18645          return "<Buffer " + str + ">";
18646        };
18647        if (customInspectSymbol) {
18648          Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
18649        }
18650        Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
18651          if (isInstance(target, GlobalUint8Array)) {
18652            target = Buffer3.from(target, target.offset, target.byteLength);
18653          }
18654          if (!Buffer3.isBuffer(target)) {
18655            throw new TypeError(
18656              'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
18657            );
18658          }
18659          if (start === void 0) {
18660            start = 0;
18661          }
18662          if (end === void 0) {
18663            end = target ? target.length : 0;
18664          }
18665          if (thisStart === void 0) {
18666            thisStart = 0;
18667          }
18668          if (thisEnd === void 0) {
18669            thisEnd = this.length;
18670          }
18671          if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
18672            throw new RangeError("out of range index");
18673          }
18674          if (thisStart >= thisEnd && start >= end) {
18675            return 0;
18676          }
18677          if (thisStart >= thisEnd) {
18678            return -1;
18679          }
18680          if (start >= end) {
18681            return 1;
18682          }
18683          start >>>= 0;
18684          end >>>= 0;
18685          thisStart >>>= 0;
18686          thisEnd >>>= 0;
18687          if (this === target) return 0;
18688          let x = thisEnd - thisStart;
18689          let y = end - start;
18690          const len3 = Math.min(x, y);
18691          const thisCopy = this.slice(thisStart, thisEnd);
18692          const targetCopy = target.slice(start, end);
18693          for (let i3 = 0; i3 < len3; ++i3) {
18694            if (thisCopy[i3] !== targetCopy[i3]) {
18695              x = thisCopy[i3];
18696              y = targetCopy[i3];
18697              break;
18698            }
18699          }
18700          if (x < y) return -1;
18701          if (y < x) return 1;
18702          return 0;
18703        };
18704        function bidirectionalIndexOf(buffer3, val, byteOffset, encoding, dir) {
18705          if (buffer3.length === 0) return -1;
18706          if (typeof byteOffset === "string") {
18707            encoding = byteOffset;
18708            byteOffset = 0;
18709          } else if (byteOffset > 2147483647) {
18710            byteOffset = 2147483647;
18711          } else if (byteOffset < -2147483648) {
18712            byteOffset = -2147483648;
18713          }
18714          byteOffset = +byteOffset;
18715          if (numberIsNaN(byteOffset)) {
18716            byteOffset = dir ? 0 : buffer3.length - 1;
18717          }
18718          if (byteOffset < 0) byteOffset = buffer3.length + byteOffset;
18719          if (byteOffset >= buffer3.length) {
18720            if (dir) return -1;
18721            else byteOffset = buffer3.length - 1;
18722          } else if (byteOffset < 0) {
18723            if (dir) byteOffset = 0;
18724            else return -1;
18725          }
18726          if (typeof val === "string") {
18727            val = Buffer3.from(val, encoding);
18728          }
18729          if (Buffer3.isBuffer(val)) {
18730            if (val.length === 0) {
18731              return -1;
18732            }
18733            return arrayIndexOf(buffer3, val, byteOffset, encoding, dir);
18734          } else if (typeof val === "number") {
18735            val = val & 255;
18736            if (typeof GlobalUint8Array.prototype.indexOf === "function") {
18737              if (dir) {
18738                return GlobalUint8Array.prototype.indexOf.call(buffer3, val, byteOffset);
18739              } else {
18740                return GlobalUint8Array.prototype.lastIndexOf.call(buffer3, val, byteOffset);
18741              }
18742            }
18743            return arrayIndexOf(buffer3, [val], byteOffset, encoding, dir);
18744          }
18745          throw new TypeError("val must be string, number or Buffer");
18746        }
18747        function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
18748          let indexSize = 1;
18749          let arrLength = arr.length;
18750          let valLength = val.length;
18751          if (encoding !== void 0) {
18752            encoding = String(encoding).toLowerCase();
18753            if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
18754              if (arr.length < 2 || val.length < 2) {
18755                return -1;
18756              }
18757              indexSize = 2;
18758              arrLength /= 2;
18759              valLength /= 2;
18760              byteOffset /= 2;
18761            }
18762          }
18763          function read(buf, i4) {
18764            if (indexSize === 1) {
18765              return buf[i4];
18766            } else {
18767              return buf.readUInt16BE(i4 * indexSize);
18768            }
18769          }
18770          let i3;
18771          if (dir) {
18772            let foundIndex = -1;
18773            for (i3 = byteOffset; i3 < arrLength; i3++) {
18774              if (read(arr, i3) === read(val, foundIndex === -1 ? 0 : i3 - foundIndex)) {
18775                if (foundIndex === -1) foundIndex = i3;
18776                if (i3 - foundIndex + 1 === valLength) return foundIndex * indexSize;
18777              } else {
18778                if (foundIndex !== -1) i3 -= i3 - foundIndex;
18779                foundIndex = -1;
18780              }
18781            }
18782          } else {
18783            if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
18784            for (i3 = byteOffset; i3 >= 0; i3--) {
18785              let found = true;
18786              for (let j = 0; j < valLength; j++) {
18787                if (read(arr, i3 + j) !== read(val, j)) {
18788                  found = false;
18789                  break;
18790                }
18791              }
18792              if (found) return i3;
18793            }
18794          }
18795          return -1;
18796        }
18797        Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
18798          return this.indexOf(val, byteOffset, encoding) !== -1;
18799        };
18800        Buffer3.prototype.indexOf = function indexOf2(val, byteOffset, encoding) {
18801          return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
18802        };
18803        Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
18804          return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
18805        };
18806        function hexWrite(buf, string, offset, length) {
18807          offset = Number(offset) || 0;
18808          const remaining = buf.length - offset;
18809          if (!length) {
18810            length = remaining;
18811          } else {
18812            length = Number(length);
18813            if (length > remaining) {
18814              length = remaining;
18815            }
18816          }
18817          const strLen = string.length;
18818          if (length > strLen / 2) {
18819            length = strLen / 2;
18820          }
18821          let i3;
18822          for (i3 = 0; i3 < length; ++i3) {
18823            const parsed = parseInt(string.substr(i3 * 2, 2), 16);
18824            if (numberIsNaN(parsed)) return i3;
18825            buf[offset + i3] = parsed;
18826          }
18827          return i3;
18828        }
18829        function utf8Write(buf, string, offset, length) {
18830          return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
18831        }
18832        function asciiWrite(buf, string, offset, length) {
18833          return blitBuffer(asciiToBytes(string), buf, offset, length);
18834        }
18835        function base64Write(buf, string, offset, length) {
18836          return blitBuffer(base64ToBytes(string), buf, offset, length);
18837        }
18838        function ucs2Write(buf, string, offset, length) {
18839          return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
18840        }
18841        Buffer3.prototype.write = function write(string, offset, length, encoding) {
18842          if (offset === void 0) {
18843            encoding = "utf8";
18844            length = this.length;
18845            offset = 0;
18846          } else if (length === void 0 && typeof offset === "string") {
18847            encoding = offset;
18848            length = this.length;
18849            offset = 0;
18850          } else if (isFinite(offset)) {
18851            offset = offset >>> 0;
18852            if (isFinite(length)) {
18853              length = length >>> 0;
18854              if (encoding === void 0) encoding = "utf8";
18855            } else {
18856              encoding = length;
18857              length = void 0;
18858            }
18859          } else {
18860            throw new Error(
18861              "Buffer.write(string, encoding, offset[, length]) is no longer supported"
18862            );
18863          }
18864          const remaining = this.length - offset;
18865          if (length === void 0 || length > remaining) length = remaining;
18866          if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
18867            throw new RangeError("Attempt to write outside buffer bounds");
18868          }
18869          if (!encoding) encoding = "utf8";
18870          let loweredCase = false;
18871          for (; ; ) {
18872            switch (encoding) {
18873              case "hex":
18874                return hexWrite(this, string, offset, length);
18875              case "utf8":
18876              case "utf-8":
18877                return utf8Write(this, string, offset, length);
18878              case "ascii":
18879              case "latin1":
18880              case "binary":
18881                return asciiWrite(this, string, offset, length);
18882              case "base64":
18883                return base64Write(this, string, offset, length);
18884              case "ucs2":
18885              case "ucs-2":
18886              case "utf16le":
18887              case "utf-16le":
18888                return ucs2Write(this, string, offset, length);
18889              default:
18890                if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
18891                encoding = ("" + encoding).toLowerCase();
18892                loweredCase = true;
18893            }
18894          }
18895        };
18896        Buffer3.prototype.toJSON = function toJSON() {
18897          return {
18898            type: "Buffer",
18899            data: Array.prototype.slice.call(this._arr || this, 0)
18900          };
18901        };
18902        function base64Slice(buf, start, end) {
18903          if (start === 0 && end === buf.length) {
18904            return base64.fromByteArray(buf);
18905          } else {
18906            return base64.fromByteArray(buf.slice(start, end));
18907          }
18908        }
18909        function utf8Slice(buf, start, end) {
18910          end = Math.min(buf.length, end);
18911          const res = [];
18912          let i3 = start;
18913          while (i3 < end) {
18914            const firstByte = buf[i3];
18915            let codePoint = null;
18916            let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
18917            if (i3 + bytesPerSequence <= end) {
18918              let secondByte, thirdByte, fourthByte, tempCodePoint;
18919              switch (bytesPerSequence) {
18920                case 1:
18921                  if (firstByte < 128) {
18922                    codePoint = firstByte;
18923                  }
18924                  break;
18925                case 2:
18926                  secondByte = buf[i3 + 1];
18927                  if ((secondByte & 192) === 128) {
18928                    tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
18929                    if (tempCodePoint > 127) {
18930                      codePoint = tempCodePoint;
18931                    }
18932                  }
18933                  break;
18934                case 3:
18935                  secondByte = buf[i3 + 1];
18936                  thirdByte = buf[i3 + 2];
18937                  if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
18938                    tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
18939                    if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
18940                      codePoint = tempCodePoint;
18941                    }
18942                  }
18943                  break;
18944                case 4:
18945                  secondByte = buf[i3 + 1];
18946                  thirdByte = buf[i3 + 2];
18947                  fourthByte = buf[i3 + 3];
18948                  if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
18949                    tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
18950                    if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
18951                      codePoint = tempCodePoint;
18952                    }
18953                  }
18954              }
18955            }
18956            if (codePoint === null) {
18957              codePoint = 65533;
18958              bytesPerSequence = 1;
18959            } else if (codePoint > 65535) {
18960              codePoint -= 65536;
18961              res.push(codePoint >>> 10 & 1023 | 55296);
18962              codePoint = 56320 | codePoint & 1023;
18963            }
18964            res.push(codePoint);
18965            i3 += bytesPerSequence;
18966          }
18967          return decodeCodePointsArray(res);
18968        }
18969        const MAX_ARGUMENTS_LENGTH = 4096;
18970        function decodeCodePointsArray(codePoints) {
18971          const len3 = codePoints.length;
18972          if (len3 <= MAX_ARGUMENTS_LENGTH) {
18973            return String.fromCharCode.apply(String, codePoints);
18974          }
18975          let res = "";
18976          let i3 = 0;
18977          while (i3 < len3) {
18978            res += String.fromCharCode.apply(
18979              String,
18980              codePoints.slice(i3, i3 += MAX_ARGUMENTS_LENGTH)
18981            );
18982          }
18983          return res;
18984        }
18985        function asciiSlice(buf, start, end) {
18986          let ret = "";
18987          end = Math.min(buf.length, end);
18988          for (let i3 = start; i3 < end; ++i3) {
18989            ret += String.fromCharCode(buf[i3] & 127);
18990          }
18991          return ret;
18992        }
18993        function latin1Slice(buf, start, end) {
18994          let ret = "";
18995          end = Math.min(buf.length, end);
18996          for (let i3 = start; i3 < end; ++i3) {
18997            ret += String.fromCharCode(buf[i3]);
18998          }
18999          return ret;
19000        }
19001        function hexSlice(buf, start, end) {
19002          const len3 = buf.length;
19003          if (!start || start < 0) start = 0;
19004          if (!end || end < 0 || end > len3) end = len3;
19005          let out = "";
19006          for (let i3 = start; i3 < end; ++i3) {
19007            out += hexSliceLookupTable[buf[i3]];
19008          }
19009          return out;
19010        }
19011        function utf16leSlice(buf, start, end) {
19012          const bytes = buf.slice(start, end);
19013          let res = "";
19014          for (let i3 = 0; i3 < bytes.length - 1; i3 += 2) {
19015            res += String.fromCharCode(bytes[i3] + bytes[i3 + 1] * 256);
19016          }
19017          return res;
19018        }
19019        Buffer3.prototype.slice = function slice(start, end) {
19020          const len3 = this.length;
19021          start = ~~start;
19022          end = end === void 0 ? len3 : ~~end;
19023          if (start < 0) {
19024            start += len3;
19025            if (start < 0) start = 0;
19026          } else if (start > len3) {
19027            start = len3;
19028          }
19029          if (end < 0) {
19030            end += len3;
19031            if (end < 0) end = 0;
19032          } else if (end > len3) {
19033            end = len3;
19034          }
19035          if (end < start) end = start;
19036          const newBuf = this.subarray(start, end);
19037          Object.setPrototypeOf(newBuf, Buffer3.prototype);
19038          return newBuf;
19039        };
19040        function checkOffset(offset, ext, length) {
19041          if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
19042          if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
19043        }
19044        Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength4, noAssert) {
19045          offset = offset >>> 0;
19046          byteLength4 = byteLength4 >>> 0;
19047          if (!noAssert) checkOffset(offset, byteLength4, this.length);
19048          let val = this[offset];
19049          let mul = 1;
19050          let i3 = 0;
19051          while (++i3 < byteLength4 && (mul *= 256)) {
19052            val += this[offset + i3] * mul;
19053          }
19054          return val;
19055        };
19056        Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength4, noAssert) {
19057          offset = offset >>> 0;
19058          byteLength4 = byteLength4 >>> 0;
19059          if (!noAssert) {
19060            checkOffset(offset, byteLength4, this.length);
19061          }
19062          let val = this[offset + --byteLength4];
19063          let mul = 1;
19064          while (byteLength4 > 0 && (mul *= 256)) {
19065            val += this[offset + --byteLength4] * mul;
19066          }
19067          return val;
19068        };
19069        Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
19070          offset = offset >>> 0;
19071          if (!noAssert) checkOffset(offset, 1, this.length);
19072          return this[offset];
19073        };
19074        Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
19075          offset = offset >>> 0;
19076          if (!noAssert) checkOffset(offset, 2, this.length);
19077          return this[offset] | this[offset + 1] << 8;
19078        };
19079        Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
19080          offset = offset >>> 0;
19081          if (!noAssert) checkOffset(offset, 2, this.length);
19082          return this[offset] << 8 | this[offset + 1];
19083        };
19084        Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
19085          offset = offset >>> 0;
19086          if (!noAssert) checkOffset(offset, 4, this.length);
19087          return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
19088        };
19089        Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
19090          offset = offset >>> 0;
19091          if (!noAssert) checkOffset(offset, 4, this.length);
19092          return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
19093        };
19094        Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
19095          offset = offset >>> 0;
19096          validateNumber(offset, "offset");
19097          const first = this[offset];
19098          const last = this[offset + 7];
19099          if (first === void 0 || last === void 0) {
19100            boundsError(offset, this.length - 8);
19101          }
19102          const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
19103          const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
19104          return BigInt(lo) + (BigInt(hi) << BigInt(32));
19105        });
19106        Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
19107          offset = offset >>> 0;
19108          validateNumber(offset, "offset");
19109          const first = this[offset];
19110          const last = this[offset + 7];
19111          if (first === void 0 || last === void 0) {
19112            boundsError(offset, this.length - 8);
19113          }
19114          const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
19115          const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
19116          return (BigInt(hi) << BigInt(32)) + BigInt(lo);
19117        });
19118        Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength4, noAssert) {
19119          offset = offset >>> 0;
19120          byteLength4 = byteLength4 >>> 0;
19121          if (!noAssert) checkOffset(offset, byteLength4, this.length);
19122          let val = this[offset];
19123          let mul = 1;
19124          let i3 = 0;
19125          while (++i3 < byteLength4 && (mul *= 256)) {
19126            val += this[offset + i3] * mul;
19127          }
19128          mul *= 128;
19129          if (val >= mul) val -= Math.pow(2, 8 * byteLength4);
19130          return val;
19131        };
19132        Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength4, noAssert) {
19133          offset = offset >>> 0;
19134          byteLength4 = byteLength4 >>> 0;
19135          if (!noAssert) checkOffset(offset, byteLength4, this.length);
19136          let i3 = byteLength4;
19137          let mul = 1;
19138          let val = this[offset + --i3];
19139          while (i3 > 0 && (mul *= 256)) {
19140            val += this[offset + --i3] * mul;
19141          }
19142          mul *= 128;
19143          if (val >= mul) val -= Math.pow(2, 8 * byteLength4);
19144          return val;
19145        };
19146        Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
19147          offset = offset >>> 0;
19148          if (!noAssert) checkOffset(offset, 1, this.length);
19149          if (!(this[offset] & 128)) return this[offset];
19150          return (255 - this[offset] + 1) * -1;
19151        };
19152        Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
19153          offset = offset >>> 0;
19154          if (!noAssert) checkOffset(offset, 2, this.length);
19155          const val = this[offset] | this[offset + 1] << 8;
19156          return val & 32768 ? val | 4294901760 : val;
19157        };
19158        Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
19159          offset = offset >>> 0;
19160          if (!noAssert) checkOffset(offset, 2, this.length);
19161          const val = this[offset + 1] | this[offset] << 8;
19162          return val & 32768 ? val | 4294901760 : val;
19163        };
19164        Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
19165          offset = offset >>> 0;
19166          if (!noAssert) checkOffset(offset, 4, this.length);
19167          return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
19168        };
19169        Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
19170          offset = offset >>> 0;
19171          if (!noAssert) checkOffset(offset, 4, this.length);
19172          return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
19173        };
19174        Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
19175          offset = offset >>> 0;
19176          validateNumber(offset, "offset");
19177          const first = this[offset];
19178          const last = this[offset + 7];
19179          if (first === void 0 || last === void 0) {
19180            boundsError(offset, this.length - 8);
19181          }
19182          const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
19183          return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
19184        });
19185        Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
19186          offset = offset >>> 0;
19187          validateNumber(offset, "offset");
19188          const first = this[offset];
19189          const last = this[offset + 7];
19190          if (first === void 0 || last === void 0) {
19191            boundsError(offset, this.length - 8);
19192          }
19193          const val = (first << 24) + // Overflow
19194          this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
19195          return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
19196        });
19197        Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
19198          offset = offset >>> 0;
19199          if (!noAssert) checkOffset(offset, 4, this.length);
19200          return ieee754$1.read(this, offset, true, 23, 4);
19201        };
19202        Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
19203          offset = offset >>> 0;
19204          if (!noAssert) checkOffset(offset, 4, this.length);
19205          return ieee754$1.read(this, offset, false, 23, 4);
19206        };
19207        Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
19208          offset = offset >>> 0;
19209          if (!noAssert) checkOffset(offset, 8, this.length);
19210          return ieee754$1.read(this, offset, true, 52, 8);
19211        };
19212        Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
19213          offset = offset >>> 0;
19214          if (!noAssert) checkOffset(offset, 8, this.length);
19215          return ieee754$1.read(this, offset, false, 52, 8);
19216        };
19217        function checkInt(buf, value, offset, ext, max2, min2) {
19218          if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
19219          if (value > max2 || value < min2) throw new RangeError('"value" argument is out of bounds');
19220          if (offset + ext > buf.length) throw new RangeError("Index out of range");
19221        }
19222        Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength4, noAssert) {
19223          value = +value;
19224          offset = offset >>> 0;
19225          byteLength4 = byteLength4 >>> 0;
19226          if (!noAssert) {
19227            const maxBytes = Math.pow(2, 8 * byteLength4) - 1;
19228            checkInt(this, value, offset, byteLength4, maxBytes, 0);
19229          }
19230          let mul = 1;
19231          let i3 = 0;
19232          this[offset] = value & 255;
19233          while (++i3 < byteLength4 && (mul *= 256)) {
19234            this[offset + i3] = value / mul & 255;
19235          }
19236          return offset + byteLength4;
19237        };
19238        Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength4, noAssert) {
19239          value = +value;
19240          offset = offset >>> 0;
19241          byteLength4 = byteLength4 >>> 0;
19242          if (!noAssert) {
19243            const maxBytes = Math.pow(2, 8 * byteLength4) - 1;
19244            checkInt(this, value, offset, byteLength4, maxBytes, 0);
19245          }
19246          let i3 = byteLength4 - 1;
19247          let mul = 1;
19248          this[offset + i3] = value & 255;
19249          while (--i3 >= 0 && (mul *= 256)) {
19250            this[offset + i3] = value / mul & 255;
19251          }
19252          return offset + byteLength4;
19253        };
19254        Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
19255          value = +value;
19256          offset = offset >>> 0;
19257          if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
19258          this[offset] = value & 255;
19259          return offset + 1;
19260        };

vendor: 5,271 bytes, lines 19261-19388

19261        Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
19262          value = +value;
19263          offset = offset >>> 0;
19264          if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
19265          this[offset] = value & 255;
19266          this[offset + 1] = value >>> 8;
19267          return offset + 2;
19268        };
19269        Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
19270          value = +value;
19271          offset = offset >>> 0;
19272          if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
19273          this[offset] = value >>> 8;
19274          this[offset + 1] = value & 255;
19275          return offset + 2;
19276        };
19277        Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
19278          value = +value;
19279          offset = offset >>> 0;
19280          if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
19281          this[offset + 3] = value >>> 24;
19282          this[offset + 2] = value >>> 16;
19283          this[offset + 1] = value >>> 8;
19284          this[offset] = value & 255;
19285          return offset + 4;
19286        };
19287        Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
19288          value = +value;
19289          offset = offset >>> 0;
19290          if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
19291          this[offset] = value >>> 24;
19292          this[offset + 1] = value >>> 16;
19293          this[offset + 2] = value >>> 8;
19294          this[offset + 3] = value & 255;
19295          return offset + 4;
19296        };
19297        function wrtBigUInt64LE(buf, value, offset, min2, max2) {
19298          checkIntBI(value, min2, max2, buf, offset, 7);
19299          let lo = Number(value & BigInt(4294967295));
19300          buf[offset++] = lo;
19301          lo = lo >> 8;
19302          buf[offset++] = lo;
19303          lo = lo >> 8;
19304          buf[offset++] = lo;
19305          lo = lo >> 8;
19306          buf[offset++] = lo;
19307          let hi = Number(value >> BigInt(32) & BigInt(4294967295));
19308          buf[offset++] = hi;
19309          hi = hi >> 8;
19310          buf[offset++] = hi;
19311          hi = hi >> 8;
19312          buf[offset++] = hi;
19313          hi = hi >> 8;
19314          buf[offset++] = hi;
19315          return offset;
19316        }
19317        function wrtBigUInt64BE(buf, value, offset, min2, max2) {
19318          checkIntBI(value, min2, max2, buf, offset, 7);
19319          let lo = Number(value & BigInt(4294967295));
19320          buf[offset + 7] = lo;
19321          lo = lo >> 8;
19322          buf[offset + 6] = lo;
19323          lo = lo >> 8;
19324          buf[offset + 5] = lo;
19325          lo = lo >> 8;
19326          buf[offset + 4] = lo;
19327          let hi = Number(value >> BigInt(32) & BigInt(4294967295));
19328          buf[offset + 3] = hi;
19329          hi = hi >> 8;
19330          buf[offset + 2] = hi;
19331          hi = hi >> 8;
19332          buf[offset + 1] = hi;
19333          hi = hi >> 8;
19334          buf[offset] = hi;
19335          return offset + 8;
19336        }
19337        Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
19338          return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
19339        });
19340        Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
19341          return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
19342        });
19343        Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength4, noAssert) {
19344          value = +value;
19345          offset = offset >>> 0;
19346          if (!noAssert) {
19347            const limit = Math.pow(2, 8 * byteLength4 - 1);
19348            checkInt(this, value, offset, byteLength4, limit - 1, -limit);
19349          }
19350          let i3 = 0;
19351          let mul = 1;
19352          let sub = 0;
19353          this[offset] = value & 255;
19354          while (++i3 < byteLength4 && (mul *= 256)) {
19355            if (value < 0 && sub === 0 && this[offset + i3 - 1] !== 0) {
19356              sub = 1;
19357            }
19358            this[offset + i3] = (value / mul >> 0) - sub & 255;
19359          }
19360          return offset + byteLength4;
19361        };
19362        Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength4, noAssert) {
19363          value = +value;
19364          offset = offset >>> 0;
19365          if (!noAssert) {
19366            const limit = Math.pow(2, 8 * byteLength4 - 1);
19367            checkInt(this, value, offset, byteLength4, limit - 1, -limit);
19368          }
19369          let i3 = byteLength4 - 1;
19370          let mul = 1;
19371          let sub = 0;
19372          this[offset + i3] = value & 255;
19373          while (--i3 >= 0 && (mul *= 256)) {
19374            if (value < 0 && sub === 0 && this[offset + i3 + 1] !== 0) {
19375              sub = 1;
19376            }
19377            this[offset + i3] = (value / mul >> 0) - sub & 255;
19378          }
19379          return offset + byteLength4;
19380        };
19381        Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
19382          value = +value;
19383          offset = offset >>> 0;
19384          if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
19385          if (value < 0) value = 255 + value + 1;
19386          this[offset] = value & 255;
19387          return offset + 1;
19388        };

vendor: 15,038 bytes, lines 19389-19771

19389        Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
19390          value = +value;
19391          offset = offset >>> 0;
19392          if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
19393          this[offset] = value & 255;
19394          this[offset + 1] = value >>> 8;
19395          return offset + 2;
19396        };
19397        Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
19398          value = +value;
19399          offset = offset >>> 0;
19400          if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
19401          this[offset] = value >>> 8;
19402          this[offset + 1] = value & 255;
19403          return offset + 2;
19404        };
19405        Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
19406          value = +value;
19407          offset = offset >>> 0;
19408          if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
19409          this[offset] = value & 255;
19410          this[offset + 1] = value >>> 8;
19411          this[offset + 2] = value >>> 16;
19412          this[offset + 3] = value >>> 24;
19413          return offset + 4;
19414        };
19415        Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
19416          value = +value;
19417          offset = offset >>> 0;
19418          if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
19419          if (value < 0) value = 4294967295 + value + 1;
19420          this[offset] = value >>> 24;
19421          this[offset + 1] = value >>> 16;
19422          this[offset + 2] = value >>> 8;
19423          this[offset + 3] = value & 255;
19424          return offset + 4;
19425        };
19426        Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
19427          return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
19428        });
19429        Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
19430          return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
19431        });
19432        function checkIEEE754(buf, value, offset, ext, max2, min2) {
19433          if (offset + ext > buf.length) throw new RangeError("Index out of range");
19434          if (offset < 0) throw new RangeError("Index out of range");
19435        }
19436        function writeFloat(buf, value, offset, littleEndian, noAssert) {
19437          value = +value;
19438          offset = offset >>> 0;
19439          if (!noAssert) {
19440            checkIEEE754(buf, value, offset, 4);
19441          }
19442          ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
19443          return offset + 4;
19444        }
19445        Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
19446          return writeFloat(this, value, offset, true, noAssert);
19447        };
19448        Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
19449          return writeFloat(this, value, offset, false, noAssert);
19450        };
19451        function writeDouble(buf, value, offset, littleEndian, noAssert) {
19452          value = +value;
19453          offset = offset >>> 0;
19454          if (!noAssert) {
19455            checkIEEE754(buf, value, offset, 8);
19456          }
19457          ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
19458          return offset + 8;
19459        }
19460        Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
19461          return writeDouble(this, value, offset, true, noAssert);
19462        };
19463        Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
19464          return writeDouble(this, value, offset, false, noAssert);
19465        };
19466        Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
19467          if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
19468          if (!start) start = 0;
19469          if (!end && end !== 0) end = this.length;
19470          if (targetStart >= target.length) targetStart = target.length;
19471          if (!targetStart) targetStart = 0;
19472          if (end > 0 && end < start) end = start;
19473          if (end === start) return 0;
19474          if (target.length === 0 || this.length === 0) return 0;
19475          if (targetStart < 0) {
19476            throw new RangeError("targetStart out of bounds");
19477          }
19478          if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
19479          if (end < 0) throw new RangeError("sourceEnd out of bounds");
19480          if (end > this.length) end = this.length;
19481          if (target.length - targetStart < end - start) {
19482            end = target.length - targetStart + start;
19483          }
19484          const len3 = end - start;
19485          if (this === target && typeof GlobalUint8Array.prototype.copyWithin === "function") {
19486            this.copyWithin(targetStart, start, end);
19487          } else {
19488            GlobalUint8Array.prototype.set.call(
19489              target,
19490              this.subarray(start, end),
19491              targetStart
19492            );
19493          }
19494          return len3;
19495        };
19496        Buffer3.prototype.fill = function fill(val, start, end, encoding) {
19497          if (typeof val === "string") {
19498            if (typeof start === "string") {
19499              encoding = start;
19500              start = 0;
19501              end = this.length;
19502            } else if (typeof end === "string") {
19503              encoding = end;
19504              end = this.length;
19505            }
19506            if (encoding !== void 0 && typeof encoding !== "string") {
19507              throw new TypeError("encoding must be a string");
19508            }
19509            if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
19510              throw new TypeError("Unknown encoding: " + encoding);
19511            }
19512            if (val.length === 1) {
19513              const code3 = val.charCodeAt(0);
19514              if (encoding === "utf8" && code3 < 128 || encoding === "latin1") {
19515                val = code3;
19516              }
19517            }
19518          } else if (typeof val === "number") {
19519            val = val & 255;
19520          } else if (typeof val === "boolean") {
19521            val = Number(val);
19522          }
19523          if (start < 0 || this.length < start || this.length < end) {
19524            throw new RangeError("Out of range index");
19525          }
19526          if (end <= start) {
19527            return this;
19528          }
19529          start = start >>> 0;
19530          end = end === void 0 ? this.length : end >>> 0;
19531          if (!val) val = 0;
19532          let i3;
19533          if (typeof val === "number") {
19534            for (i3 = start; i3 < end; ++i3) {
19535              this[i3] = val;
19536            }
19537          } else {
19538            const bytes = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
19539            const len3 = bytes.length;
19540            if (len3 === 0) {
19541              throw new TypeError('The value "' + val + '" is invalid for argument "value"');
19542            }
19543            for (i3 = 0; i3 < end - start; ++i3) {
19544              this[i3 + start] = bytes[i3 % len3];
19545            }
19546          }
19547          return this;
19548        };
19549        const errors2 = {};
19550        function E(sym, getMessage, Base) {
19551          errors2[sym] = class NodeError extends Base {
19552            constructor() {
19553              super();
19554              Object.defineProperty(this, "message", {
19555                value: getMessage.apply(this, arguments),
19556                writable: true,
19557                configurable: true
19558              });
19559              this.name = `${this.name} [${sym}]`;
19560              this.stack;
19561              delete this.name;
19562            }
19563            get code() {
19564              return sym;
19565            }
19566            set code(value) {
19567              Object.defineProperty(this, "code", {
19568                configurable: true,
19569                enumerable: true,
19570                value,
19571                writable: true
19572              });
19573            }
19574            toString() {
19575              return `${this.name} [${sym}]: ${this.message}`;
19576            }
19577          };
19578        }
19579        E(
19580          "ERR_BUFFER_OUT_OF_BOUNDS",
19581          function(name) {
19582            if (name) {
19583              return `${name} is outside of buffer bounds`;
19584            }
19585            return "Attempt to access memory outside buffer bounds";
19586          },
19587          RangeError
19588        );
19589        E(
19590          "ERR_INVALID_ARG_TYPE",
19591          function(name, actual) {
19592            return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
19593          },
19594          TypeError
19595        );
19596        E(
19597          "ERR_OUT_OF_RANGE",
19598          function(str, range2, input) {
19599            let msg = `The value of "${str}" is out of range.`;
19600            let received = input;
19601            if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
19602              received = addNumericalSeparator(String(input));
19603            } else if (typeof input === "bigint") {
19604              received = String(input);
19605              if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
19606                received = addNumericalSeparator(received);
19607              }
19608              received += "n";
19609            }
19610            msg += ` It must be ${range2}. Received ${received}`;
19611            return msg;
19612          },
19613          RangeError
19614        );
19615        function addNumericalSeparator(val) {
19616          let res = "";
19617          let i3 = val.length;
19618          const start = val[0] === "-" ? 1 : 0;
19619          for (; i3 >= start + 4; i3 -= 3) {
19620            res = `_${val.slice(i3 - 3, i3)}${res}`;
19621          }
19622          return `${val.slice(0, i3)}${res}`;
19623        }
19624        function checkBounds(buf, offset, byteLength4) {
19625          validateNumber(offset, "offset");
19626          if (buf[offset] === void 0 || buf[offset + byteLength4] === void 0) {
19627            boundsError(offset, buf.length - (byteLength4 + 1));
19628          }
19629        }
19630        function checkIntBI(value, min2, max2, buf, offset, byteLength4) {
19631          if (value > max2 || value < min2) {
19632            const n = typeof min2 === "bigint" ? "n" : "";
19633            let range2;
19634            {
19635              if (min2 === 0 || min2 === BigInt(0)) {
19636                range2 = `>= 0${n} and < 2${n} ** ${(byteLength4 + 1) * 8}${n}`;
19637              } else {
19638                range2 = `>= -(2${n} ** ${(byteLength4 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength4 + 1) * 8 - 1}${n}`;
19639              }
19640            }
19641            throw new errors2.ERR_OUT_OF_RANGE("value", range2, value);
19642          }
19643          checkBounds(buf, offset, byteLength4);
19644        }
19645        function validateNumber(value, name) {
19646          if (typeof value !== "number") {
19647            throw new errors2.ERR_INVALID_ARG_TYPE(name, "number", value);
19648          }
19649        }
19650        function boundsError(value, length, type2) {
19651          if (Math.floor(value) !== value) {
19652            validateNumber(value, type2);
19653            throw new errors2.ERR_OUT_OF_RANGE("offset", "an integer", value);
19654          }
19655          if (length < 0) {
19656            throw new errors2.ERR_BUFFER_OUT_OF_BOUNDS();
19657          }
19658          throw new errors2.ERR_OUT_OF_RANGE(
19659            "offset",
19660            `>= ${0} and <= ${length}`,
19661            value
19662          );
19663        }
19664        const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
19665        function base64clean(str) {
19666          str = str.split("=")[0];
19667          str = str.trim().replace(INVALID_BASE64_RE, "");
19668          if (str.length < 2) return "";
19669          while (str.length % 4 !== 0) {
19670            str = str + "=";
19671          }
19672          return str;
19673        }
19674        function utf8ToBytes(string, units) {
19675          units = units || Infinity;
19676          let codePoint;
19677          const length = string.length;
19678          let leadSurrogate = null;
19679          const bytes = [];
19680          for (let i3 = 0; i3 < length; ++i3) {
19681            codePoint = string.charCodeAt(i3);
19682            if (codePoint > 55295 && codePoint < 57344) {
19683              if (!leadSurrogate) {
19684                if (codePoint > 56319) {
19685                  if ((units -= 3) > -1) bytes.push(239, 191, 189);
19686                  continue;
19687                } else if (i3 + 1 === length) {
19688                  if ((units -= 3) > -1) bytes.push(239, 191, 189);
19689                  continue;
19690                }
19691                leadSurrogate = codePoint;
19692                continue;
19693              }
19694              if (codePoint < 56320) {
19695                if ((units -= 3) > -1) bytes.push(239, 191, 189);
19696                leadSurrogate = codePoint;
19697                continue;
19698              }
19699              codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
19700            } else if (leadSurrogate) {
19701              if ((units -= 3) > -1) bytes.push(239, 191, 189);
19702            }
19703            leadSurrogate = null;
19704            if (codePoint < 128) {
19705              if ((units -= 1) < 0) break;
19706              bytes.push(codePoint);
19707            } else if (codePoint < 2048) {
19708              if ((units -= 2) < 0) break;
19709              bytes.push(
19710                codePoint >> 6 | 192,
19711                codePoint & 63 | 128
19712              );
19713            } else if (codePoint < 65536) {
19714              if ((units -= 3) < 0) break;
19715              bytes.push(
19716                codePoint >> 12 | 224,
19717                codePoint >> 6 & 63 | 128,
19718                codePoint & 63 | 128
19719              );
19720            } else if (codePoint < 1114112) {
19721              if ((units -= 4) < 0) break;
19722              bytes.push(
19723                codePoint >> 18 | 240,
19724                codePoint >> 12 & 63 | 128,
19725                codePoint >> 6 & 63 | 128,
19726                codePoint & 63 | 128
19727              );
19728            } else {
19729              throw new Error("Invalid code point");
19730            }
19731          }
19732          return bytes;
19733        }
19734        function asciiToBytes(str) {
19735          const byteArray = [];
19736          for (let i3 = 0; i3 < str.length; ++i3) {
19737            byteArray.push(str.charCodeAt(i3) & 255);
19738          }
19739          return byteArray;
19740        }
19741        function utf16leToBytes(str, units) {
19742          let c, hi, lo;
19743          const byteArray = [];
19744          for (let i3 = 0; i3 < str.length; ++i3) {
19745            if ((units -= 2) < 0) break;
19746            c = str.charCodeAt(i3);
19747            hi = c >> 8;
19748            lo = c % 256;
19749            byteArray.push(lo);
19750            byteArray.push(hi);
19751          }
19752          return byteArray;
19753        }
19754        function base64ToBytes(str) {
19755          return base64.toByteArray(base64clean(str));
19756        }
19757        function blitBuffer(src2, dst, offset, length) {
19758          let i3;
19759          for (i3 = 0; i3 < length; ++i3) {
19760            if (i3 + offset >= dst.length || i3 >= src2.length) break;
19761            dst[i3 + offset] = src2[i3];
19762          }
19763          return i3;
19764        }
19765        function isInstance(obj, type2) {
19766          return obj instanceof type2 || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type2.name;
19767        }
19768        function numberIsNaN(obj) {
19769          return obj !== obj;
19770        }
19771        const hexSliceLookupTable = (function() {

vendor: 9,460 bytes, lines 19772-20046

19772          const alphabet = "0123456789abcdef";
19773          const table = new Array(256);
19774          for (let i3 = 0; i3 < 16; ++i3) {
19775            const i16 = i3 * 16;
19776            for (let j = 0; j < 16; ++j) {
19777              table[i16 + j] = alphabet[i3] + alphabet[j];
19778            }
19779          }
19780          return table;
19781        })();
19782        function defineBigIntMethod(fn) {
19783          return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
19784        }
19785        function BufferBigIntNotDefined() {
19786          throw new Error("BigInt not supported");
19787        }
19788      })(buffer2);
19789      const Buffer2 = buffer2.Buffer;
19790      exports$12.Blob = buffer2.Blob;
19791      exports$12.BlobOptions = buffer2.BlobOptions;
19792      exports$12.Buffer = buffer2.Buffer;
19793      exports$12.File = buffer2.File;
19794      exports$12.FileOptions = buffer2.FileOptions;
19795      exports$12.INSPECT_MAX_BYTES = buffer2.INSPECT_MAX_BYTES;
19796      exports$12.SlowBuffer = buffer2.SlowBuffer;
19797      exports$12.TranscodeEncoding = buffer2.TranscodeEncoding;
19798      exports$12.atob = buffer2.atob;
19799      exports$12.btoa = buffer2.btoa;
19800      exports$12.constants = buffer2.constants;
19801      exports$12.default = Buffer2;
19802      exports$12.isAscii = buffer2.isAscii;
19803      exports$12.isUtf8 = buffer2.isUtf8;
19804      exports$12.kMaxLength = buffer2.kMaxLength;
19805      exports$12.kStringMaxLength = buffer2.kStringMaxLength;
19806      exports$12.resolveObjectURL = buffer2.resolveObjectURL;
19807      exports$12.transcode = buffer2.transcode;
19808    })(dist);
19809    return dist;
19810  }
19811  var buffer_list;
19812  var hasRequiredBuffer_list;
19813  function requireBuffer_list() {
19814    if (hasRequiredBuffer_list) return buffer_list;
19815    hasRequiredBuffer_list = 1;
19816    function ownKeys(object, enumerableOnly) {
19817      var keys = Object.keys(object);
19818      if (Object.getOwnPropertySymbols) {
19819        var symbols = Object.getOwnPropertySymbols(object);
19820        enumerableOnly && (symbols = symbols.filter(function(sym) {
19821          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
19822        })), keys.push.apply(keys, symbols);
19823      }
19824      return keys;
19825    }
19826    function _objectSpread(target) {
19827      for (var i2 = 1; i2 < arguments.length; i2++) {
19828        var source = null != arguments[i2] ? arguments[i2] : {};
19829        i2 % 2 ? ownKeys(Object(source), true).forEach(function(key2) {
19830          _defineProperty(target, key2, source[key2]);
19831        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key2) {
19832          Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2));
19833        });
19834      }
19835      return target;
19836    }
19837    function _defineProperty(obj, key2, value) {
19838      key2 = _toPropertyKey(key2);
19839      if (key2 in obj) {
19840        Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
19841      } else {
19842        obj[key2] = value;
19843      }
19844      return obj;
19845    }
19846    function _classCallCheck(instance, Constructor) {
19847      if (!(instance instanceof Constructor)) {
19848        throw new TypeError("Cannot call a class as a function");
19849      }
19850    }
19851    function _defineProperties(target, props) {
19852      for (var i2 = 0; i2 < props.length; i2++) {
19853        var descriptor = props[i2];
19854        descriptor.enumerable = descriptor.enumerable || false;
19855        descriptor.configurable = true;
19856        if ("value" in descriptor) descriptor.writable = true;
19857        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
19858      }
19859    }
19860    function _createClass(Constructor, protoProps, staticProps) {
19861      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
19862      Object.defineProperty(Constructor, "prototype", { writable: false });
19863      return Constructor;
19864    }
19865    function _toPropertyKey(arg) {
19866      var key2 = _toPrimitive(arg, "string");
19867      return typeof key2 === "symbol" ? key2 : String(key2);
19868    }
19869    function _toPrimitive(input, hint) {
19870      if (typeof input !== "object" || input === null) return input;
19871      var prim = input[Symbol.toPrimitive];
19872      if (prim !== void 0) {
19873        var res = prim.call(input, hint);
19874        if (typeof res !== "object") return res;
19875        throw new TypeError("@@toPrimitive must return a primitive value.");
19876      }
19877      return String(input);
19878    }
19879    var _require = requireDist(), Buffer2 = _require.Buffer;
19880    var _require2 = requireUtil$1(), inspect = _require2.inspect;
19881    var custom = inspect && inspect.custom || "inspect";
19882    function copyBuffer(src2, target, offset) {
19883      Buffer2.prototype.copy.call(src2, target, offset);
19884    }
19885    buffer_list = /* @__PURE__ */ (function() {
19886      function BufferList2() {
19887        _classCallCheck(this, BufferList2);
19888        this.head = null;
19889        this.tail = null;
19890        this.length = 0;
19891      }
19892      _createClass(BufferList2, [{
19893        key: "push",
19894        value: function push(v) {
19895          var entry = {
19896            data: v,
19897            next: null
19898          };
19899          if (this.length > 0) this.tail.next = entry;
19900          else this.head = entry;
19901          this.tail = entry;
19902          ++this.length;
19903        }
19904      }, {
19905        key: "unshift",
19906        value: function unshift(v) {
19907          var entry = {
19908            data: v,
19909            next: this.head
19910          };
19911          if (this.length === 0) this.tail = entry;
19912          this.head = entry;
19913          ++this.length;
19914        }
19915      }, {
19916        key: "shift",
19917        value: function shift() {
19918          if (this.length === 0) return;
19919          var ret = this.head.data;
19920          if (this.length === 1) this.head = this.tail = null;
19921          else this.head = this.head.next;
19922          --this.length;
19923          return ret;
19924        }
19925      }, {
19926        key: "clear",
19927        value: function clear() {
19928          this.head = this.tail = null;
19929          this.length = 0;
19930        }
19931      }, {
19932        key: "join",
19933        value: function join(s) {
19934          if (this.length === 0) return "";
19935          var p = this.head;
19936          var ret = "" + p.data;
19937          while (p = p.next) ret += s + p.data;
19938          return ret;
19939        }
19940      }, {
19941        key: "concat",
19942        value: function concat(n) {
19943          if (this.length === 0) return Buffer2.alloc(0);
19944          var ret = Buffer2.allocUnsafe(n >>> 0);
19945          var p = this.head;
19946          var i2 = 0;
19947          while (p) {
19948            copyBuffer(p.data, ret, i2);
19949            i2 += p.data.length;
19950            p = p.next;
19951          }
19952          return ret;
19953        }
19954        // Consumes a specified amount of bytes or characters from the buffered data.
19955      }, {
19956        key: "consume",
19957        value: function consume(n, hasStrings) {
19958          var ret;
19959          if (n < this.head.data.length) {
19960            ret = this.head.data.slice(0, n);
19961            this.head.data = this.head.data.slice(n);
19962          } else if (n === this.head.data.length) {
19963            ret = this.shift();
19964          } else {
19965            ret = hasStrings ? this._getString(n) : this._getBuffer(n);
19966          }
19967          return ret;
19968        }
19969      }, {
19970        key: "first",
19971        value: function first() {
19972          return this.head.data;
19973        }
19974        // Consumes a specified amount of characters from the buffered data.
19975      }, {
19976        key: "_getString",
19977        value: function _getString(n) {
19978          var p = this.head;
19979          var c = 1;
19980          var ret = p.data;
19981          n -= ret.length;
19982          while (p = p.next) {
19983            var str = p.data;
19984            var nb = n > str.length ? str.length : n;
19985            if (nb === str.length) ret += str;
19986            else ret += str.slice(0, n);
19987            n -= nb;
19988            if (n === 0) {
19989              if (nb === str.length) {
19990                ++c;
19991                if (p.next) this.head = p.next;
19992                else this.head = this.tail = null;
19993              } else {
19994                this.head = p;
19995                p.data = str.slice(nb);
19996              }
19997              break;
19998            }
19999            ++c;
20000          }
20001          this.length -= c;
20002          return ret;
20003        }
20004        // Consumes a specified amount of bytes from the buffered data.
20005      }, {
20006        key: "_getBuffer",
20007        value: function _getBuffer(n) {
20008          var ret = Buffer2.allocUnsafe(n);
20009          var p = this.head;
20010          var c = 1;
20011          p.data.copy(ret);
20012          n -= p.data.length;
20013          while (p = p.next) {
20014            var buf = p.data;
20015            var nb = n > buf.length ? buf.length : n;
20016            buf.copy(ret, ret.length - n, 0, nb);
20017            n -= nb;
20018            if (n === 0) {
20019              if (nb === buf.length) {
20020                ++c;
20021                if (p.next) this.head = p.next;
20022                else this.head = this.tail = null;
20023              } else {
20024                this.head = p;
20025                p.data = buf.slice(nb);
20026              }
20027              break;
20028            }
20029            ++c;
20030          }
20031          this.length -= c;
20032          return ret;
20033        }
20034        // Make sure the linked list only shows the minimal necessary information.
20035      }, {
20036        key: custom,
20037        value: function value(_2, options) {
20038          return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
20039            // Only inspect one level.
20040            depth: 0,
20041            // It should not recurse.
20042            customInspect: false
20043          }));
20044        }
20045      }]);
20046      return BufferList2;

vendor: 4,875 bytes, lines 20047-20194

20047    })();
20048    return buffer_list;
20049  }
20050  var destroy_1$1;
20051  var hasRequiredDestroy$1;
20052  function requireDestroy$1() {
20053    if (hasRequiredDestroy$1) return destroy_1$1;
20054    hasRequiredDestroy$1 = 1;
20055    function destroy(err, cb) {
20056      var _this = this;
20057      var readableDestroyed = this._readableState && this._readableState.destroyed;
20058      var writableDestroyed = this._writableState && this._writableState.destroyed;
20059      if (readableDestroyed || writableDestroyed) {
20060        if (cb) {
20061          cb(err);
20062        } else if (err) {
20063          if (!this._writableState) {
20064            process$1.nextTick(emitErrorNT, this, err);
20065          } else if (!this._writableState.errorEmitted) {
20066            this._writableState.errorEmitted = true;
20067            process$1.nextTick(emitErrorNT, this, err);
20068          }
20069        }
20070        return this;
20071      }
20072      if (this._readableState) {
20073        this._readableState.destroyed = true;
20074      }
20075      if (this._writableState) {
20076        this._writableState.destroyed = true;
20077      }
20078      this._destroy(err || null, function(err2) {
20079        if (!cb && err2) {
20080          if (!_this._writableState) {
20081            process$1.nextTick(emitErrorAndCloseNT, _this, err2);
20082          } else if (!_this._writableState.errorEmitted) {
20083            _this._writableState.errorEmitted = true;
20084            process$1.nextTick(emitErrorAndCloseNT, _this, err2);
20085          } else {
20086            process$1.nextTick(emitCloseNT, _this);
20087          }
20088        } else if (cb) {
20089          process$1.nextTick(emitCloseNT, _this);
20090          cb(err2);
20091        } else {
20092          process$1.nextTick(emitCloseNT, _this);
20093        }
20094      });
20095      return this;
20096    }
20097    function emitErrorAndCloseNT(self2, err) {
20098      emitErrorNT(self2, err);
20099      emitCloseNT(self2);
20100    }
20101    function emitCloseNT(self2) {
20102      if (self2._writableState && !self2._writableState.emitClose) return;
20103      if (self2._readableState && !self2._readableState.emitClose) return;
20104      self2.emit("close");
20105    }
20106    function undestroy() {
20107      if (this._readableState) {
20108        this._readableState.destroyed = false;
20109        this._readableState.reading = false;
20110        this._readableState.ended = false;
20111        this._readableState.endEmitted = false;
20112      }
20113      if (this._writableState) {
20114        this._writableState.destroyed = false;
20115        this._writableState.ended = false;
20116        this._writableState.ending = false;
20117        this._writableState.finalCalled = false;
20118        this._writableState.prefinished = false;
20119        this._writableState.finished = false;
20120        this._writableState.errorEmitted = false;
20121      }
20122    }
20123    function emitErrorNT(self2, err) {
20124      self2.emit("error", err);
20125    }
20126    function errorOrDestroy(stream2, err) {
20127      var rState = stream2._readableState;
20128      var wState = stream2._writableState;
20129      if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream2.destroy(err);
20130      else stream2.emit("error", err);
20131    }
20132    destroy_1$1 = {
20133      destroy,
20134      undestroy,
20135      errorOrDestroy
20136    };
20137    return destroy_1$1;
20138  }
20139  var errors$1 = {};
20140  var hasRequiredErrors$1;
20141  function requireErrors$1() {
20142    if (hasRequiredErrors$1) return errors$1;
20143    hasRequiredErrors$1 = 1;
20144    const codes = {};
20145    function createErrorType(code2, message, Base) {
20146      if (!Base) {
20147        Base = Error;
20148      }
20149      function getMessage(arg1, arg2, arg3) {
20150        if (typeof message === "string") {
20151          return message;
20152        } else {
20153          return message(arg1, arg2, arg3);
20154        }
20155      }
20156      class NodeError extends Base {
20157        constructor(arg1, arg2, arg3) {
20158          super(getMessage(arg1, arg2, arg3));
20159        }
20160      }
20161      NodeError.prototype.name = Base.name;
20162      NodeError.prototype.code = code2;
20163      codes[code2] = NodeError;
20164    }
20165    function oneOf(expected, thing) {
20166      if (Array.isArray(expected)) {
20167        const len2 = expected.length;
20168        expected = expected.map((i2) => String(i2));
20169        if (len2 > 2) {
20170          return `one of ${thing} ${expected.slice(0, len2 - 1).join(", ")}, or ` + expected[len2 - 1];
20171        } else if (len2 === 2) {
20172          return `one of ${thing} ${expected[0]} or ${expected[1]}`;
20173        } else {
20174          return `of ${thing} ${expected[0]}`;
20175        }
20176      } else {
20177        return `of ${thing} ${String(expected)}`;
20178      }
20179    }
20180    function startsWith(str, search, pos) {
20181      return str.substr(0, search.length) === search;
20182    }
20183    function endsWith2(str, search, this_len) {
20184      if (this_len === void 0 || this_len > str.length) {
20185        this_len = str.length;
20186      }
20187      return str.substring(this_len - search.length, this_len) === search;
20188    }
20189    function includes(str, search, start) {
20190      if (typeof start !== "number") {
20191        start = 0;
20192      }
20193      if (start + search.length > str.length) {
20194        return false;

20195      } else {
20196        return str.indexOf(search, start) !== -1;
20197      }
20198    }
20199    createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
20200      return 'The value "' + value + '" is invalid for option "' + name + '"';
20201    }, TypeError);
20202    createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
20203      let determiner;
20204      if (typeof expected === "string" && startsWith(expected, "not ")) {
20205        determiner = "must not be";
20206        expected = expected.replace(/^not /, "");
20207      } else {
20208        determiner = "must be";
20209      }
20210      let msg;
20211      if (endsWith2(name, " argument")) {
20212        msg = `The ${name} ${determiner} ${oneOf(expected, "type")}`;
20213      } else {
20214        const type2 = includes(name, ".") ? "property" : "argument";
20215        msg = `The "${name}" ${type2} ${determiner} ${oneOf(expected, "type")}`;
20216      }
20217      msg += `. Received type ${typeof actual}`;
20218      return msg;
20219    }, TypeError);
20220    createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
20221    createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
20222      return "The " + name + " method is not implemented";
20223    });
20224    createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
20225    createErrorType("ERR_STREAM_DESTROYED", function(name) {
20226      return "Cannot call " + name + " after a stream was destroyed";
20227    });
20228    createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
20229    createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
20230    createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
20231    createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
20232    createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
20233      return "Unknown encoding: " + arg;
20234    }, TypeError);
20235    createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
20236    errors$1.codes = codes;
20237    return errors$1;
20238  }
20239  var state;
20240  var hasRequiredState$1;
20241  function requireState$1() {
20242    if (hasRequiredState$1) return state;
20243    hasRequiredState$1 = 1;
20244    var ERR_INVALID_OPT_VALUE = requireErrors$1().codes.ERR_INVALID_OPT_VALUE;
20245    function highWaterMarkFrom(options, isDuplex, duplexKey) {
20246      return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
20247    }
20248    function getHighWaterMark(state2, options, duplexKey, isDuplex) {
20249      var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
20250      if (hwm != null) {
20251        if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
20252          var name = isDuplex ? duplexKey : "highWaterMark";
20253          throw new ERR_INVALID_OPT_VALUE(name, hwm);
20254        }
20255        return Math.floor(hwm);
20256      }
20257      return state2.objectMode ? 16 : 16 * 1024;
20258    }
20259    state = {
20260      getHighWaterMark
20261    };
20262    return state;
20263  }
20264  var node$2;
20265  var hasRequiredNode$2;
20266  function requireNode$2() {
20267    if (hasRequiredNode$2) return node$2;
20268    hasRequiredNode$2 = 1;
20269    node$2 = requireUtil$1().deprecate;
20270    return node$2;
20271  }
20272  var _stream_writable$1;
20273  var hasRequired_stream_writable$1;
20274  function require_stream_writable$1() {
20275    if (hasRequired_stream_writable$1) return _stream_writable$1;
20276    hasRequired_stream_writable$1 = 1;
20277    _stream_writable$1 = Writable;
20278    function CorkedRequest(state2) {
20279      var _this = this;
20280      this.next = null;
20281      this.entry = null;
20282      this.finish = function() {
20283        onCorkedFinish(_this, state2);
20284      };
20285    }
20286    var Duplex;
20287    Writable.WritableState = WritableState;
20288    var internalUtil = {
20289      deprecate: requireNode$2()
20290    };
20291    var Stream = requireStream$1();
20292    var Buffer2 = requireDist().Buffer;
20293    var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
20294    };
20295    function _uint8ArrayToBuffer(chunk) {
20296      return Buffer2.from(chunk);
20297    }
20298    function _isUint8Array(obj) {
20299      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
20300    }
20301    var destroyImpl = requireDestroy$1();
20302    var _require = requireState$1(), getHighWaterMark = _require.getHighWaterMark;
20303    var _require$codes = requireErrors$1().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_METHOD_NOT_IMPLEMENT

vendor: 4,587 bytes, lines 20303-20410

20303ED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
20304    var errorOrDestroy = destroyImpl.errorOrDestroy;
20305    requireInherits()(Writable, Stream);
20306    function nop() {
20307    }
20308    function WritableState(options, stream2, isDuplex) {
20309      Duplex = Duplex || require_stream_duplex$1();
20310      options = options || {};
20311      if (typeof isDuplex !== "boolean") isDuplex = stream2 instanceof Duplex;
20312      this.objectMode = !!options.objectMode;
20313      if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
20314      this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
20315      this.finalCalled = false;
20316      this.needDrain = false;
20317      this.ending = false;
20318      this.ended = false;
20319      this.finished = false;
20320      this.destroyed = false;
20321      var noDecode = options.decodeStrings === false;
20322      this.decodeStrings = !noDecode;
20323      this.defaultEncoding = options.defaultEncoding || "utf8";
20324      this.length = 0;
20325      this.writing = false;
20326      this.corked = 0;
20327      this.sync = true;
20328      this.bufferProcessing = false;
20329      this.onwrite = function(er) {
20330        onwrite(stream2, er);
20331      };
20332      this.writecb = null;
20333      this.writelen = 0;
20334      this.bufferedRequest = null;
20335      this.lastBufferedRequest = null;
20336      this.pendingcb = 0;
20337      this.prefinished = false;
20338      this.errorEmitted = false;
20339      this.emitClose = options.emitClose !== false;
20340      this.autoDestroy = !!options.autoDestroy;
20341      this.bufferedRequestCount = 0;
20342      this.corkedRequestsFree = new CorkedRequest(this);
20343    }
20344    WritableState.prototype.getBuffer = function getBuffer() {
20345      var current = this.bufferedRequest;
20346      var out = [];
20347      while (current) {
20348        out.push(current);
20349        current = current.next;
20350      }
20351      return out;
20352    };
20353    (function() {
20354      try {
20355        Object.defineProperty(WritableState.prototype, "buffer", {
20356          get: internalUtil.deprecate(function writableStateBufferGetter() {
20357            return this.getBuffer();
20358          }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
20359        });
20360      } catch (_2) {
20361      }
20362    })();
20363    var realHasInstance;
20364    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
20365      realHasInstance = Function.prototype[Symbol.hasInstance];
20366      Object.defineProperty(Writable, Symbol.hasInstance, {
20367        value: function value(object) {
20368          if (realHasInstance.call(this, object)) return true;
20369          if (this !== Writable) return false;
20370          return object && object._writableState instanceof WritableState;
20371        }
20372      });
20373    } else {
20374      realHasInstance = function realHasInstance2(object) {
20375        return object instanceof this;
20376      };
20377    }
20378    function Writable(options) {
20379      Duplex = Duplex || require_stream_duplex$1();
20380      var isDuplex = this instanceof Duplex;
20381      if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
20382      this._writableState = new WritableState(options, this, isDuplex);
20383      this.writable = true;
20384      if (options) {
20385        if (typeof options.write === "function") this._write = options.write;
20386        if (typeof options.writev === "function") this._writev = options.writev;
20387        if (typeof options.destroy === "function") this._destroy = options.destroy;
20388        if (typeof options.final === "function") this._final = options.final;
20389      }
20390      Stream.call(this);
20391    }
20392    Writable.prototype.pipe = function() {
20393      errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
20394    };
20395    function writeAfterEnd(stream2, cb) {
20396      var er = new ERR_STREAM_WRITE_AFTER_END();
20397      errorOrDestroy(stream2, er);
20398      process$1.nextTick(cb, er);
20399    }
20400    function validChunk(stream2, state2, chunk, cb) {
20401      var er;
20402      if (chunk === null) {
20403        er = new ERR_STREAM_NULL_VALUES();
20404      } else if (typeof chunk !== "string" && !state2.objectMode) {
20405        er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
20406      }
20407      if (er) {
20408        errorOrDestroy(stream2, er);
20409        process$1.nextTick(cb, er);
20410        return false;

vendor: 4,126 bytes, lines 20411-20521

20411      }
20412      return true;
20413    }
20414    Writable.prototype.write = function(chunk, encoding, cb) {
20415      var state2 = this._writableState;
20416      var ret = false;
20417      var isBuf = !state2.objectMode && _isUint8Array(chunk);
20418      if (isBuf && !Buffer2.isBuffer(chunk)) {
20419        chunk = _uint8ArrayToBuffer(chunk);
20420      }
20421      if (typeof encoding === "function") {
20422        cb = encoding;
20423        encoding = null;
20424      }
20425      if (isBuf) encoding = "buffer";
20426      else if (!encoding) encoding = state2.defaultEncoding;
20427      if (typeof cb !== "function") cb = nop;
20428      if (state2.ending) writeAfterEnd(this, cb);
20429      else if (isBuf || validChunk(this, state2, chunk, cb)) {
20430        state2.pendingcb++;
20431        ret = writeOrBuffer(this, state2, isBuf, chunk, encoding, cb);
20432      }
20433      return ret;
20434    };
20435    Writable.prototype.cork = function() {
20436      this._writableState.corked++;
20437    };
20438    Writable.prototype.uncork = function() {
20439      var state2 = this._writableState;
20440      if (state2.corked) {
20441        state2.corked--;
20442        if (!state2.writing && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) clearBuffer(this, state2);
20443      }
20444    };
20445    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
20446      if (typeof encoding === "string") encoding = encoding.toLowerCase();
20447      if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
20448      this._writableState.defaultEncoding = encoding;
20449      return this;
20450    };
20451    Object.defineProperty(Writable.prototype, "writableBuffer", {
20452      // making it explicit this property is not enumerable
20453      // because otherwise some prototype manipulation in
20454      // userland will fail
20455      enumerable: false,
20456      get: function get2() {
20457        return this._writableState && this._writableState.getBuffer();
20458      }
20459    });
20460    function decodeChunk(state2, chunk, encoding) {
20461      if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk === "string") {
20462        chunk = Buffer2.from(chunk, encoding);
20463      }
20464      return chunk;
20465    }
20466    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
20467      // making it explicit this property is not enumerable
20468      // because otherwise some prototype manipulation in
20469      // userland will fail
20470      enumerable: false,
20471      get: function get2() {
20472        return this._writableState.highWaterMark;
20473      }
20474    });
20475    function writeOrBuffer(stream2, state2, isBuf, chunk, encoding, cb) {
20476      if (!isBuf) {
20477        var newChunk = decodeChunk(state2, chunk, encoding);
20478        if (chunk !== newChunk) {
20479          isBuf = true;
20480          encoding = "buffer";
20481          chunk = newChunk;
20482        }
20483      }
20484      var len2 = state2.objectMode ? 1 : chunk.length;
20485      state2.length += len2;
20486      var ret = state2.length < state2.highWaterMark;
20487      if (!ret) state2.needDrain = true;
20488      if (state2.writing || state2.corked) {
20489        var last = state2.lastBufferedRequest;
20490        state2.lastBufferedRequest = {
20491          chunk,
20492          encoding,
20493          isBuf,
20494          callback: cb,
20495          next: null
20496        };
20497        if (last) {
20498          last.next = state2.lastBufferedRequest;
20499        } else {
20500          state2.bufferedRequest = state2.lastBufferedRequest;
20501        }
20502        state2.bufferedRequestCount += 1;
20503      } else {
20504        doWrite(stream2, state2, false, len2, chunk, encoding, cb);
20505      }
20506      return ret;
20507    }
20508    function doWrite(stream2, state2, writev, len2, chunk, encoding, cb) {
20509      state2.writelen = len2;
20510      state2.writecb = cb;
20511      state2.writing = true;
20512      state2.sync = true;
20513      if (state2.destroyed) state2.onwrite(new ERR_STREAM_DESTROYED("write"));
20514      else if (writev) stream2._writev(chunk, state2.onwrite);
20515      else stream2._write(chunk, encoding, state2.onwrite);
20516      state2.sync = false;
20517    }
20518    function onwriteError(stream2, state2, sync2, er, cb) {
20519      --state2.pendingcb;
20520      if (sync2) {
20521        process$1.nextTick(cb, er);

vendor: 5,858 bytes, lines 20522-20696

20522        process$1.nextTick(finishMaybe, stream2, state2);
20523        stream2._writableState.errorEmitted = true;
20524        errorOrDestroy(stream2, er);
20525      } else {
20526        cb(er);
20527        stream2._writableState.errorEmitted = true;
20528        errorOrDestroy(stream2, er);
20529        finishMaybe(stream2, state2);
20530      }
20531    }
20532    function onwriteStateUpdate(state2) {
20533      state2.writing = false;
20534      state2.writecb = null;
20535      state2.length -= state2.writelen;
20536      state2.writelen = 0;
20537    }
20538    function onwrite(stream2, er) {
20539      var state2 = stream2._writableState;
20540      var sync2 = state2.sync;
20541      var cb = state2.writecb;
20542      if (typeof cb !== "function") throw new ERR_MULTIPLE_CALLBACK();
20543      onwriteStateUpdate(state2);
20544      if (er) onwriteError(stream2, state2, sync2, er, cb);
20545      else {
20546        var finished = needFinish(state2) || stream2.destroyed;
20547        if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) {
20548          clearBuffer(stream2, state2);
20549        }
20550        if (sync2) {
20551          process$1.nextTick(afterWrite, stream2, state2, finished, cb);
20552        } else {
20553          afterWrite(stream2, state2, finished, cb);
20554        }
20555      }
20556    }
20557    function afterWrite(stream2, state2, finished, cb) {
20558      if (!finished) onwriteDrain(stream2, state2);
20559      state2.pendingcb--;
20560      cb();
20561      finishMaybe(stream2, state2);
20562    }
20563    function onwriteDrain(stream2, state2) {
20564      if (state2.length === 0 && state2.needDrain) {
20565        state2.needDrain = false;
20566        stream2.emit("drain");
20567      }
20568    }
20569    function clearBuffer(stream2, state2) {
20570      state2.bufferProcessing = true;
20571      var entry = state2.bufferedRequest;
20572      if (stream2._writev && entry && entry.next) {
20573        var l = state2.bufferedRequestCount;
20574        var buffer2 = new Array(l);
20575        var holder = state2.corkedRequestsFree;
20576        holder.entry = entry;
20577        var count = 0;
20578        var allBuffers = true;
20579        while (entry) {
20580          buffer2[count] = entry;
20581          if (!entry.isBuf) allBuffers = false;
20582          entry = entry.next;
20583          count += 1;
20584        }
20585        buffer2.allBuffers = allBuffers;
20586        doWrite(stream2, state2, true, state2.length, buffer2, "", holder.finish);
20587        state2.pendingcb++;
20588        state2.lastBufferedRequest = null;
20589        if (holder.next) {
20590          state2.corkedRequestsFree = holder.next;
20591          holder.next = null;
20592        } else {
20593          state2.corkedRequestsFree = new CorkedRequest(state2);
20594        }
20595        state2.bufferedRequestCount = 0;
20596      } else {
20597        while (entry) {
20598          var chunk = entry.chunk;
20599          var encoding = entry.encoding;
20600          var cb = entry.callback;
20601          var len2 = state2.objectMode ? 1 : chunk.length;
20602          doWrite(stream2, state2, false, len2, chunk, encoding, cb);
20603          entry = entry.next;
20604          state2.bufferedRequestCount--;
20605          if (state2.writing) {
20606            break;
20607          }
20608        }
20609        if (entry === null) state2.lastBufferedRequest = null;
20610      }
20611      state2.bufferedRequest = entry;
20612      state2.bufferProcessing = false;
20613    }
20614    Writable.prototype._write = function(chunk, encoding, cb) {
20615      cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
20616    };
20617    Writable.prototype._writev = null;
20618    Writable.prototype.end = function(chunk, encoding, cb) {
20619      var state2 = this._writableState;
20620      if (typeof chunk === "function") {
20621        cb = chunk;
20622        chunk = null;
20623        encoding = null;
20624      } else if (typeof encoding === "function") {
20625        cb = encoding;
20626        encoding = null;
20627      }
20628      if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
20629      if (state2.corked) {
20630        state2.corked = 1;
20631        this.uncork();
20632      }
20633      if (!state2.ending) endWritable(this, state2, cb);
20634      return this;
20635    };
20636    Object.defineProperty(Writable.prototype, "writableLength", {
20637      // making it explicit this property is not enumerable
20638      // because otherwise some prototype manipulation in
20639      // userland will fail
20640      enumerable: false,
20641      get: function get2() {
20642        return this._writableState.length;
20643      }
20644    });
20645    function needFinish(state2) {
20646      return state2.ending && state2.length === 0 && state2.bufferedRequest === null && !state2.finished && !state2.writing;
20647    }
20648    function callFinal(stream2, state2) {
20649      stream2._final(function(err) {
20650        state2.pendingcb--;
20651        if (err) {
20652          errorOrDestroy(stream2, err);
20653        }
20654        state2.prefinished = true;
20655        stream2.emit("prefinish");
20656        finishMaybe(stream2, state2);
20657      });
20658    }
20659    function prefinish(stream2, state2) {
20660      if (!state2.prefinished && !state2.finalCalled) {
20661        if (typeof stream2._final === "function" && !state2.destroyed) {
20662          state2.pendingcb++;
20663          state2.finalCalled = true;
20664          process$1.nextTick(callFinal, stream2, state2);
20665        } else {
20666          state2.prefinished = true;
20667          stream2.emit("prefinish");
20668        }
20669      }
20670    }
20671    function finishMaybe(stream2, state2) {
20672      var need = needFinish(state2);
20673      if (need) {
20674        prefinish(stream2, state2);
20675        if (state2.pendingcb === 0) {
20676          state2.finished = true;
20677          stream2.emit("finish");
20678          if (state2.autoDestroy) {
20679            var rState = stream2._readableState;
20680            if (!rState || rState.autoDestroy && rState.endEmitted) {
20681              stream2.destroy();
20682            }
20683          }
20684        }
20685      }
20686      return need;
20687    }
20688    function endWritable(stream2, state2, cb) {
20689      state2.ending = true;
20690      finishMaybe(stream2, state2);
20691      if (cb) {
20692        if (state2.finished) process$1.nextTick(cb);
20693        else stream2.once("finish", cb);
20694      }
20695      state2.ended = true;
20696      stream2.writable = false;

vendor: 5,557 bytes, lines 20697-20856

20697    }
20698    function onCorkedFinish(corkReq, state2, err) {
20699      var entry = corkReq.entry;
20700      corkReq.entry = null;
20701      while (entry) {
20702        var cb = entry.callback;
20703        state2.pendingcb--;
20704        cb(err);
20705        entry = entry.next;
20706      }
20707      state2.corkedRequestsFree.next = corkReq;
20708    }
20709    Object.defineProperty(Writable.prototype, "destroyed", {
20710      // making it explicit this property is not enumerable
20711      // because otherwise some prototype manipulation in
20712      // userland will fail
20713      enumerable: false,
20714      get: function get2() {
20715        if (this._writableState === void 0) {
20716          return false;
20717        }
20718        return this._writableState.destroyed;
20719      },
20720      set: function set(value) {
20721        if (!this._writableState) {
20722          return;
20723        }
20724        this._writableState.destroyed = value;
20725      }
20726    });
20727    Writable.prototype.destroy = destroyImpl.destroy;
20728    Writable.prototype._undestroy = destroyImpl.undestroy;
20729    Writable.prototype._destroy = function(err, cb) {
20730      cb(err);
20731    };
20732    return _stream_writable$1;
20733  }
20734  var _stream_duplex$1;
20735  var hasRequired_stream_duplex$1;
20736  function require_stream_duplex$1() {
20737    if (hasRequired_stream_duplex$1) return _stream_duplex$1;
20738    hasRequired_stream_duplex$1 = 1;
20739    var objectKeys2 = Object.keys || function(obj) {
20740      var keys2 = [];
20741      for (var key2 in obj) keys2.push(key2);
20742      return keys2;
20743    };
20744    _stream_duplex$1 = Duplex;
20745    var Readable = require_stream_readable$1();
20746    var Writable = require_stream_writable$1();
20747    requireInherits()(Duplex, Readable);
20748    {
20749      var keys = objectKeys2(Writable.prototype);
20750      for (var v = 0; v < keys.length; v++) {
20751        var method = keys[v];
20752        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
20753      }
20754    }
20755    function Duplex(options) {
20756      if (!(this instanceof Duplex)) return new Duplex(options);
20757      Readable.call(this, options);
20758      Writable.call(this, options);
20759      this.allowHalfOpen = true;
20760      if (options) {
20761        if (options.readable === false) this.readable = false;
20762        if (options.writable === false) this.writable = false;
20763        if (options.allowHalfOpen === false) {
20764          this.allowHalfOpen = false;
20765          this.once("end", onend);
20766        }
20767      }
20768    }
20769    Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
20770      // making it explicit this property is not enumerable
20771      // because otherwise some prototype manipulation in
20772      // userland will fail
20773      enumerable: false,
20774      get: function get2() {
20775        return this._writableState.highWaterMark;
20776      }
20777    });
20778    Object.defineProperty(Duplex.prototype, "writableBuffer", {
20779      // making it explicit this property is not enumerable
20780      // because otherwise some prototype manipulation in
20781      // userland will fail
20782      enumerable: false,
20783      get: function get2() {
20784        return this._writableState && this._writableState.getBuffer();
20785      }
20786    });
20787    Object.defineProperty(Duplex.prototype, "writableLength", {
20788      // making it explicit this property is not enumerable
20789      // because otherwise some prototype manipulation in
20790      // userland will fail
20791      enumerable: false,
20792      get: function get2() {
20793        return this._writableState.length;
20794      }
20795    });
20796    function onend() {
20797      if (this._writableState.ended) return;
20798      process$1.nextTick(onEndNT, this);
20799    }
20800    function onEndNT(self2) {
20801      self2.end();
20802    }
20803    Object.defineProperty(Duplex.prototype, "destroyed", {
20804      // making it explicit this property is not enumerable
20805      // because otherwise some prototype manipulation in
20806      // userland will fail
20807      enumerable: false,
20808      get: function get2() {
20809        if (this._readableState === void 0 || this._writableState === void 0) {
20810          return false;
20811        }
20812        return this._readableState.destroyed && this._writableState.destroyed;
20813      },
20814      set: function set(value) {
20815        if (this._readableState === void 0 || this._writableState === void 0) {
20816          return;
20817        }
20818        this._readableState.destroyed = value;
20819        this._writableState.destroyed = value;
20820      }
20821    });
20822    return _stream_duplex$1;
20823  }
20824  var string_decoder = {};
20825  var safeBuffer$1 = { exports: {} };
20826  /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
20827  var hasRequiredSafeBuffer$1;
20828  function requireSafeBuffer$1() {
20829    if (hasRequiredSafeBuffer$1) return safeBuffer$1.exports;
20830    hasRequiredSafeBuffer$1 = 1;
20831    (function(module, exports$12) {
20832      var buffer2 = requireDist();
20833      var Buffer2 = buffer2.Buffer;
20834      function copyProps(src2, dst) {
20835        for (var key2 in src2) {
20836          dst[key2] = src2[key2];
20837        }
20838      }
20839      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
20840        module.exports = buffer2;
20841      } else {
20842        copyProps(buffer2, exports$12);
20843        exports$12.Buffer = SafeBuffer;
20844      }
20845      function SafeBuffer(arg, encodingOrOffset, length) {
20846        return Buffer2(arg, encodingOrOffset, length);
20847      }
20848      SafeBuffer.prototype = Object.create(Buffer2.prototype);
20849      copyProps(Buffer2, SafeBuffer);
20850      SafeBuffer.from = function(arg, encodingOrOffset, length) {
20851        if (typeof arg === "number") {
20852          throw new TypeError("Argument must not be a number");
20853        }
20854        return Buffer2(arg, encodingOrOffset, length);
20855      };
20856      SafeBuffer.alloc = function(size, fill, encoding) {

vendor: 4,881 bytes, lines 20857-21020

20857        if (typeof size !== "number") {
20858          throw new TypeError("Argument must be a number");
20859        }
20860        var buf = Buffer2(size);
20861        if (fill !== void 0) {
20862          if (typeof encoding === "string") {
20863            buf.fill(fill, encoding);
20864          } else {
20865            buf.fill(fill);
20866          }
20867        } else {
20868          buf.fill(0);
20869        }
20870        return buf;
20871      };
20872      SafeBuffer.allocUnsafe = function(size) {
20873        if (typeof size !== "number") {
20874          throw new TypeError("Argument must be a number");
20875        }
20876        return Buffer2(size);
20877      };
20878      SafeBuffer.allocUnsafeSlow = function(size) {
20879        if (typeof size !== "number") {
20880          throw new TypeError("Argument must be a number");
20881        }
20882        return buffer2.SlowBuffer(size);
20883      };
20884    })(safeBuffer$1, safeBuffer$1.exports);
20885    return safeBuffer$1.exports;
20886  }
20887  var hasRequiredString_decoder;
20888  function requireString_decoder() {
20889    if (hasRequiredString_decoder) return string_decoder;
20890    hasRequiredString_decoder = 1;
20891    var Buffer2 = requireSafeBuffer$1().Buffer;
20892    var isEncoding = Buffer2.isEncoding || function(encoding) {
20893      encoding = "" + encoding;
20894      switch (encoding && encoding.toLowerCase()) {
20895        case "hex":
20896        case "utf8":
20897        case "utf-8":
20898        case "ascii":
20899        case "binary":
20900        case "base64":
20901        case "ucs2":
20902        case "ucs-2":
20903        case "utf16le":
20904        case "utf-16le":
20905        case "raw":
20906          return true;
20907        default:
20908          return false;
20909      }
20910    };
20911    function _normalizeEncoding(enc) {
20912      if (!enc) return "utf8";
20913      var retried;
20914      while (true) {
20915        switch (enc) {
20916          case "utf8":
20917          case "utf-8":
20918            return "utf8";
20919          case "ucs2":
20920          case "ucs-2":
20921          case "utf16le":
20922          case "utf-16le":
20923            return "utf16le";
20924          case "latin1":
20925          case "binary":
20926            return "latin1";
20927          case "base64":
20928          case "ascii":
20929          case "hex":
20930            return enc;
20931          default:
20932            if (retried) return;
20933            enc = ("" + enc).toLowerCase();
20934            retried = true;
20935        }
20936      }
20937    }
20938    function normalizeEncoding(enc) {
20939      var nenc = _normalizeEncoding(enc);
20940      if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
20941      return nenc || enc;
20942    }
20943    string_decoder.StringDecoder = StringDecoder;
20944    function StringDecoder(encoding) {
20945      this.encoding = normalizeEncoding(encoding);
20946      var nb;
20947      switch (this.encoding) {
20948        case "utf16le":
20949          this.text = utf16Text;
20950          this.end = utf16End;
20951          nb = 4;
20952          break;
20953        case "utf8":
20954          this.fillLast = utf8FillLast;
20955          nb = 4;
20956          break;
20957        case "base64":
20958          this.text = base64Text;
20959          this.end = base64End;
20960          nb = 3;
20961          break;
20962        default:
20963          this.write = simpleWrite;
20964          this.end = simpleEnd;
20965          return;
20966      }
20967      this.lastNeed = 0;
20968      this.lastTotal = 0;
20969      this.lastChar = Buffer2.allocUnsafe(nb);
20970    }
20971    StringDecoder.prototype.write = function(buf) {
20972      if (buf.length === 0) return "";
20973      var r;
20974      var i2;
20975      if (this.lastNeed) {
20976        r = this.fillLast(buf);
20977        if (r === void 0) return "";
20978        i2 = this.lastNeed;
20979        this.lastNeed = 0;
20980      } else {
20981        i2 = 0;
20982      }
20983      if (i2 < buf.length) return r ? r + this.text(buf, i2) : this.text(buf, i2);
20984      return r || "";
20985    };
20986    StringDecoder.prototype.end = utf8End;
20987    StringDecoder.prototype.text = utf8Text;
20988    StringDecoder.prototype.fillLast = function(buf) {
20989      if (this.lastNeed <= buf.length) {
20990        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
20991        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
20992      }
20993      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
20994      this.lastNeed -= buf.length;
20995    };
20996    function utf8CheckByte(byte) {
20997      if (byte <= 127) return 0;
20998      else if (byte >> 5 === 6) return 2;
20999      else if (byte >> 4 === 14) return 3;
21000      else if (byte >> 3 === 30) return 4;
21001      return byte >> 6 === 2 ? -1 : -2;
21002    }
21003    function utf8CheckIncomplete(self2, buf, i2) {
21004      var j = buf.length - 1;
21005      if (j < i2) return 0;
21006      var nb = utf8CheckByte(buf[j]);
21007      if (nb >= 0) {
21008        if (nb > 0) self2.lastNeed = nb - 1;
21009        return nb;
21010      }
21011      if (--j < i2 || nb === -2) return 0;
21012      nb = utf8CheckByte(buf[j]);
21013      if (nb >= 0) {
21014        if (nb > 0) self2.lastNeed = nb - 2;
21015        return nb;
21016      }
21017      if (--j < i2 || nb === -2) return 0;
21018      nb = utf8CheckByte(buf[j]);
21019      if (nb >= 0) {
21020        if (nb > 0) {

vendor: 4,575 bytes, lines 21021-21157

21021          if (nb === 2) nb = 0;
21022          else self2.lastNeed = nb - 3;
21023        }
21024        return nb;
21025      }
21026      return 0;
21027    }
21028    function utf8CheckExtraBytes(self2, buf, p) {
21029      if ((buf[0] & 192) !== 128) {
21030        self2.lastNeed = 0;
21031        return "ï¿½";
21032      }
21033      if (self2.lastNeed > 1 && buf.length > 1) {
21034        if ((buf[1] & 192) !== 128) {
21035          self2.lastNeed = 1;
21036          return "ï¿½";
21037        }
21038        if (self2.lastNeed > 2 && buf.length > 2) {
21039          if ((buf[2] & 192) !== 128) {
21040            self2.lastNeed = 2;
21041            return "ï¿½";
21042          }
21043        }
21044      }
21045    }
21046    function utf8FillLast(buf) {
21047      var p = this.lastTotal - this.lastNeed;
21048      var r = utf8CheckExtraBytes(this, buf);
21049      if (r !== void 0) return r;
21050      if (this.lastNeed <= buf.length) {
21051        buf.copy(this.lastChar, p, 0, this.lastNeed);
21052        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
21053      }
21054      buf.copy(this.lastChar, p, 0, buf.length);
21055      this.lastNeed -= buf.length;
21056    }
21057    function utf8Text(buf, i2) {
21058      var total = utf8CheckIncomplete(this, buf, i2);
21059      if (!this.lastNeed) return buf.toString("utf8", i2);
21060      this.lastTotal = total;
21061      var end = buf.length - (total - this.lastNeed);
21062      buf.copy(this.lastChar, 0, end);
21063      return buf.toString("utf8", i2, end);
21064    }
21065    function utf8End(buf) {
21066      var r = buf && buf.length ? this.write(buf) : "";
21067      if (this.lastNeed) return r + "ï¿½";
21068      return r;
21069    }
21070    function utf16Text(buf, i2) {
21071      if ((buf.length - i2) % 2 === 0) {
21072        var r = buf.toString("utf16le", i2);
21073        if (r) {
21074          var c = r.charCodeAt(r.length - 1);
21075          if (c >= 55296 && c <= 56319) {
21076            this.lastNeed = 2;
21077            this.lastTotal = 4;
21078            this.lastChar[0] = buf[buf.length - 2];
21079            this.lastChar[1] = buf[buf.length - 1];
21080            return r.slice(0, -1);
21081          }
21082        }
21083        return r;
21084      }
21085      this.lastNeed = 1;
21086      this.lastTotal = 2;
21087      this.lastChar[0] = buf[buf.length - 1];
21088      return buf.toString("utf16le", i2, buf.length - 1);
21089    }
21090    function utf16End(buf) {
21091      var r = buf && buf.length ? this.write(buf) : "";
21092      if (this.lastNeed) {
21093        var end = this.lastTotal - this.lastNeed;
21094        return r + this.lastChar.toString("utf16le", 0, end);
21095      }
21096      return r;
21097    }
21098    function base64Text(buf, i2) {
21099      var n = (buf.length - i2) % 3;
21100      if (n === 0) return buf.toString("base64", i2);
21101      this.lastNeed = 3 - n;
21102      this.lastTotal = 3;
21103      if (n === 1) {
21104        this.lastChar[0] = buf[buf.length - 1];
21105      } else {
21106        this.lastChar[0] = buf[buf.length - 2];
21107        this.lastChar[1] = buf[buf.length - 1];
21108      }
21109      return buf.toString("base64", i2, buf.length - n);
21110    }
21111    function base64End(buf) {
21112      var r = buf && buf.length ? this.write(buf) : "";
21113      if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
21114      return r;
21115    }
21116    function simpleWrite(buf) {
21117      return buf.toString(this.encoding);
21118    }
21119    function simpleEnd(buf) {
21120      return buf && buf.length ? this.write(buf) : "";
21121    }
21122    return string_decoder;
21123  }
21124  var endOfStream;
21125  var hasRequiredEndOfStream;
21126  function requireEndOfStream() {
21127    if (hasRequiredEndOfStream) return endOfStream;
21128    hasRequiredEndOfStream = 1;
21129    var ERR_STREAM_PREMATURE_CLOSE = requireErrors$1().codes.ERR_STREAM_PREMATURE_CLOSE;
21130    function once(callback) {
21131      var called = false;
21132      return function() {
21133        if (called) return;
21134        called = true;
21135        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
21136          args[_key] = arguments[_key];
21137        }
21138        callback.apply(this, args);
21139      };
21140    }
21141    function noop2() {
21142    }
21143    function isRequest2(stream2) {
21144      return stream2.setHeader && typeof stream2.abort === "function";
21145    }
21146    function eos(stream2, opts, callback) {
21147      if (typeof opts === "function") return eos(stream2, null, opts);
21148      if (!opts) opts = {};
21149      callback = once(callback || noop2);
21150      var readable2 = opts.readable || opts.readable !== false && stream2.readable;
21151      var writable = opts.writable || opts.writable !== false && stream2.writable;
21152      var onlegacyfinish = function onlegacyfinish2() {
21153        if (!stream2.writable) onfinish();
21154      };
21155      var writableEnded = stream2._writableState && stream2._writableState.finished;
21156      var onfinish = function onfinish2() {
21157        writable = false;

vendor: 6,937 bytes, lines 21158-21350

21158        writableEnded = true;
21159        if (!readable2) callback.call(stream2);
21160      };
21161      var readableEnded = stream2._readableState && stream2._readableState.endEmitted;
21162      var onend = function onend2() {
21163        readable2 = false;
21164        readableEnded = true;
21165        if (!writable) callback.call(stream2);
21166      };
21167      var onerror = function onerror2(err) {
21168        callback.call(stream2, err);
21169      };
21170      var onclose = function onclose2() {
21171        var err;
21172        if (readable2 && !readableEnded) {
21173          if (!stream2._readableState || !stream2._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
21174          return callback.call(stream2, err);
21175        }
21176        if (writable && !writableEnded) {
21177          if (!stream2._writableState || !stream2._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
21178          return callback.call(stream2, err);
21179        }
21180      };
21181      var onrequest = function onrequest2() {
21182        stream2.req.on("finish", onfinish);
21183      };
21184      if (isRequest2(stream2)) {
21185        stream2.on("complete", onfinish);
21186        stream2.on("abort", onclose);
21187        if (stream2.req) onrequest();
21188        else stream2.on("request", onrequest);
21189      } else if (writable && !stream2._writableState) {
21190        stream2.on("end", onlegacyfinish);
21191        stream2.on("close", onlegacyfinish);
21192      }
21193      stream2.on("end", onend);
21194      stream2.on("finish", onfinish);
21195      if (opts.error !== false) stream2.on("error", onerror);
21196      stream2.on("close", onclose);
21197      return function() {
21198        stream2.removeListener("complete", onfinish);
21199        stream2.removeListener("abort", onclose);
21200        stream2.removeListener("request", onrequest);
21201        if (stream2.req) stream2.req.removeListener("finish", onfinish);
21202        stream2.removeListener("end", onlegacyfinish);
21203        stream2.removeListener("close", onlegacyfinish);
21204        stream2.removeListener("finish", onfinish);
21205        stream2.removeListener("end", onend);
21206        stream2.removeListener("error", onerror);
21207        stream2.removeListener("close", onclose);
21208      };
21209    }
21210    endOfStream = eos;
21211    return endOfStream;
21212  }
21213  var async_iterator;
21214  var hasRequiredAsync_iterator;
21215  function requireAsync_iterator() {
21216    if (hasRequiredAsync_iterator) return async_iterator;
21217    hasRequiredAsync_iterator = 1;
21218    var _Object$setPrototypeO;
21219    function _defineProperty(obj, key2, value) {
21220      key2 = _toPropertyKey(key2);
21221      if (key2 in obj) {
21222        Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
21223      } else {
21224        obj[key2] = value;
21225      }
21226      return obj;
21227    }
21228    function _toPropertyKey(arg) {
21229      var key2 = _toPrimitive(arg, "string");
21230      return typeof key2 === "symbol" ? key2 : String(key2);
21231    }
21232    function _toPrimitive(input, hint) {
21233      if (typeof input !== "object" || input === null) return input;
21234      var prim = input[Symbol.toPrimitive];
21235      if (prim !== void 0) {
21236        var res = prim.call(input, hint);
21237        if (typeof res !== "object") return res;
21238        throw new TypeError("@@toPrimitive must return a primitive value.");
21239      }
21240      return (hint === "string" ? String : Number)(input);
21241    }
21242    var finished = requireEndOfStream();
21243    var kLastResolve = Symbol("lastResolve");
21244    var kLastReject = Symbol("lastReject");
21245    var kError = Symbol("error");
21246    var kEnded = Symbol("ended");
21247    var kLastPromise = Symbol("lastPromise");
21248    var kHandlePromise = Symbol("handlePromise");
21249    var kStream = Symbol("stream");
21250    function createIterResult(value, done) {
21251      return {
21252        value,
21253        done
21254      };
21255    }
21256    function readAndResolve(iter) {
21257      var resolve = iter[kLastResolve];
21258      if (resolve !== null) {
21259        var data = iter[kStream].read();
21260        if (data !== null) {
21261          iter[kLastPromise] = null;
21262          iter[kLastResolve] = null;
21263          iter[kLastReject] = null;
21264          resolve(createIterResult(data, false));
21265        }
21266      }
21267    }
21268    function onReadable(iter) {
21269      process$1.nextTick(readAndResolve, iter);
21270    }
21271    function wrapForNext(lastPromise, iter) {
21272      return function(resolve, reject) {
21273        lastPromise.then(function() {
21274          if (iter[kEnded]) {
21275            resolve(createIterResult(void 0, true));
21276            return;
21277          }
21278          iter[kHandlePromise](resolve, reject);
21279        }, reject);
21280      };
21281    }
21282    var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
21283    });
21284    var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
21285      get stream() {
21286        return this[kStream];
21287      },
21288      next: function next() {
21289        var _this = this;
21290        var error = this[kError];
21291        if (error !== null) {
21292          return Promise.reject(error);
21293        }
21294        if (this[kEnded]) {
21295          return Promise.resolve(createIterResult(void 0, true));
21296        }
21297        if (this[kStream].destroyed) {
21298          return new Promise(function(resolve, reject) {
21299            process$1.nextTick(function() {
21300              if (_this[kError]) {
21301                reject(_this[kError]);
21302              } else {
21303                resolve(createIterResult(void 0, true));
21304              }
21305            });
21306          });
21307        }
21308        var lastPromise = this[kLastPromise];
21309        var promise;
21310        if (lastPromise) {
21311          promise = new Promise(wrapForNext(lastPromise, this));
21312        } else {
21313          var data = this[kStream].read();
21314          if (data !== null) {
21315            return Promise.resolve(createIterResult(data, false));
21316          }
21317          promise = new Promise(this[kHandlePromise]);
21318        }
21319        this[kLastPromise] = promise;
21320        return promise;
21321      }
21322    }, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function() {
21323      return this;
21324    }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
21325      var _this2 = this;
21326      return new Promise(function(resolve, reject) {
21327        _this2[kStream].destroy(null, function(err) {
21328          if (err) {
21329            reject(err);
21330            return;
21331          }
21332          resolve(createIterResult(void 0, true));
21333        });
21334      });
21335    }), _Object$setPrototypeO), AsyncIteratorPrototype);
21336    var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream2) {
21337      var _Object$create;
21338      var iterator2 = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
21339        value: stream2,
21340        writable: true
21341      }), _defineProperty(_Object$create, kLastResolve, {
21342        value: null,
21343        writable: true
21344      }), _defineProperty(_Object$create, kLastReject, {
21345        value: null,
21346        writable: true
21347      }), _defineProperty(_Object$create, kError, {
21348        value: null,
21349        writable: true
21350      }), _defineProperty(_Object$create, kEnded, {

21351        value: stream2._readableState.endEmitted,
21352        writable: true
21353      }), _defineProperty(_Object$create, kHandlePromise, {
21354        value: function value(resolve, reject) {
21355          var data = iterator2[kStream].read();
21356          if (data) {
21357            iterator2[kLastPromise] = null;
21358            iterator2[kLastResolve] = null;
21359            iterator2[kLastReject] = null;
21360            resolve(createIterResult(data, false));
21361          } else {
21362            iterator2[kLastResolve] = resolve;
21363            iterator2[kLastReject] = reject;
21364          }
21365        },
21366        writable: true
21367      }), _Object$create));
21368      iterator2[kLastPromise] = null;
21369      finished(stream2, function(err) {
21370        if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
21371          var reject = iterator2[kLastReject];
21372          if (reject !== null) {
21373            iterator2[kLastPromise] = null;
21374            iterator2[kLastResolve] = null;
21375            iterator2[kLastReject] = null;
21376            reject(err);
21377          }
21378          iterator2[kError] = err;
21379          return;
21380        }
21381        var resolve = iterator2[kLastResolve];
21382        if (resolve !== null) {
21383          iterator2[kLastPromise] = null;
21384          iterator2[kLastResolve] = null;
21385          iterator2[kLastReject] = null;
21386          resolve(createIterResult(void 0, true));
21387        }
21388        iterator2[kEnded] = true;
21389      });
21390      stream2.on("readable", onReadable.bind(null, iterator2));
21391      return iterator2;
21392    };
21393    async_iterator = createReadableStreamAsyncIterator;
21394    return async_iterator;
21395  }
21396  var from_1;
21397  var hasRequiredFrom;
21398  function requireFrom() {
21399    if (hasRequiredFrom) return from_1;
21400    hasRequiredFrom = 1;
21401    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key2, arg) {
21402      try {
21403        var info = gen[key2](arg);
21404        var value = info.value;
21405      } catch (error) {
21406        reject(error);
21407        return;
21408      }
21409      if (info.done) {
21410        resolve(value);
21411      } else {
21412        Promise.resolve(value).then(_next, _throw);
21413      }
21414    }
21415    function _asyncToGenerator(fn) {
21416      return function() {
21417        var self2 = this, args = arguments;
21418        return new Promise(function(resolve, reject) {
21419          var gen = fn.apply(self2, args);
21420          function _next(value) {
21421            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
21422          }
21423          function _throw(err) {
21424            asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
21425          }
21426          _next(void 0);
21427        });
21428      };
21429    }
21430    function ownKeys(object, enumerableOnly) {
21431      var keys = Object.keys(object);
21432      if (Object.getOwnPropertySymbols) {
21433        var symbols = Object.getOwnPropertySymbols(object);
21434        enumerableOnly && (symbols = symbols.filter(function(sym) {
21435          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
21436        })), keys.push.apply(keys, symbols);
21437      }
21438      return keys;
21439    }
21440    function _objectSpread(target) {
21441      for (var i2 = 1; i2 < arguments.length; i2++) {
21442        var source = null != arguments[i2] ? arguments[i2] : {};
21443        i2 % 2 ? ownKeys(Object(source), true).forEach(function(key2) {
21444          _defineProperty(target, key2, source[key2]);
21445        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key2) {
21446          Object.defineProperty(target, key2, Object.getOwnPropertyDescriptor(source, key2));
21447        });
21448      }
21449      return target;
21450    }
21451    function _defineProperty(obj, key2, value) {
21452      key2 = _toPropertyKey(key2);
21453      if (key2 in obj) {
21454        Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
21455      } else {
21456        obj[key2] = value;
21457      }
21458      return obj;
21459    }
21460    function _toPropertyKey(arg) {
21461      var key2 = _toPrimitive(arg, "string");
21462      return typeof key2 === "symbol" ? key2 : String(key2);
21463    }
21464    function _toPrimitive(input, hint) {
21465      if (typeof input !== "object" || input === null) return input;
21466      var prim = input[Symbol.toPrimitive];
21467      if (prim !== void 0) {
21468        var res = prim.call(input, hint);
21469        if (typeof res !== "object") return res;
21470        throw new TypeError("@@toPrimitive must return a primitive value.");
21471      }
21472      return (hint === "string" ? String : Number)(input);
21473    }
21474    var ERR_INVALID_ARG_TYPE = requireErrors$1().codes.ERR_INVALID_ARG_TYPE;
21475    function from(Readable, iterable, opts) {
21476      var iterator2;
21477      if (iterable && typeof iterable.next === "function") {
21478        iterator2 = iterable;
21479      } else if (iterable && iterable[Symbol.asyncIterator]) iterator2 = iterable[Symbol.asyncIterator]();
21480      else if (iterable && iterable[Symbol.iterator]) iterator2 = iterable[Symbol.iterator]();

21481      else throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);
21482      var readable2 = new Readable(_objectSpread({
21483        objectMode: true
21484      }, opts));
21485      var reading = false;
21486      readable2._read = function() {
21487        if (!reading) {
21488          reading = true;
21489          next();
21490        }
21491      };
21492      function next() {
21493        return _next2.apply(this, arguments);
21494      }
21495      function _next2() {
21496        _next2 = _asyncToGenerator(function* () {
21497          try {
21498            var _yield$iterator$next = yield iterator2.next(), value = _yield$iterator$next.value, done = _yield$iterator$next.done;
21499            if (done) {
21500              readable2.push(null);
21501            } else if (readable2.push(yield value)) {
21502              next();
21503            } else {
21504              reading = false;
21505            }
21506          } catch (err) {
21507            readable2.destroy(err);
21508          }
21509        });
21510        return _next2.apply(this, arguments);
21511      }
21512      return readable2;
21513    }
21514    from_1 = from;
21515    return from_1;
21516  }
21517  var _stream_readable$1;
21518  var hasRequired_stream_readable$1;
21519  function require_stream_readable$1() {
21520    if (hasRequired_stream_readable$1) return _stream_readable$1;
21521    hasRequired_stream_readable$1 = 1;
21522    _stream_readable$1 = Readable;
21523    var Duplex;
21524    Readable.ReadableState = ReadableState;
21525    requireEvents().EventEmitter;
21526    var EElistenerCount = function EElistenerCount2(emitter, type2) {
21527      return emitter.listeners(type2).length;
21528    };
21529    var Stream = requireStream$1();
21530    var Buffer2 = requireDist().Buffer;
21531    var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
21532    };
21533    function _uint8ArrayToBuffer(chunk) {
21534      return Buffer2.from(chunk);
21535    }
21536    function _isUint8Array(obj) {
21537      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
21538    }
21539    var debugUtil = requireUtil$1();
21540    var debug;
21541    if (debugUtil && debugUtil.debuglog) {
21542      debug = debugUtil.debuglog("stream");
21543    } else {
21544      debug = function debug2() {
21545      };
21546    }
21547    var BufferList2 = requireBuffer_list();
21548    var destroyImpl = requireDestroy$1();
21549    var _require = requireState$1(), getHighWaterMark = _require.getHighWaterMark;
21550    var _require$codes = requireErrors$1().codes, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
21551    var StringDecoder;
21552    var createReadableStreamAsyncIterator;
21553    var from;
21554    requireInherits()(Readable, Stream);
21555    var errorOrDestroy = destroyImpl.errorOrDestroy;
21556    var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
21557    function prependListener(emitter, event, fn) {
21558      if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
21559      if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
21560      else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);
21561      else emitter._events[event] = [fn, emitter._events[event]];
21562    }
21563    function ReadableState(options, stream2, isDuplex) {
21564      Duplex = Duplex || require_stream_duplex$1();
21565      options = options || {};
21566      if (typeof isDuplex !== "boolean") isDuplex = stream2 instanceof Duplex;
21567      this.objectMode = !!options.objectMode;
21568      if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
21569      this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
21570      this.buffer = new BufferList2();
21571      this.length = 0;
21572      this.pipes = null;
21573      this.pipesCount = 0;
21574      this.flowing = null;
21575      this.ended = false;
21576      this.endEmitted = false;
21577      this.reading = false;
21578      this.sync = true;
21579      this.needReadable = false;
21580      this.emittedReadable = false;
21581      this.readableListening = false;

vendor: 6,784 bytes, lines 21582-21765

21582      this.resumeScheduled = false;
21583      this.paused = true;
21584      this.emitClose = options.emitClose !== false;
21585      this.autoDestroy = !!options.autoDestroy;
21586      this.destroyed = false;
21587      this.defaultEncoding = options.defaultEncoding || "utf8";
21588      this.awaitDrain = 0;
21589      this.readingMore = false;
21590      this.decoder = null;
21591      this.encoding = null;
21592      if (options.encoding) {
21593        if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
21594        this.decoder = new StringDecoder(options.encoding);
21595        this.encoding = options.encoding;
21596      }
21597    }
21598    function Readable(options) {
21599      Duplex = Duplex || require_stream_duplex$1();
21600      if (!(this instanceof Readable)) return new Readable(options);
21601      var isDuplex = this instanceof Duplex;
21602      this._readableState = new ReadableState(options, this, isDuplex);
21603      this.readable = true;
21604      if (options) {
21605        if (typeof options.read === "function") this._read = options.read;
21606        if (typeof options.destroy === "function") this._destroy = options.destroy;
21607      }
21608      Stream.call(this);
21609    }
21610    Object.defineProperty(Readable.prototype, "destroyed", {
21611      // making it explicit this property is not enumerable
21612      // because otherwise some prototype manipulation in
21613      // userland will fail
21614      enumerable: false,
21615      get: function get2() {
21616        if (this._readableState === void 0) {
21617          return false;
21618        }
21619        return this._readableState.destroyed;
21620      },
21621      set: function set(value) {
21622        if (!this._readableState) {
21623          return;
21624        }
21625        this._readableState.destroyed = value;
21626      }
21627    });
21628    Readable.prototype.destroy = destroyImpl.destroy;
21629    Readable.prototype._undestroy = destroyImpl.undestroy;
21630    Readable.prototype._destroy = function(err, cb) {
21631      cb(err);
21632    };
21633    Readable.prototype.push = function(chunk, encoding) {
21634      var state2 = this._readableState;
21635      var skipChunkCheck;
21636      if (!state2.objectMode) {
21637        if (typeof chunk === "string") {
21638          encoding = encoding || state2.defaultEncoding;
21639          if (encoding !== state2.encoding) {
21640            chunk = Buffer2.from(chunk, encoding);
21641            encoding = "";
21642          }
21643          skipChunkCheck = true;
21644        }
21645      } else {
21646        skipChunkCheck = true;
21647      }
21648      return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
21649    };
21650    Readable.prototype.unshift = function(chunk) {
21651      return readableAddChunk(this, chunk, null, true, false);
21652    };
21653    function readableAddChunk(stream2, chunk, encoding, addToFront, skipChunkCheck) {
21654      debug("readableAddChunk", chunk);
21655      var state2 = stream2._readableState;
21656      if (chunk === null) {
21657        state2.reading = false;
21658        onEofChunk(stream2, state2);
21659      } else {
21660        var er;
21661        if (!skipChunkCheck) er = chunkInvalid(state2, chunk);
21662        if (er) {
21663          errorOrDestroy(stream2, er);
21664        } else if (state2.objectMode || chunk && chunk.length > 0) {
21665          if (typeof chunk !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
21666            chunk = _uint8ArrayToBuffer(chunk);
21667          }
21668          if (addToFront) {
21669            if (state2.endEmitted) errorOrDestroy(stream2, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
21670            else addChunk(stream2, state2, chunk, true);
21671          } else if (state2.ended) {
21672            errorOrDestroy(stream2, new ERR_STREAM_PUSH_AFTER_EOF());
21673          } else if (state2.destroyed) {
21674            return false;
21675          } else {
21676            state2.reading = false;
21677            if (state2.decoder && !encoding) {
21678              chunk = state2.decoder.write(chunk);
21679              if (state2.objectMode || chunk.length !== 0) addChunk(stream2, state2, chunk, false);
21680              else maybeReadMore(stream2, state2);
21681            } else {
21682              addChunk(stream2, state2, chunk, false);
21683            }
21684          }
21685        } else if (!addToFront) {
21686          state2.reading = false;
21687          maybeReadMore(stream2, state2);
21688        }
21689      }
21690      return !state2.ended && (state2.length < state2.highWaterMark || state2.length === 0);
21691    }
21692    function addChunk(stream2, state2, chunk, addToFront) {
21693      if (state2.flowing && state2.length === 0 && !state2.sync) {
21694        state2.awaitDrain = 0;
21695        stream2.emit("data", chunk);
21696      } else {
21697        state2.length += state2.objectMode ? 1 : chunk.length;
21698        if (addToFront) state2.buffer.unshift(chunk);
21699        else state2.buffer.push(chunk);
21700        if (state2.needReadable) emitReadable(stream2);
21701      }
21702      maybeReadMore(stream2, state2);
21703    }
21704    function chunkInvalid(state2, chunk) {
21705      var er;
21706      if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
21707        er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
21708      }
21709      return er;
21710    }
21711    Readable.prototype.isPaused = function() {
21712      return this._readableState.flowing === false;
21713    };
21714    Readable.prototype.setEncoding = function(enc) {
21715      if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
21716      var decoder = new StringDecoder(enc);
21717      this._readableState.decoder = decoder;
21718      this._readableState.encoding = this._readableState.decoder.encoding;
21719      var p = this._readableState.buffer.head;
21720      var content = "";
21721      while (p !== null) {
21722        content += decoder.write(p.data);
21723        p = p.next;
21724      }
21725      this._readableState.buffer.clear();
21726      if (content !== "") this._readableState.buffer.push(content);
21727      this._readableState.length = content.length;
21728      return this;
21729    };
21730    var MAX_HWM = 1073741824;
21731    function computeNewHighWaterMark(n) {
21732      if (n >= MAX_HWM) {
21733        n = MAX_HWM;
21734      } else {
21735        n--;
21736        n |= n >>> 1;
21737        n |= n >>> 2;
21738        n |= n >>> 4;
21739        n |= n >>> 8;
21740        n |= n >>> 16;
21741        n++;
21742      }
21743      return n;
21744    }
21745    function howMuchToRead(n, state2) {
21746      if (n <= 0 || state2.length === 0 && state2.ended) return 0;
21747      if (state2.objectMode) return 1;
21748      if (n !== n) {
21749        if (state2.flowing && state2.length) return state2.buffer.head.data.length;
21750        else return state2.length;
21751      }
21752      if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n);
21753      if (n <= state2.length) return n;
21754      if (!state2.ended) {
21755        state2.needReadable = true;
21756        return 0;
21757      }
21758      return state2.length;
21759    }
21760    Readable.prototype.read = function(n) {
21761      debug("read", n);
21762      n = parseInt(n, 10);
21763      var state2 = this._readableState;
21764      var nOrig = n;
21765      if (n !== 0) state2.emittedReadable = false;

vendor: 8,818 bytes, lines 21766-22018

21766      if (n === 0 && state2.needReadable && ((state2.highWaterMark !== 0 ? state2.length >= state2.highWaterMark : state2.length > 0) || state2.ended)) {
21767        debug("read: emitReadable", state2.length, state2.ended);
21768        if (state2.length === 0 && state2.ended) endReadable(this);
21769        else emitReadable(this);
21770        return null;
21771      }
21772      n = howMuchToRead(n, state2);
21773      if (n === 0 && state2.ended) {
21774        if (state2.length === 0) endReadable(this);
21775        return null;
21776      }
21777      var doRead = state2.needReadable;
21778      debug("need readable", doRead);
21779      if (state2.length === 0 || state2.length - n < state2.highWaterMark) {
21780        doRead = true;
21781        debug("length less than watermark", doRead);
21782      }
21783      if (state2.ended || state2.reading) {
21784        doRead = false;
21785        debug("reading or ended", doRead);
21786      } else if (doRead) {
21787        debug("do read");
21788        state2.reading = true;
21789        state2.sync = true;
21790        if (state2.length === 0) state2.needReadable = true;
21791        this._read(state2.highWaterMark);
21792        state2.sync = false;
21793        if (!state2.reading) n = howMuchToRead(nOrig, state2);
21794      }
21795      var ret;
21796      if (n > 0) ret = fromList(n, state2);
21797      else ret = null;
21798      if (ret === null) {
21799        state2.needReadable = state2.length <= state2.highWaterMark;
21800        n = 0;
21801      } else {
21802        state2.length -= n;
21803        state2.awaitDrain = 0;
21804      }
21805      if (state2.length === 0) {
21806        if (!state2.ended) state2.needReadable = true;
21807        if (nOrig !== n && state2.ended) endReadable(this);
21808      }
21809      if (ret !== null) this.emit("data", ret);
21810      return ret;
21811    };
21812    function onEofChunk(stream2, state2) {
21813      debug("onEofChunk");
21814      if (state2.ended) return;
21815      if (state2.decoder) {
21816        var chunk = state2.decoder.end();
21817        if (chunk && chunk.length) {
21818          state2.buffer.push(chunk);
21819          state2.length += state2.objectMode ? 1 : chunk.length;
21820        }
21821      }
21822      state2.ended = true;
21823      if (state2.sync) {
21824        emitReadable(stream2);
21825      } else {
21826        state2.needReadable = false;
21827        if (!state2.emittedReadable) {
21828          state2.emittedReadable = true;
21829          emitReadable_(stream2);
21830        }
21831      }
21832    }
21833    function emitReadable(stream2) {
21834      var state2 = stream2._readableState;
21835      debug("emitReadable", state2.needReadable, state2.emittedReadable);
21836      state2.needReadable = false;
21837      if (!state2.emittedReadable) {
21838        debug("emitReadable", state2.flowing);
21839        state2.emittedReadable = true;
21840        process$1.nextTick(emitReadable_, stream2);
21841      }
21842    }
21843    function emitReadable_(stream2) {
21844      var state2 = stream2._readableState;
21845      debug("emitReadable_", state2.destroyed, state2.length, state2.ended);
21846      if (!state2.destroyed && (state2.length || state2.ended)) {
21847        stream2.emit("readable");
21848        state2.emittedReadable = false;
21849      }
21850      state2.needReadable = !state2.flowing && !state2.ended && state2.length <= state2.highWaterMark;
21851      flow(stream2);
21852    }
21853    function maybeReadMore(stream2, state2) {
21854      if (!state2.readingMore) {
21855        state2.readingMore = true;
21856        process$1.nextTick(maybeReadMore_, stream2, state2);
21857      }
21858    }
21859    function maybeReadMore_(stream2, state2) {
21860      while (!state2.reading && !state2.ended && (state2.length < state2.highWaterMark || state2.flowing && state2.length === 0)) {
21861        var len2 = state2.length;
21862        debug("maybeReadMore read 0");
21863        stream2.read(0);
21864        if (len2 === state2.length)
21865          break;
21866      }
21867      state2.readingMore = false;
21868    }
21869    Readable.prototype._read = function(n) {
21870      errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
21871    };
21872    Readable.prototype.pipe = function(dest, pipeOpts) {
21873      var src2 = this;
21874      var state2 = this._readableState;
21875      switch (state2.pipesCount) {
21876        case 0:
21877          state2.pipes = dest;
21878          break;
21879        case 1:
21880          state2.pipes = [state2.pipes, dest];
21881          break;
21882        default:
21883          state2.pipes.push(dest);
21884          break;
21885      }
21886      state2.pipesCount += 1;
21887      debug("pipe count=%d opts=%j", state2.pipesCount, pipeOpts);
21888      var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr;
21889      var endFn = doEnd ? onend : unpipe;
21890      if (state2.endEmitted) process$1.nextTick(endFn);
21891      else src2.once("end", endFn);
21892      dest.on("unpipe", onunpipe);
21893      function onunpipe(readable2, unpipeInfo) {
21894        debug("onunpipe");
21895        if (readable2 === src2) {
21896          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
21897            unpipeInfo.hasUnpiped = true;
21898            cleanup();
21899          }
21900        }
21901      }
21902      function onend() {
21903        debug("onend");
21904        dest.end();
21905      }
21906      var ondrain = pipeOnDrain(src2);
21907      dest.on("drain", ondrain);
21908      var cleanedUp = false;
21909      function cleanup() {
21910        debug("cleanup");
21911        dest.removeListener("close", onclose);
21912        dest.removeListener("finish", onfinish);
21913        dest.removeListener("drain", ondrain);
21914        dest.removeListener("error", onerror);
21915        dest.removeListener("unpipe", onunpipe);
21916        src2.removeListener("end", onend);
21917        src2.removeListener("end", unpipe);
21918        src2.removeListener("data", ondata);
21919        cleanedUp = true;
21920        if (state2.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
21921      }
21922      src2.on("data", ondata);
21923      function ondata(chunk) {
21924        debug("ondata");
21925        var ret = dest.write(chunk);
21926        debug("dest.write", ret);
21927        if (ret === false) {
21928          if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf2(state2.pipes, dest) !== -1) && !cleanedUp) {
21929            debug("false write response, pause", state2.awaitDrain);
21930            state2.awaitDrain++;
21931          }
21932          src2.pause();
21933        }
21934      }
21935      function onerror(er) {
21936        debug("onerror", er);
21937        unpipe();
21938        dest.removeListener("error", onerror);
21939        if (EElistenerCount(dest, "error") === 0) errorOrDestroy(dest, er);
21940      }
21941      prependListener(dest, "error", onerror);
21942      function onclose() {
21943        dest.removeListener("finish", onfinish);
21944        unpipe();
21945      }
21946      dest.once("close", onclose);
21947      function onfinish() {
21948        debug("onfinish");
21949        dest.removeListener("close", onclose);
21950        unpipe();
21951      }
21952      dest.once("finish", onfinish);
21953      function unpipe() {
21954        debug("unpipe");
21955        src2.unpipe(dest);
21956      }
21957      dest.emit("pipe", src2);
21958      if (!state2.flowing) {
21959        debug("pipe resume");
21960        src2.resume();
21961      }
21962      return dest;
21963    };
21964    function pipeOnDrain(src2) {
21965      return function pipeOnDrainFunctionResult() {
21966        var state2 = src2._readableState;
21967        debug("pipeOnDrain", state2.awaitDrain);
21968        if (state2.awaitDrain) state2.awaitDrain--;
21969        if (state2.awaitDrain === 0 && EElistenerCount(src2, "data")) {
21970          state2.flowing = true;
21971          flow(src2);
21972        }
21973      };
21974    }
21975    Readable.prototype.unpipe = function(dest) {
21976      var state2 = this._readableState;
21977      var unpipeInfo = {
21978        hasUnpiped: false
21979      };
21980      if (state2.pipesCount === 0) return this;
21981      if (state2.pipesCount === 1) {
21982        if (dest && dest !== state2.pipes) return this;
21983        if (!dest) dest = state2.pipes;
21984        state2.pipes = null;
21985        state2.pipesCount = 0;
21986        state2.flowing = false;
21987        if (dest) dest.emit("unpipe", this, unpipeInfo);
21988        return this;
21989      }
21990      if (!dest) {
21991        var dests = state2.pipes;
21992        var len2 = state2.pipesCount;
21993        state2.pipes = null;
21994        state2.pipesCount = 0;
21995        state2.flowing = false;
21996        for (var i2 = 0; i2 < len2; i2++) dests[i2].emit("unpipe", this, {
21997          hasUnpiped: false
21998        });
21999        return this;
22000      }
22001      var index = indexOf2(state2.pipes, dest);
22002      if (index === -1) return this;
22003      state2.pipes.splice(index, 1);
22004      state2.pipesCount -= 1;
22005      if (state2.pipesCount === 1) state2.pipes = state2.pipes[0];
22006      dest.emit("unpipe", this, unpipeInfo);
22007      return this;
22008    };
22009    Readable.prototype.on = function(ev, fn) {
22010      var res = Stream.prototype.on.call(this, ev, fn);
22011      var state2 = this._readableState;
22012      if (ev === "data") {
22013        state2.readableListening = this.listenerCount("readable") > 0;
22014        if (state2.flowing !== false) this.resume();
22015      } else if (ev === "readable") {
22016        if (!state2.endEmitted && !state2.readableListening) {
22017          state2.readableListening = state2.needReadable = true;
22018          state2.flowing = false;

vendor: 4,762 bytes, lines 22019-22159

22019          state2.emittedReadable = false;
22020          debug("on readable", state2.length, state2.reading);
22021          if (state2.length) {
22022            emitReadable(this);
22023          } else if (!state2.reading) {
22024            process$1.nextTick(nReadingNextTick, this);
22025          }
22026        }
22027      }
22028      return res;
22029    };
22030    Readable.prototype.addListener = Readable.prototype.on;
22031    Readable.prototype.removeListener = function(ev, fn) {
22032      var res = Stream.prototype.removeListener.call(this, ev, fn);
22033      if (ev === "readable") {
22034        process$1.nextTick(updateReadableListening, this);
22035      }
22036      return res;
22037    };
22038    Readable.prototype.removeAllListeners = function(ev) {
22039      var res = Stream.prototype.removeAllListeners.apply(this, arguments);
22040      if (ev === "readable" || ev === void 0) {
22041        process$1.nextTick(updateReadableListening, this);
22042      }
22043      return res;
22044    };
22045    function updateReadableListening(self2) {
22046      var state2 = self2._readableState;
22047      state2.readableListening = self2.listenerCount("readable") > 0;
22048      if (state2.resumeScheduled && !state2.paused) {
22049        state2.flowing = true;
22050      } else if (self2.listenerCount("data") > 0) {
22051        self2.resume();
22052      }
22053    }
22054    function nReadingNextTick(self2) {
22055      debug("readable nexttick read 0");
22056      self2.read(0);
22057    }
22058    Readable.prototype.resume = function() {
22059      var state2 = this._readableState;
22060      if (!state2.flowing) {
22061        debug("resume");
22062        state2.flowing = !state2.readableListening;
22063        resume(this, state2);
22064      }
22065      state2.paused = false;
22066      return this;
22067    };
22068    function resume(stream2, state2) {
22069      if (!state2.resumeScheduled) {
22070        state2.resumeScheduled = true;
22071        process$1.nextTick(resume_, stream2, state2);
22072      }
22073    }
22074    function resume_(stream2, state2) {
22075      debug("resume", state2.reading);
22076      if (!state2.reading) {
22077        stream2.read(0);
22078      }
22079      state2.resumeScheduled = false;
22080      stream2.emit("resume");
22081      flow(stream2);
22082      if (state2.flowing && !state2.reading) stream2.read(0);
22083    }
22084    Readable.prototype.pause = function() {
22085      debug("call pause flowing=%j", this._readableState.flowing);
22086      if (this._readableState.flowing !== false) {
22087        debug("pause");
22088        this._readableState.flowing = false;
22089        this.emit("pause");
22090      }
22091      this._readableState.paused = true;
22092      return this;
22093    };
22094    function flow(stream2) {
22095      var state2 = stream2._readableState;
22096      debug("flow", state2.flowing);
22097      while (state2.flowing && stream2.read() !== null) ;
22098    }
22099    Readable.prototype.wrap = function(stream2) {
22100      var _this = this;
22101      var state2 = this._readableState;
22102      var paused = false;
22103      stream2.on("end", function() {
22104        debug("wrapped end");
22105        if (state2.decoder && !state2.ended) {
22106          var chunk = state2.decoder.end();
22107          if (chunk && chunk.length) _this.push(chunk);
22108        }
22109        _this.push(null);
22110      });
22111      stream2.on("data", function(chunk) {
22112        debug("wrapped data");
22113        if (state2.decoder) chunk = state2.decoder.write(chunk);
22114        if (state2.objectMode && (chunk === null || chunk === void 0)) return;
22115        else if (!state2.objectMode && (!chunk || !chunk.length)) return;
22116        var ret = _this.push(chunk);
22117        if (!ret) {
22118          paused = true;
22119          stream2.pause();
22120        }
22121      });
22122      for (var i2 in stream2) {
22123        if (this[i2] === void 0 && typeof stream2[i2] === "function") {
22124          this[i2] = /* @__PURE__ */ (function methodWrap(method) {
22125            return function methodWrapReturnFunction() {
22126              return stream2[method].apply(stream2, arguments);
22127            };
22128          })(i2);
22129        }
22130      }
22131      for (var n = 0; n < kProxyEvents.length; n++) {
22132        stream2.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
22133      }
22134      this._read = function(n2) {
22135        debug("wrapped _read", n2);
22136        if (paused) {
22137          paused = false;
22138          stream2.resume();
22139        }
22140      };
22141      return this;
22142    };
22143    if (typeof Symbol === "function") {
22144      Readable.prototype[Symbol.asyncIterator] = function() {
22145        if (createReadableStreamAsyncIterator === void 0) {
22146          createReadableStreamAsyncIterator = requireAsync_iterator();
22147        }
22148        return createReadableStreamAsyncIterator(this);
22149      };
22150    }
22151    Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
22152      // making it explicit this property is not enumerable
22153      // because otherwise some prototype manipulation in
22154      // userland will fail
22155      enumerable: false,
22156      get: function get2() {
22157        return this._readableState.highWaterMark;
22158      }
22159    });

vendor: 4,497 bytes, lines 22160-22284

22160    Object.defineProperty(Readable.prototype, "readableBuffer", {
22161      // making it explicit this property is not enumerable
22162      // because otherwise some prototype manipulation in
22163      // userland will fail
22164      enumerable: false,
22165      get: function get2() {
22166        return this._readableState && this._readableState.buffer;
22167      }
22168    });
22169    Object.defineProperty(Readable.prototype, "readableFlowing", {
22170      // making it explicit this property is not enumerable
22171      // because otherwise some prototype manipulation in
22172      // userland will fail
22173      enumerable: false,
22174      get: function get2() {
22175        return this._readableState.flowing;
22176      },
22177      set: function set(state2) {
22178        if (this._readableState) {
22179          this._readableState.flowing = state2;
22180        }
22181      }
22182    });
22183    Readable._fromList = fromList;
22184    Object.defineProperty(Readable.prototype, "readableLength", {
22185      // making it explicit this property is not enumerable
22186      // because otherwise some prototype manipulation in
22187      // userland will fail
22188      enumerable: false,
22189      get: function get2() {
22190        return this._readableState.length;
22191      }
22192    });
22193    function fromList(n, state2) {
22194      if (state2.length === 0) return null;
22195      var ret;
22196      if (state2.objectMode) ret = state2.buffer.shift();
22197      else if (!n || n >= state2.length) {
22198        if (state2.decoder) ret = state2.buffer.join("");
22199        else if (state2.buffer.length === 1) ret = state2.buffer.first();
22200        else ret = state2.buffer.concat(state2.length);
22201        state2.buffer.clear();
22202      } else {
22203        ret = state2.buffer.consume(n, state2.decoder);
22204      }
22205      return ret;
22206    }
22207    function endReadable(stream2) {
22208      var state2 = stream2._readableState;
22209      debug("endReadable", state2.endEmitted);
22210      if (!state2.endEmitted) {
22211        state2.ended = true;
22212        process$1.nextTick(endReadableNT, state2, stream2);
22213      }
22214    }
22215    function endReadableNT(state2, stream2) {
22216      debug("endReadableNT", state2.endEmitted, state2.length);
22217      if (!state2.endEmitted && state2.length === 0) {
22218        state2.endEmitted = true;
22219        stream2.readable = false;
22220        stream2.emit("end");
22221        if (state2.autoDestroy) {
22222          var wState = stream2._writableState;
22223          if (!wState || wState.autoDestroy && wState.finished) {
22224            stream2.destroy();
22225          }
22226        }
22227      }
22228    }
22229    if (typeof Symbol === "function") {
22230      Readable.from = function(iterable, opts) {
22231        if (from === void 0) {
22232          from = requireFrom();
22233        }
22234        return from(Readable, iterable, opts);
22235      };
22236    }
22237    function indexOf2(xs, x) {
22238      for (var i2 = 0, l = xs.length; i2 < l; i2++) {
22239        if (xs[i2] === x) return i2;
22240      }
22241      return -1;
22242    }
22243    return _stream_readable$1;
22244  }
22245  var _stream_transform$1;
22246  var hasRequired_stream_transform$1;
22247  function require_stream_transform$1() {
22248    if (hasRequired_stream_transform$1) return _stream_transform$1;
22249    hasRequired_stream_transform$1 = 1;
22250    _stream_transform$1 = Transform;
22251    var _require$codes = requireErrors$1().codes, ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
22252    var Duplex = require_stream_duplex$1();
22253    requireInherits()(Transform, Duplex);
22254    function afterTransform(er, data) {
22255      var ts = this._transformState;
22256      ts.transforming = false;
22257      var cb = ts.writecb;
22258      if (cb === null) {
22259        return this.emit("error", new ERR_MULTIPLE_CALLBACK());
22260      }
22261      ts.writechunk = null;
22262      ts.writecb = null;
22263      if (data != null)
22264        this.push(data);
22265      cb(er);
22266      var rs = this._readableState;
22267      rs.reading = false;
22268      if (rs.needReadable || rs.length < rs.highWaterMark) {
22269        this._read(rs.highWaterMark);
22270      }
22271    }
22272    function Transform(options) {
22273      if (!(this instanceof Transform)) return new Transform(options);
22274      Duplex.call(this, options);
22275      this._transformState = {
22276        afterTransform: afterTransform.bind(this),
22277        needTransform: false,
22278        transforming: false,
22279        writecb: null,
22280        writechunk: null,
22281        writeencoding: null
22282      };
22283      this._readableState.needReadable = true;
22284      this._readableState.sync = false;

vendor: 8,701 bytes, lines 22285-22543

22285      if (options) {
22286        if (typeof options.transform === "function") this._transform = options.transform;
22287        if (typeof options.flush === "function") this._flush = options.flush;
22288      }
22289      this.on("prefinish", prefinish);
22290    }
22291    function prefinish() {
22292      var _this = this;
22293      if (typeof this._flush === "function" && !this._readableState.destroyed) {
22294        this._flush(function(er, data) {
22295          done(_this, er, data);
22296        });
22297      } else {
22298        done(this, null, null);
22299      }
22300    }
22301    Transform.prototype.push = function(chunk, encoding) {
22302      this._transformState.needTransform = false;
22303      return Duplex.prototype.push.call(this, chunk, encoding);
22304    };
22305    Transform.prototype._transform = function(chunk, encoding, cb) {
22306      cb(new ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
22307    };
22308    Transform.prototype._write = function(chunk, encoding, cb) {
22309      var ts = this._transformState;
22310      ts.writecb = cb;
22311      ts.writechunk = chunk;
22312      ts.writeencoding = encoding;
22313      if (!ts.transforming) {
22314        var rs = this._readableState;
22315        if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
22316      }
22317    };
22318    Transform.prototype._read = function(n) {
22319      var ts = this._transformState;
22320      if (ts.writechunk !== null && !ts.transforming) {
22321        ts.transforming = true;
22322        this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
22323      } else {
22324        ts.needTransform = true;
22325      }
22326    };
22327    Transform.prototype._destroy = function(err, cb) {
22328      Duplex.prototype._destroy.call(this, err, function(err2) {
22329        cb(err2);
22330      });
22331    };
22332    function done(stream2, er, data) {
22333      if (er) return stream2.emit("error", er);
22334      if (data != null)
22335        stream2.push(data);
22336      if (stream2._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
22337      if (stream2._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
22338      return stream2.push(null);
22339    }
22340    return _stream_transform$1;
22341  }
22342  var _stream_passthrough$1;
22343  var hasRequired_stream_passthrough$1;
22344  function require_stream_passthrough$1() {
22345    if (hasRequired_stream_passthrough$1) return _stream_passthrough$1;
22346    hasRequired_stream_passthrough$1 = 1;
22347    _stream_passthrough$1 = PassThrough;
22348    var Transform = require_stream_transform$1();
22349    requireInherits()(PassThrough, Transform);
22350    function PassThrough(options) {
22351      if (!(this instanceof PassThrough)) return new PassThrough(options);
22352      Transform.call(this, options);
22353    }
22354    PassThrough.prototype._transform = function(chunk, encoding, cb) {
22355      cb(null, chunk);
22356    };
22357    return _stream_passthrough$1;
22358  }
22359  var pipeline_1;
22360  var hasRequiredPipeline;
22361  function requirePipeline() {
22362    if (hasRequiredPipeline) return pipeline_1;
22363    hasRequiredPipeline = 1;
22364    var eos;
22365    function once(callback) {
22366      var called = false;
22367      return function() {
22368        if (called) return;
22369        called = true;
22370        callback.apply(void 0, arguments);
22371      };
22372    }
22373    var _require$codes = requireErrors$1().codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
22374    function noop2(err) {
22375      if (err) throw err;
22376    }
22377    function isRequest2(stream2) {
22378      return stream2.setHeader && typeof stream2.abort === "function";
22379    }
22380    function destroyer(stream2, reading, writing, callback) {
22381      callback = once(callback);
22382      var closed = false;
22383      stream2.on("close", function() {
22384        closed = true;
22385      });
22386      if (eos === void 0) eos = requireEndOfStream();
22387      eos(stream2, {
22388        readable: reading,
22389        writable: writing
22390      }, function(err) {
22391        if (err) return callback(err);
22392        closed = true;
22393        callback();
22394      });
22395      var destroyed = false;
22396      return function(err) {
22397        if (closed) return;
22398        if (destroyed) return;
22399        destroyed = true;
22400        if (isRequest2(stream2)) return stream2.abort();
22401        if (typeof stream2.destroy === "function") return stream2.destroy();
22402        callback(err || new ERR_STREAM_DESTROYED("pipe"));
22403      };
22404    }
22405    function call(fn) {
22406      fn();
22407    }
22408    function pipe(from, to) {
22409      return from.pipe(to);
22410    }
22411    function popCallback(streams) {
22412      if (!streams.length) return noop2;
22413      if (typeof streams[streams.length - 1] !== "function") return noop2;
22414      return streams.pop();
22415    }
22416    function pipeline() {
22417      for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
22418        streams[_key] = arguments[_key];
22419      }
22420      var callback = popCallback(streams);
22421      if (Array.isArray(streams[0])) streams = streams[0];
22422      if (streams.length < 2) {
22423        throw new ERR_MISSING_ARGS("streams");
22424      }
22425      var error;
22426      var destroys = streams.map(function(stream2, i2) {
22427        var reading = i2 < streams.length - 1;
22428        var writing = i2 > 0;
22429        return destroyer(stream2, reading, writing, function(err) {
22430          if (!error) error = err;
22431          if (err) destroys.forEach(call);
22432          if (reading) return;
22433          destroys.forEach(call);
22434          callback(error);
22435        });
22436      });
22437      return streams.reduce(pipe);
22438    }
22439    pipeline_1 = pipeline;
22440    return pipeline_1;
22441  }
22442  var streamBrowserify;
22443  var hasRequiredStreamBrowserify;
22444  function requireStreamBrowserify() {
22445    if (hasRequiredStreamBrowserify) return streamBrowserify;
22446    hasRequiredStreamBrowserify = 1;
22447    streamBrowserify = Stream;
22448    var EE = requireEvents().EventEmitter;
22449    var inherits2 = requireInherits();
22450    inherits2(Stream, EE);
22451    Stream.Readable = require_stream_readable$1();
22452    Stream.Writable = require_stream_writable$1();
22453    Stream.Duplex = require_stream_duplex$1();
22454    Stream.Transform = require_stream_transform$1();
22455    Stream.PassThrough = require_stream_passthrough$1();
22456    Stream.finished = requireEndOfStream();
22457    Stream.pipeline = requirePipeline();
22458    Stream.Stream = Stream;
22459    function Stream() {
22460      EE.call(this);
22461    }
22462    Stream.prototype.pipe = function(dest, options) {
22463      var source = this;
22464      function ondata(chunk) {
22465        if (dest.writable) {
22466          if (false === dest.write(chunk) && source.pause) {
22467            source.pause();
22468          }
22469        }
22470      }
22471      source.on("data", ondata);
22472      function ondrain() {
22473        if (source.readable && source.resume) {
22474          source.resume();
22475        }
22476      }
22477      dest.on("drain", ondrain);
22478      if (!dest._isStdio && (!options || options.end !== false)) {
22479        source.on("end", onend);
22480        source.on("close", onclose);
22481      }
22482      var didOnEnd = false;
22483      function onend() {
22484        if (didOnEnd) return;
22485        didOnEnd = true;
22486        dest.end();
22487      }
22488      function onclose() {
22489        if (didOnEnd) return;
22490        didOnEnd = true;
22491        if (typeof dest.destroy === "function") dest.destroy();
22492      }
22493      function onerror(er) {
22494        cleanup();
22495        if (EE.listenerCount(this, "error") === 0) {
22496          throw er;
22497        }
22498      }
22499      source.on("error", onerror);
22500      dest.on("error", onerror);
22501      function cleanup() {
22502        source.removeListener("data", ondata);
22503        dest.removeListener("drain", ondrain);
22504        source.removeListener("end", onend);
22505        source.removeListener("close", onclose);
22506        source.removeListener("error", onerror);
22507        dest.removeListener("error", onerror);
22508        source.removeListener("end", cleanup);
22509        source.removeListener("close", cleanup);
22510        dest.removeListener("close", cleanup);
22511      }
22512      source.on("end", cleanup);
22513      source.on("close", cleanup);
22514      dest.on("close", cleanup);
22515      dest.emit("pipe", source);
22516      return dest;
22517    };
22518    return streamBrowserify;
22519  }
22520  var delayed_stream;
22521  var hasRequiredDelayed_stream;
22522  function requireDelayed_stream() {
22523    if (hasRequiredDelayed_stream) return delayed_stream;
22524    hasRequiredDelayed_stream = 1;
22525    var Stream = requireStreamBrowserify().Stream;
22526    var util2 = requireUtil$1();
22527    delayed_stream = DelayedStream;
22528    function DelayedStream() {
22529      this.source = null;
22530      this.dataSize = 0;
22531      this.maxDataSize = 1024 * 1024;
22532      this.pauseStream = true;
22533      this._maxDataSizeExceeded = false;
22534      this._released = false;
22535      this._bufferedEvents = [];
22536    }
22537    util2.inherits(DelayedStream, Stream);
22538    DelayedStream.create = function(source, options) {
22539      var delayedStream = new this();
22540      options = options || {};
22541      for (var option in options) {
22542        delayedStream[option] = options[option];
22543      }

vendor: 4,267 bytes, lines 22544-22675

22544      delayedStream.source = source;
22545      var realEmit = source.emit;
22546      source.emit = function() {
22547        delayedStream._handleEmit(arguments);
22548        return realEmit.apply(source, arguments);
22549      };
22550      source.on("error", function() {
22551      });
22552      if (delayedStream.pauseStream) {
22553        source.pause();
22554      }
22555      return delayedStream;
22556    };
22557    Object.defineProperty(DelayedStream.prototype, "readable", {
22558      configurable: true,
22559      enumerable: true,
22560      get: function() {
22561        return this.source.readable;
22562      }
22563    });
22564    DelayedStream.prototype.setEncoding = function() {
22565      return this.source.setEncoding.apply(this.source, arguments);
22566    };
22567    DelayedStream.prototype.resume = function() {
22568      if (!this._released) {
22569        this.release();
22570      }
22571      this.source.resume();
22572    };
22573    DelayedStream.prototype.pause = function() {
22574      this.source.pause();
22575    };
22576    DelayedStream.prototype.release = function() {
22577      this._released = true;
22578      this._bufferedEvents.forEach((function(args) {
22579        this.emit.apply(this, args);
22580      }).bind(this));
22581      this._bufferedEvents = [];
22582    };
22583    DelayedStream.prototype.pipe = function() {
22584      var r = Stream.prototype.pipe.apply(this, arguments);
22585      this.resume();
22586      return r;
22587    };
22588    DelayedStream.prototype._handleEmit = function(args) {
22589      if (this._released) {
22590        this.emit.apply(this, args);
22591        return;
22592      }
22593      if (args[0] === "data") {
22594        this.dataSize += args[1].length;
22595        this._checkIfMaxDataSizeExceeded();
22596      }
22597      this._bufferedEvents.push(args);
22598    };
22599    DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
22600      if (this._maxDataSizeExceeded) {
22601        return;
22602      }
22603      if (this.dataSize <= this.maxDataSize) {
22604        return;
22605      }
22606      this._maxDataSizeExceeded = true;
22607      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
22608      this.emit("error", new Error(message));
22609    };
22610    return delayed_stream;
22611  }
22612  var combined_stream;
22613  var hasRequiredCombined_stream;
22614  function requireCombined_stream() {
22615    if (hasRequiredCombined_stream) return combined_stream;
22616    hasRequiredCombined_stream = 1;
22617    var util2 = requireUtil$1();
22618    var Stream = requireStreamBrowserify().Stream;
22619    var DelayedStream = requireDelayed_stream();
22620    combined_stream = CombinedStream;
22621    function CombinedStream() {
22622      this.writable = false;
22623      this.readable = true;
22624      this.dataSize = 0;
22625      this.maxDataSize = 2 * 1024 * 1024;
22626      this.pauseStreams = true;
22627      this._released = false;
22628      this._streams = [];
22629      this._currentStream = null;
22630      this._insideLoop = false;
22631      this._pendingNext = false;
22632    }
22633    util2.inherits(CombinedStream, Stream);
22634    CombinedStream.create = function(options) {
22635      var combinedStream = new this();
22636      options = options || {};
22637      for (var option in options) {
22638        combinedStream[option] = options[option];
22639      }
22640      return combinedStream;
22641    };
22642    CombinedStream.isStreamLike = function(stream2) {
22643      return typeof stream2 !== "function" && typeof stream2 !== "string" && typeof stream2 !== "boolean" && typeof stream2 !== "number" && !Buffer.isBuffer(stream2);
22644    };
22645    CombinedStream.prototype.append = function(stream2) {
22646      var isStreamLike = CombinedStream.isStreamLike(stream2);
22647      if (isStreamLike) {
22648        if (!(stream2 instanceof DelayedStream)) {
22649          var newStream = DelayedStream.create(stream2, {
22650            maxDataSize: Infinity,
22651            pauseStream: this.pauseStreams
22652          });
22653          stream2.on("data", this._checkDataSize.bind(this));
22654          stream2 = newStream;
22655        }
22656        this._handleErrors(stream2);
22657        if (this.pauseStreams) {
22658          stream2.pause();
22659        }
22660      }
22661      this._streams.push(stream2);
22662      return this;
22663    };
22664    CombinedStream.prototype.pipe = function(dest, options) {
22665      Stream.prototype.pipe.call(this, dest, options);
22666      this.resume();
22667      return dest;
22668    };
22669    CombinedStream.prototype._getNext = function() {
22670      this._currentStream = null;
22671      if (this._insideLoop) {
22672        this._pendingNext = true;
22673        return;
22674      }
22675      this._insideLoop = true;

22676      try {
22677        do {
22678          this._pendingNext = false;
22679          this._realGetNext();
22680        } while (this._pendingNext);
22681      } finally {
22682        this._insideLoop = false;
22683      }
22684    };
22685    CombinedStream.prototype._realGetNext = function() {
22686      var stream2 = this._streams.shift();
22687      if (typeof stream2 == "undefined") {
22688        this.end();
22689        return;
22690      }
22691      if (typeof stream2 !== "function") {
22692        this._pipeNext(stream2);
22693        return;
22694      }
22695      var getStream = stream2;
22696      getStream((function(stream3) {
22697        var isStreamLike = CombinedStream.isStreamLike(stream3);
22698        if (isStreamLike) {
22699          stream3.on("data", this._checkDataSize.bind(this));
22700          this._handleErrors(stream3);
22701        }
22702        this._pipeNext(stream3);
22703      }).bind(this));
22704    };
22705    CombinedStream.prototype._pipeNext = function(stream2) {
22706      this._currentStream = stream2;
22707      var isStreamLike = CombinedStream.isStreamLike(stream2);
22708      if (isStreamLike) {
22709        stream2.on("end", this._getNext.bind(this));
22710        stream2.pipe(this, { end: false });
22711        return;
22712      }
22713      var value = stream2;
22714      this.write(value);
22715      this._getNext();
22716    };
22717    CombinedStream.prototype._handleErrors = function(stream2) {
22718      var self2 = this;
22719      stream2.on("error", function(err) {
22720        self2._emitError(err);
22721      });
22722    };
22723    CombinedStream.prototype.write = function(data) {
22724      this.emit("data", data);
22725    };
22726    CombinedStream.prototype.pause = function() {
22727      if (!this.pauseStreams) {
22728        return;
22729      }
22730      if (this.pauseStreams && this._currentStream && typeof this._currentStream.pause == "function") this._currentStream.pause();
22731      this.emit("pause");
22732    };
22733    CombinedStream.prototype.resume = function() {
22734      if (!this._released) {
22735        this._released = true;
22736        this.writable = true;
22737        this._getNext();
22738      }
22739      if (this.pauseStreams && this._currentStream && typeof this._currentStream.resume == "function") this._currentStream.resume();
22740      this.emit("resume");
22741    };
22742    CombinedStream.prototype.end = function() {
22743      this._reset();
22744      this.emit("end");
22745    };
22746    CombinedStream.prototype.destroy = function() {
22747      this._reset();
22748      this.emit("close");
22749    };
22750    CombinedStream.prototype._reset = function() {
22751      this.writable = false;
22752      this._streams = [];
22753      this._currentStream = null;
22754    };
22755    CombinedStream.prototype._checkDataSize = function() {
22756      this._updateDataSize();
22757      if (this.dataSize <= this.maxDataSize) {
22758        return;
22759      }
22760      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
22761      this._emitError(new Error(message));
22762    };
22763    CombinedStream.prototype._updateDataSize = function() {
22764      this.dataSize = 0;
22765      var self2 = this;
22766      this._streams.forEach(function(stream2) {
22767        if (!stream2.dataSize) {
22768          return;
22769        }
22770        self2.dataSize += stream2.dataSize;
22771      });
22772      if (this._currentStream && this._currentStream.dataSize) {
22773        this.dataSize += this._currentStream.dataSize;
22774      }
22775    };
22776    CombinedStream.prototype._emitError = function(err) {
22777      this._reset();
22778      this.emit("error", err);
22779    };
22780    return combined_stream;
22781  }
22782  var pathBrowserify;
22783  var hasRequiredPathBrowserify;
22784  function requirePathBrowserify() {
22785    if (hasRequiredPathBrowserify) return pathBrowserify;
22786    hasRequiredPathBrowserify = 1;
22787    function assertPath(path) {
22788      if (typeof path !== "string") {
22789        throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
22790      }
22791    }
22792    function normalizeStringPosix(path, allowAboveRoot) {
22793      var res = "";
22794      var lastSegmentLength = 0;
22795      var lastSlash = -1;
22796      var dots = 0;
22797      var code2;
22798      for (var i2 = 0; i2 <= path.length; ++i2) {
22799        if (i2 < path.length)
22800          code2 = path.charCodeAt(i2);
22801        else if (code2 === 47)
22802          break;
22803        else
22804          code2 = 47;
22805        if (code2 === 47) {
22806          if (lastSlash === i2 - 1 || dots === 1) ;
22807          else if (lastSlash !== i2 - 1 && dots === 2) {
22808            if (res.length < 2 || lastSegmentLength !== 2 || res.charCo

vendor: 11,094 bytes, lines 22808-23149

22808deAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
22809              if (res.length > 2) {
22810                var lastSlashIndex = res.lastIndexOf("/");
22811                if (lastSlashIndex !== res.length - 1) {
22812                  if (lastSlashIndex === -1) {
22813                    res = "";
22814                    lastSegmentLength = 0;
22815                  } else {
22816                    res = res.slice(0, lastSlashIndex);
22817                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
22818                  }
22819                  lastSlash = i2;
22820                  dots = 0;
22821                  continue;
22822                }
22823              } else if (res.length === 2 || res.length === 1) {
22824                res = "";
22825                lastSegmentLength = 0;
22826                lastSlash = i2;
22827                dots = 0;
22828                continue;
22829              }
22830            }
22831            if (allowAboveRoot) {
22832              if (res.length > 0)
22833                res += "/..";
22834              else
22835                res = "..";
22836              lastSegmentLength = 2;
22837            }
22838          } else {
22839            if (res.length > 0)
22840              res += "/" + path.slice(lastSlash + 1, i2);
22841            else
22842              res = path.slice(lastSlash + 1, i2);
22843            lastSegmentLength = i2 - lastSlash - 1;
22844          }
22845          lastSlash = i2;
22846          dots = 0;
22847        } else if (code2 === 46 && dots !== -1) {
22848          ++dots;
22849        } else {
22850          dots = -1;
22851        }
22852      }
22853      return res;
22854    }
22855    function _format(sep, pathObject) {
22856      var dir = pathObject.dir || pathObject.root;
22857      var base2 = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
22858      if (!dir) {
22859        return base2;
22860      }
22861      if (dir === pathObject.root) {
22862        return dir + base2;
22863      }
22864      return dir + sep + base2;
22865    }
22866    var posix = {
22867      // path.resolve([from ...], to)
22868      resolve: function resolve() {
22869        var resolvedPath = "";
22870        var resolvedAbsolute = false;
22871        var cwd;
22872        for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
22873          var path;
22874          if (i2 >= 0)
22875            path = arguments[i2];
22876          else {
22877            if (cwd === void 0)
22878              cwd = process$1.cwd();
22879            path = cwd;
22880          }
22881          assertPath(path);
22882          if (path.length === 0) {
22883            continue;
22884          }
22885          resolvedPath = path + "/" + resolvedPath;
22886          resolvedAbsolute = path.charCodeAt(0) === 47;
22887        }
22888        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
22889        if (resolvedAbsolute) {
22890          if (resolvedPath.length > 0)
22891            return "/" + resolvedPath;
22892          else
22893            return "/";
22894        } else if (resolvedPath.length > 0) {
22895          return resolvedPath;
22896        } else {
22897          return ".";
22898        }
22899      },
22900      normalize: function normalize(path) {
22901        assertPath(path);
22902        if (path.length === 0) return ".";
22903        var isAbsolute = path.charCodeAt(0) === 47;
22904        var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
22905        path = normalizeStringPosix(path, !isAbsolute);
22906        if (path.length === 0 && !isAbsolute) path = ".";
22907        if (path.length > 0 && trailingSeparator) path += "/";
22908        if (isAbsolute) return "/" + path;
22909        return path;
22910      },
22911      isAbsolute: function isAbsolute(path) {
22912        assertPath(path);
22913        return path.length > 0 && path.charCodeAt(0) === 47;
22914      },
22915      join: function join() {
22916        if (arguments.length === 0)
22917          return ".";
22918        var joined;
22919        for (var i2 = 0; i2 < arguments.length; ++i2) {
22920          var arg = arguments[i2];
22921          assertPath(arg);
22922          if (arg.length > 0) {
22923            if (joined === void 0)
22924              joined = arg;
22925            else
22926              joined += "/" + arg;
22927          }
22928        }
22929        if (joined === void 0)
22930          return ".";
22931        return posix.normalize(joined);
22932      },
22933      relative: function relative(from, to) {
22934        assertPath(from);
22935        assertPath(to);
22936        if (from === to) return "";
22937        from = posix.resolve(from);
22938        to = posix.resolve(to);
22939        if (from === to) return "";
22940        var fromStart = 1;
22941        for (; fromStart < from.length; ++fromStart) {
22942          if (from.charCodeAt(fromStart) !== 47)
22943            break;
22944        }
22945        var fromEnd = from.length;
22946        var fromLen = fromEnd - fromStart;
22947        var toStart = 1;
22948        for (; toStart < to.length; ++toStart) {
22949          if (to.charCodeAt(toStart) !== 47)
22950            break;
22951        }
22952        var toEnd = to.length;
22953        var toLen = toEnd - toStart;
22954        var length = fromLen < toLen ? fromLen : toLen;
22955        var lastCommonSep = -1;
22956        var i2 = 0;
22957        for (; i2 <= length; ++i2) {
22958          if (i2 === length) {
22959            if (toLen > length) {
22960              if (to.charCodeAt(toStart + i2) === 47) {
22961                return to.slice(toStart + i2 + 1);
22962              } else if (i2 === 0) {
22963                return to.slice(toStart + i2);
22964              }
22965            } else if (fromLen > length) {
22966              if (from.charCodeAt(fromStart + i2) === 47) {
22967                lastCommonSep = i2;
22968              } else if (i2 === 0) {
22969                lastCommonSep = 0;
22970              }
22971            }
22972            break;
22973          }
22974          var fromCode = from.charCodeAt(fromStart + i2);
22975          var toCode = to.charCodeAt(toStart + i2);
22976          if (fromCode !== toCode)
22977            break;
22978          else if (fromCode === 47)
22979            lastCommonSep = i2;
22980        }
22981        var out = "";
22982        for (i2 = fromStart + lastCommonSep + 1; i2 <= fromEnd; ++i2) {
22983          if (i2 === fromEnd || from.charCodeAt(i2) === 47) {
22984            if (out.length === 0)
22985              out += "..";
22986            else
22987              out += "/..";
22988          }
22989        }
22990        if (out.length > 0)
22991          return out + to.slice(toStart + lastCommonSep);
22992        else {
22993          toStart += lastCommonSep;
22994          if (to.charCodeAt(toStart) === 47)
22995            ++toStart;
22996          return to.slice(toStart);
22997        }
22998      },
22999      _makeLong: function _makeLong(path) {
23000        return path;
23001      },
23002      dirname: function dirname(path) {
23003        assertPath(path);
23004        if (path.length === 0) return ".";
23005        var code2 = path.charCodeAt(0);
23006        var hasRoot = code2 === 47;
23007        var end = -1;
23008        var matchedSlash = true;
23009        for (var i2 = path.length - 1; i2 >= 1; --i2) {
23010          code2 = path.charCodeAt(i2);
23011          if (code2 === 47) {
23012            if (!matchedSlash) {
23013              end = i2;
23014              break;
23015            }
23016          } else {
23017            matchedSlash = false;
23018          }
23019        }
23020        if (end === -1) return hasRoot ? "/" : ".";
23021        if (hasRoot && end === 1) return "//";
23022        return path.slice(0, end);
23023      },
23024      basename: function basename(path, ext) {
23025        if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
23026        assertPath(path);
23027        var start = 0;
23028        var end = -1;
23029        var matchedSlash = true;
23030        var i2;
23031        if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
23032          if (ext.length === path.length && ext === path) return "";
23033          var extIdx = ext.length - 1;
23034          var firstNonSlashEnd = -1;
23035          for (i2 = path.length - 1; i2 >= 0; --i2) {
23036            var code2 = path.charCodeAt(i2);
23037            if (code2 === 47) {
23038              if (!matchedSlash) {
23039                start = i2 + 1;
23040                break;
23041              }
23042            } else {
23043              if (firstNonSlashEnd === -1) {
23044                matchedSlash = false;
23045                firstNonSlashEnd = i2 + 1;
23046              }
23047              if (extIdx >= 0) {
23048                if (code2 === ext.charCodeAt(extIdx)) {
23049                  if (--extIdx === -1) {
23050                    end = i2;
23051                  }
23052                } else {
23053                  extIdx = -1;
23054                  end = firstNonSlashEnd;
23055                }
23056              }
23057            }
23058          }
23059          if (start === end) end = firstNonSlashEnd;
23060          else if (end === -1) end = path.length;
23061          return path.slice(start, end);
23062        } else {
23063          for (i2 = path.length - 1; i2 >= 0; --i2) {
23064            if (path.charCodeAt(i2) === 47) {
23065              if (!matchedSlash) {
23066                start = i2 + 1;
23067                break;
23068              }
23069            } else if (end === -1) {
23070              matchedSlash = false;
23071              end = i2 + 1;
23072            }
23073          }
23074          if (end === -1) return "";
23075          return path.slice(start, end);
23076        }
23077      },
23078      extname: function extname(path) {
23079        assertPath(path);
23080        var startDot = -1;
23081        var startPart = 0;
23082        var end = -1;
23083        var matchedSlash = true;
23084        var preDotState = 0;
23085        for (var i2 = path.length - 1; i2 >= 0; --i2) {
23086          var code2 = path.charCodeAt(i2);
23087          if (code2 === 47) {
23088            if (!matchedSlash) {
23089              startPart = i2 + 1;
23090              break;
23091            }
23092            continue;
23093          }
23094          if (end === -1) {
23095            matchedSlash = false;
23096            end = i2 + 1;
23097          }
23098          if (code2 === 46) {
23099            if (startDot === -1)
23100              startDot = i2;
23101            else if (preDotState !== 1)
23102              preDotState = 1;
23103          } else if (startDot !== -1) {
23104            preDotState = -1;
23105          }
23106        }
23107        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
23108        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
23109        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
23110          return "";
23111        }
23112        return path.slice(startDot, end);
23113      },
23114      format: function format(pathObject) {
23115        if (pathObject === null || typeof pathObject !== "object") {
23116          throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
23117        }
23118        return _format("/", pathObject);
23119      },
23120      parse: function parse2(path) {
23121        assertPath(path);
23122        var ret = { root: "", dir: "", base: "", ext: "", name: "" };
23123        if (path.length === 0) return ret;
23124        var code2 = path.charCodeAt(0);
23125        var isAbsolute = code2 === 47;
23126        var start;
23127        if (isAbsolute) {
23128          ret.root = "/";
23129          start = 1;
23130        } else {
23131          start = 0;
23132        }
23133        var startDot = -1;
23134        var startPart = 0;
23135        var end = -1;
23136        var matchedSlash = true;
23137        var i2 = path.length - 1;
23138        var preDotState = 0;
23139        for (; i2 >= start; --i2) {
23140          code2 = path.charCodeAt(i2);
23141          if (code2 === 47) {
23142            if (!matchedSlash) {
23143              startPart = i2 + 1;
23144              break;
23145            }
23146            continue;
23147          }
23148          if (end === -1) {
23149            matchedSlash = false;

23150            end = i2 + 1;
23151          }
23152          if (code2 === 46) {
23153            if (startDot === -1) startDot = i2;
23154            else if (preDotState !== 1) preDotState = 1;
23155          } else if (startDot !== -1) {
23156            preDotState = -1;
23157          }
23158        }
23159        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
23160        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
23161        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
23162          if (end !== -1) {
23163            if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
23164            else ret.base = ret.name = path.slice(startPart, end);
23165          }
23166        } else {
23167          if (startPart === 0 && isAbsolute) {
23168            ret.name = path.slice(1, startDot);
23169            ret.base = path.slice(1, end);
23170          } else {
23171            ret.name = path.slice(startPart, startDot);
23172            ret.base = path.slice(startPart, end);
23173          }
23174          ret.ext = path.slice(startDot, end);
23175        }
23176        if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
23177        else if (isAbsolute) ret.dir = "/";
23178        return ret;
23179      },
23180      sep: "/",
23181      delimiter: ":",
23182      win32: null,
23183      posix: null
23184    };
23185    posix.posix = posix;
23186    pathBrowserify = posix;
23187    return pathBrowserify;
23188  }
23189  var streamHttp = {};
23190  var request = { exports: {} };
23191  var capability = {};
23192  var hasRequiredCapability;
23193  function requireCapability() {
23194    if (hasRequiredCapability) return capability;
23195    hasRequiredCapability = 1;
23196    (function(exports$12) {
23197      exports$12.fetch = isFunction2(commonjsGlobal.fetch) && isFunction2(commonjsGlobal.ReadableStream);
23198      exports$12.writableStream = isFunction2(commonjsGlobal.WritableStream);
23199      exports$12.abortController = isFunction2(commonjsGlobal.AbortController);
23200      var xhr;
23201      function getXHR() {
23202        if (xhr !== void 0) return xhr;
23203        if (commonjsGlobal.XMLHttpRequest) {
23204          xhr = new commonjsGlobal.XMLHttpRequest();
23205          try {
23206            xhr.open("GET", commonjsGlobal.XDomainRequest ? "/" : "https://example.com");
23207          } catch (e) {
23208            xhr = null;
23209          }
23210        } else {
23211          xhr = null;
23212        }
23213        return xhr;
23214      }

23215      function checkTypeSupport(type2) {
23216        var xhr2 = getXHR();
23217        if (!xhr2) return false;
23218        try {
23219          xhr2.responseType = type2;
23220          return xhr2.responseType === type2;
23221        } catch (e) {
23222        }
23223        return false;
23224      }
23225      exports$12.arraybuffer = exports$12.fetch || checkTypeSupport("arraybuffer");
23226      exports$12.msstream = !exports$12.fetch && checkTypeSupport("ms-stream");
23227      exports$12.mozchunkedarraybuffer = !exports$12.fetch && checkTypeSupport("moz-chunked-arraybuffer");
23228      exports$12.overrideMimeType = exports$12.fetch || (getXHR() ? isFunction2(getXHR().overrideMimeType) : false);
23229      function isFunction2(value) {
23230        return typeof value === "function";
23231      }
23232      xhr = null;
23233    })(capability);
23234    return capability;
23235  }
23236  var response = {};
23237  var readable$1 = { exports: {} };
23238  var hasRequiredReadable$1;
23239  function requireReadable$1() {
23240    if (hasRequiredReadable$1) return readable$1.exports;
23241    hasRequiredReadable$1 = 1;
23242    (function(module, exports$12) {
23243      var define_process_env_default2 = {};
23244      var Stream = requireStreamBrowserify();
23245      if (define_process_env_default2.READABLE_STREAM === "disable" && Stream) {
23246        module.exports = Stream.Readable;
23247        Object.assign(module.exports, Stream);
23248        module.exports.Stream = Stream;
23249      } else {
23250        exports$12 = module.exports = require_stream_readable$1();
23251        exports$12.Stream = Stream || exports$12;
23252        exports$12.Readable = exports$12;
23253        exports$12.Writable = require_stream_writable$1();
23254        exports$12.Duplex = require_stream_duplex$1();
23255        exports$12.Transform = require_stream_transform$1();
23256        exports$12.PassThrough = require_stream_passthrough$1();
23257        exports$12.finished = requireEndOfStream();
23258        exports$12.pipeline = requirePipeline();
23259      }
23260    })(readable$1, readable$1.exports);
23261    return readable$1.exports;
23262  }
23263  var hasRequiredResponse;
23264  function requireResponse() {
23265    if (hasRequiredResponse) return response;
23266    hasRequiredResponse = 1;
23267    var capability2 = requireCapability();
23268    var inherits2 = requireInherits();
23269    var stream2 = requireReadable$1();
23270    var rStates = response.readyStates = {
23271      UNSENT: 0,
23272      OPENED: 1,
23273      HEADERS_RECEIVED: 2,
23274      LOADING: 3,
23275      DONE: 4
23276    };
23277    var IncomingMessage = response.IncomingMessage = function(xhr, response2, mode, resetTimers) {
23278      var self2 = this;
23279      stream2.Readable.call(self2);
23280      self2._mode = mode;
23281      self2.headers = {};
23282      self2.rawHeaders = [];
23283      self2.trailers = {};
23284      self2.rawTrailers = [];
23285      self2.on("end", function() {
23286        process$1.nextTick(function() {
23287          self2.emit("close");
23288        });
23289      });
23290      if (mode === "fetch") {
23291        let read = function() {
23292          reader.read().then(function(result) {
23293            if (self2._destroyed)
23294              return;
23295            resetTimers(result.done);
23296            if (result.done) {
23297              self2.push(null);
23298              return;
23299            }
23300            self2.push(Buffer.from(result.value));
23301            read();
23302          }).catch(function(err) {
23303            resetTimers(true);
23304            if (!self2._destroyed)
23305              self2.emit("error", err);
23306          });
23307        };
23308        self2._fetchResponse = response2;
23309        self2.url = response2.url;
23310        self2.statusCode = response2.status;
23311        self2.statusMessage = response2.statusText;
23312        response2.headers.forEach(function(header, key2) {
23313          self2.headers[key2.toLowerCase()] = header;
23314          self2.rawHeaders.push(key2, header);
23315        });
23316        if (capability2.writableStream) {
23317          var writable = new WritableStream({
23318            write: function(chunk) {
23319              resetTimers(false);
23320              return new Promise(function(resolve, reject) {
23321                if (self2._destroyed) {
23322                  reject();
23323                } else if (self2.push(Buffer.from(chunk))) {
23324                  resolve();
23325                } else {
23326                  self2._resumeFetch = resolve;
23327                }
23328              });
23329            },
23330            close: function() {
23331              resetTimers(true);
23332              if (!self2._destroyed)
23333                self2.push(null);
23334            },
23335            abort: function(err) {
23336              resetTimers(true);
23337              if (!self2._destroyed)
23338                self2.emit("error", err);
23339            }
23340          });
23341          try {
23342            response2.body.pipeTo(writable).catch(function(err) {
23343              resetTimers(true);
23344              if (!self2._destroyed)
23345                self2.emit("error", err);
23346            });
23347            return;
23348          } catch (e) {
23349          }
23350        }
23351        var reader = response2.body.getReader();
23352        read();
23353      } else {
23354        self2._xhr = xhr;
23355        self2._pos = 0;
23356        self2.url = xhr.responseURL;
23357        self2.statusCode = xhr.status;
23358        self2.statusMessage = xhr.statusText;
23359        var headers = xhr.getAllResponseHeaders().split(/\r?\n/);

23360        headers.forEach(function(header) {
23361          var matches = header.match(/^([^:]+):\s*(.*)/);
23362          if (matches) {
23363            var key2 = matches[1].toLowerCase();
23364            if (key2 === "set-cookie") {
23365              if (self2.headers[key2] === void 0) {
23366                self2.headers[key2] = [];
23367              }
23368              self2.headers[key2].push(matches[2]);
23369            } else if (self2.headers[key2] !== void 0) {
23370              self2.headers[key2] += ", " + matches[2];
23371            } else {
23372              self2.headers[key2] = matches[2];
23373            }
23374            self2.rawHeaders.push(matches[1], matches[2]);
23375          }
23376        });
23377        self2._charset = "x-user-defined";
23378        if (!capability2.overrideMimeType) {
23379          var mimeType = self2.rawHeaders["mime-type"];
23380          if (mimeType) {
23381            var charsetMatch = mimeType.match(/;\s*charset=([^;])(;|$)/);
23382            if (charsetMatch) {
23383              self2._charset = charsetMatch[1].toLowerCase();
23384            }
23385          }
23386          if (!self2._charset)
23387            self2._charset = "utf-8";
23388        }
23389      }
23390    };
23391    inherits2(IncomingMessage, stream2.Readable);
23392    IncomingMessage.prototype._read = function() {
23393      var self2 = this;
23394      var resolve = self2._resumeFetch;
23395      if (resolve) {
23396        self2._resumeFetch = null;
23397        resolve();
23398      }
23399    };
23400    IncomingMessage.prototype._onXHRProgress = function(resetTimers) {
23401      var self2 = this;
23402      var xhr = self2._xhr;
23403      var response2 = null;
23404      switch (self2._mode) {
23405        case "text":
23406          response2 = xhr.responseText;
23407          if (response2.length > self2._pos) {
23408            var newData = response2.substr(self2._pos);
23409            if (self2._charset === "x-user-defined") {
23410              var buffer2 = Buffer.alloc(newData.length);
23411              for (var i2 = 0; i2 < newData.length; i2++)
23412                buffer2[i2] = newData.charCodeAt(i2) & 255;
23413              self2.push(buffer2);
23414            } else {
23415              self2.push(newData, self2._charset);
23416            }
23417            self2._pos = response2.length;
23418          }
23419          break;
23420        case "arraybuffer":
23421          if (xhr.readyState !== rStates.DONE || !xhr.response)
23422            break;
23423          response2 = xhr.response;
23424          self2.push(Buffer.from(new Uint8Array(response2)));
23425          break;
23426        case "moz-chunked-arraybuffer":
23427          response2 = xhr.response;
23428          if (xhr.readyState !== rStates.LOADING || !response2)
23429            break;
23430          self2.push(Buffer.from(new Uint8Array(response2)));
23431          break;
23432        case "ms-stream":
23433          response2 = xhr.response;
23434          if (xhr.readyState !== rStates.LOADING)
23435            break;
23436          var reader = new commonjsGlobal.MSStreamReader();
23437          reader.onprogress = function() {
23438            if (reader.result.byteLength > self2._pos) {
23439              self2.push(Buffer.from(new Uint8Array(reader.result.slice(self2._pos))));
23440              self2._pos = reader.result.byteLength;
23441            }
23442          };
23443          reader.onload = function() {
23444            resetTimers(true);
23445            self2.push(null);
23446          };
23447          reader.readAsArrayBuffer(response2);
23448          break;
23449      }
23450      if (self2._xhr.readyState === rStates.DONE && self2._mode !== "ms-stream") {
23451        resetTimers(true);
23452        self2.push(null);
23453      }
23454    };
23455    return response;
23456  }
23457  var hasRequiredRequest;
23458  function requireRequest() {
23459    if (hasRequiredRequest) return request.exports;
23460    hasRequiredRequest = 1;
23461    var capability2 = requireCapability();
23462    var inherits2 = requireInherits();
23463    var response2 = requireResponse();
23464    var stream2 = requireReadable$1();
23465    var IncomingMessage = response2.IncomingMessage;
23466    var rStates = response2.readyStates;
23467    function decideMode(preferBinary, useFetch) {
23468      if (capability2.fetch && useFetch) {
23469        return "fetch";
23470      } else if (capability2.mozchunkedarraybuffer) {
23471        return "moz-chunked-arraybuffer";
23472      } else if (capability2.msstream) {
23473        return "ms-stream";
23474      } else if (capability2.arraybuffer && preferBinary) {
23475        return "arraybuffer";
23476      } else {
23477        return "text";
23478      }
23479    }
23480    var ClientRequest = request.exports = function(opts) {
23481      var self2 = this;
23482      stream2.Writable.call(self2);
23483      self2._opts = opts;
23484      self2._body = [];
23485      self2._headers = {};
23486      if (opts.auth)
23487        self2.setHeader("Authorization", "Basic " + Buffer.from(opts.auth).toString("base64"));

23488      Object.keys(opts.headers).forEach(function(name) {
23489        self2.setHeader(name, opts.headers[name]);
23490      });
23491      var preferBinary;
23492      var useFetch = true;
23493      if (opts.mode === "disable-fetch" || "requestTimeout" in opts && !capability2.abortController) {
23494        useFetch = false;
23495        preferBinary = true;
23496      } else if (opts.mode === "prefer-streaming") {
23497        preferBinary = false;
23498      } else if (opts.mode === "allow-wrong-content-type") {
23499        preferBinary = !capability2.overrideMimeType;
23500      } else if (!opts.mode || opts.mode === "default" || opts.mode === "prefer-fast") {
23501        preferBinary = true;
23502      } else {
23503        throw new Error("Invalid value for opts.mode");
23504      }
23505      self2._mode = decideMode(preferBinary, useFetch);
23506      self2._fetchTimer = null;
23507      self2._socketTimeout = null;
23508      self2._socketTimer = null;
23509      self2.on("finish", function() {
23510        self2._onFinish();
23511      });
23512    };
23513    inherits2(ClientRequest, stream2.Writable);
23514    ClientRequest.prototype.setHeader = function(name, value) {
23515      var self2 = this;
23516      var lowerName = name.toLowerCase();
23517      if (unsafeHeaders.indexOf(lowerName) !== -1)
23518        return;
23519      self2._headers[lowerName] = {
23520        name,
23521        value
23522      };
23523    };
23524    ClientRequest.prototype.getHeader = function(name) {
23525      var header = this._headers[name.toLowerCase()];
23526      if (header)
23527        return header.value;
23528      return null;
23529    };
23530    ClientRequest.prototype.removeHeader = function(name) {
23531      var self2 = this;
23532      delete self2._headers[name.toLowerCase()];
23533    };
23534    ClientRequest.prototype._onFinish = function() {
23535      var self2 = this;
23536      if (self2._destroyed)
23537        return;
23538      var opts = self2._opts;
23539      if ("timeout" in opts && opts.timeout !== 0) {
23540        self2.setTimeout(opts.timeout);
23541      }
23542      var headersObj = self2._headers;
23543      var body = null;
23544      if (opts.method !== "GET" && opts.method !== "HEAD") {
23545        body = new Blob(self2._body, {
23546          type: (headersObj["content-type"] || {}).value || ""
23547        });
23548      }
23549      var headersList = [];
23550      Object.keys(headersObj).forEach(function(keyName) {
23551        var name = headersObj[keyName].name;
23552        var value = headersObj[keyName].value;
23553        if (Array.isArray(value)) {
23554          value.forEach(function(v) {
23555            headersList.push([name, v]);
23556          });
23557        } else {
23558          headersList.push([name, value]);
23559        }
23560      });
23561      if (self2._mode === "fetch") {
23562        var signal = null;
23563        if (capability2.abortController) {
23564          var controller = new AbortController();
23565          signal = controller.signal;
23566          self2._fetchAbortController = controller;
23567          if ("requestTimeout" in opts && opts.requestTimeout !== 0) {
23568            self2._fetchTimer = commonjsGlobal.setTimeout(function() {
23569              self2.emit("requestTimeout");
23570              if (self2._fetchAbortController)
23571                self2._fetchAbortController.abort();
23572            }, opts.requestTimeout);
23573          }
23574        }
23575        commonjsGlobal.fetch(self2._opts.url, {
23576          method: self2._opts.method,
23577          headers: headersList,
23578          body: body || void 0,
23579          mode: "cors",
23580          credentials: opts.withCredentials ? "include" : "same-origin",
23581          signal
23582        }).then(function(response3) {
23583          self2._fetchResponse = response3;
23584          self2._resetTimers(false);
23585          self2._connect();
23586        }, function(reason) {
23587          self2._resetTimers(true);
23588          if (!self2._destroyed)
23589            self2.emit("error", reason);
23590        });
23591      } else {
23592        var xhr = self2._xhr = new commonjsGlobal.XMLHttpRequest();
23593        try {
23594          xhr.open(self2._opts.method, self2._opts.url, true);
23595        } catch (err) {
23596          process$1.nextTick(function() {
23597            self2.emit("error", err);
23598          });
23599          return;
23600        }
23601        if ("responseType" in xhr)
23602          xhr.responseType = self2._mode;
23603        if ("withCredentials" in xhr)
23604          xhr.withCredentials = !!opts.withCredentials;
23605        if (self2._mode === "text" && "overrideMimeType" in xhr)
23606          xhr.overrideMimeType("text/plain;

23606 charset=x-user-defined");
23607        if ("requestTimeout" in opts) {
23608          xhr.timeout = opts.requestTimeout;
23609          xhr.ontimeout = function() {
23610            self2.emit("requestTimeout");
23611          };
23612        }
23613        headersList.forEach(function(header) {
23614          xhr.setRequestHeader(header[0], header[1]);
23615        });
23616        self2._response = null;
23617        xhr.onreadystatechange = function() {
23618          switch (xhr.readyState) {
23619            case rStates.LOADING:
23620            case rStates.DONE:
23621              self2._onXHRProgress();
23622              break;
23623          }
23624        };
23625        if (self2._mode === "moz-chunked-arraybuffer") {
23626          xhr.onprogress = function() {
23627            self2._onXHRProgress();
23628          };
23629        }
23630        xhr.onerror = function() {
23631          if (self2._destroyed)
23632            return;
23633          self2._resetTimers(true);
23634          self2.emit("error", new Error("XHR error"));
23635        };
23636        try {
23637          xhr.send(body);
23638        } catch (err) {
23639          process$1.nextTick(function() {
23640            self2.emit("error", err);
23641          });
23642          return;
23643        }
23644      }
23645    };
23646    function statusValid(xhr) {
23647      try {
23648        var status = xhr.status;
23649        return status !== null && status !== 0;
23650      } catch (e) {
23651        return false;
23652      }
23653    }
23654    ClientRequest.prototype._onXHRProgress = function() {
23655      var self2 = this;
23656      self2._resetTimers(false);
23657      if (!statusValid(self2._xhr) || self2._destroyed)
23658        return;
23659      if (!self2._response)
23660        self2._connect();
23661      self2._response._onXHRProgress(self2._resetTimers.bind(self2));
23662    };
23663    ClientRequest.prototype._connect = function() {
23664      var self2 = this;
23665      if (self2._destroyed)
23666        return;
23667      self2._response = new IncomingMessage(self2._xhr, self2._fetchResponse, self2._mode, self2._resetTimers.bind(self2));
23668      self2._response.on("error", function(err) {
23669        self2.emit("error", err);
23670      });
23671      self2.emit("response", self2._response);
23672    };
23673    ClientRequest.prototype._write = function(chunk, encoding, cb) {
23674      var self2 = this;
23675      self2._body.push(chunk);
23676      cb();
23677    };
23678    ClientRequest.prototype._resetTimers = function(done) {
23679      var self2 = this;
23680      commonjsGlobal.clearTimeout(self2._socketTimer);
23681      self2._socketTimer = null;
23682      if (done) {
23683        commonjsGlobal.clearTimeout(self2._fetchTimer);
23684        self2._fetchTimer = null;
23685      } else if (self2._socketTimeout) {
23686        self2._socketTimer = commonjsGlobal.setTimeout(function() {
23687          self2.emit("timeout");
23688        }, self2._socketTimeout);
23689      }
23690    };
23691    ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function(err) {
23692      var self2 = this;
23693      self2._destroyed = true;
23694      self2._resetTimers(true);
23695      if (self2._response)
23696        self2._response._destroyed = true;
23697      if (self2._xhr)
23698        self2._xhr.abort();
23699      else if (self2._fetchAbortController)
23700        self2._fetchAbortController.abort();
23701      if (err)
23702        self2.emit("error", err);
23703    };
23704    ClientRequest.prototype.end = function(data, encoding, cb) {
23705      var self2 = this;
23706      if (typeof data === "function") {
23707        cb = data;
23708        data = void 0;
23709      }
23710      stream2.Writable.prototype.end.call(self2, data, encoding, cb);
23711    };
23712    ClientRequest.prototype.setTimeout = function(timeout, cb) {
23713      var self2 = this;
23714      if (cb)
23715        self2.once("timeout", cb);
23716      self2._socketTimeout = timeout;
23717      self2._resetTimers(false);
23718    };
23719    ClientRequest.prototype.flushHeaders = function() {
23720    };
23721    ClientRequest.prototype.setNoDelay = function() {
23722    };
23723    ClientRequest.prototype.setSocketKeepAlive = function() {
23724    };
23725    var unsafeHeaders = [
23726      "accept-charset",
23727      "accept-encoding",
23728      "access-control-request-headers",
23729      "access-control-request-method",
23730      "connection",
23731      "content-length",
23732      "cookie",
23733      "cookie2",
23734      "date",
23735      "dnt",
23736      "expect",
23737      "host",
23738      "keep-alive",
23739      "origin",
23740      "referer",
23741      "te",
23742      "trailer",
23743      "transfer-encoding",
23744      "upgrade",
23745      "via"
23746    ];
23747    return request.exports;
23748  }
23749  var immutable;
23750  var hasRequiredImmutable;
23751  function requireImmutable() {
23752    if (hasRequiredImmutable) return immutable;
23753    hasRequiredImmutable = 1;
23754    immutable = extend2;
23755    var hasOwnProperty2 = Object.prototype.hasOwnProperty;
23756    function extend2() {
23757      var target = {};
23758      for (var i2 = 0; i2 < arguments.length; i2++) {
23759        var source = arguments[i2];
23760        for (var key2 in source) {
23761          if (hasOwnProperty2.call(source, key2)) {
23762            target[key2] = source[key2];
23763          }
23764        }
23765      }
23766      return target;
23767    }
23768    return immutable;
23769  }
23770  var builtinStatusCodes;
23771  var hasRequiredBuiltinStatusCodes;
23772  function requireBuiltinStatusCodes() {
23773    if (hasRequiredBuiltinStatusCodes) return builtinStatusCodes;
23774    hasRequiredBuiltinStatusCodes = 1;
23775    builtinStatusCodes = requireStreamHttp().STATUS_CODES;
23776    return builtinStatusCodes;
23777  }
23778  var url$1 = { exports: {} };
23779  var punycode$1 = { exports: {} };
23780  /*! https://mths.be/punycode v1.4.1 by @mathias */
23781  var punycode = punycode$1.exports;
23782  var hasRequiredPunycode;
23783  function requirePunycode() {
23784    if (hasRequiredPunycode) return punycode$1.exports;
23785    hasRequiredPunycode = 1;
23786    (function(module, exports$12) {
23787      (function(root) {
23788        var freeExports = exports$12 && !exports$12.nodeType && exports$12;
23789        var freeModule = module && !module.nodeType && module;
23790        var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal;
23791        if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
23792          root = freeGlobal;
23793        }
23794        var punycode2, maxInt = 2147483647, base2 = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors2 = {
23795          "overflow": "Overflow: input needs wider integers to process",
23796          "not-basic": "Illegal input >= 0x80 (not a basic code point)",
23797          "invalid-input": "Invalid input"
23798        }, baseMinusTMin = base2 - tMin, floor2 = Math.floor, stringFromCharCode = String.fromCharCode, key2;
23799        function error(type2) {
23800          throw new RangeError(errors2[type2]);
23801        }
23802        function map(array, fn) {
23803          var length = array.length;
23804          var result = [];
23805          while (length--) {
23806            result[length] = fn(array[length]);
23807          }
23808          return result;
23809        }
23810        function mapDomain(string, fn) {
23811          var parts = string.split("@");
23812          var result = "";
23813          if (parts.length > 1) {
23814            result = parts[0] + "@";

vendor: 5,552 bytes, lines 23815-23962

23815            string = parts[1];
23816          }
23817          string = string.replace(regexSeparators, ".");
23818          var labels = string.split(".");
23819          var encoded = map(labels, fn).join(".");
23820          return result + encoded;
23821        }
23822        function ucs2decode(string) {
23823          var output = [], counter = 0, length = string.length, value, extra;
23824          while (counter < length) {
23825            value = string.charCodeAt(counter++);
23826            if (value >= 55296 && value <= 56319 && counter < length) {
23827              extra = string.charCodeAt(counter++);
23828              if ((extra & 64512) == 56320) {
23829                output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
23830              } else {
23831                output.push(value);
23832                counter--;
23833              }
23834            } else {
23835              output.push(value);
23836            }
23837          }
23838          return output;
23839        }
23840        function ucs2encode(array) {
23841          return map(array, function(value) {
23842            var output = "";
23843            if (value > 65535) {
23844              value -= 65536;
23845              output += stringFromCharCode(value >>> 10 & 1023 | 55296);
23846              value = 56320 | value & 1023;
23847            }
23848            output += stringFromCharCode(value);
23849            return output;
23850          }).join("");
23851        }
23852        function basicToDigit(codePoint) {
23853          if (codePoint - 48 < 10) {
23854            return codePoint - 22;
23855          }
23856          if (codePoint - 65 < 26) {
23857            return codePoint - 65;
23858          }
23859          if (codePoint - 97 < 26) {
23860            return codePoint - 97;
23861          }
23862          return base2;
23863        }
23864        function digitToBasic(digit, flag) {
23865          return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
23866        }
23867        function adapt(delta, numPoints, firstTime) {
23868          var k = 0;
23869          delta = firstTime ? floor2(delta / damp) : delta >> 1;
23870          delta += floor2(delta / numPoints);
23871          for (; delta > baseMinusTMin * tMax >> 1; k += base2) {
23872            delta = floor2(delta / baseMinusTMin);
23873          }
23874          return floor2(k + (baseMinusTMin + 1) * delta / (delta + skew));
23875        }
23876        function decode(input) {
23877          var output = [], inputLength = input.length, out, i2 = 0, n = initialN, bias = initialBias, basic, j, index, oldi, w, k, digit, t, baseMinusT;
23878          basic = input.lastIndexOf(delimiter);
23879          if (basic < 0) {
23880            basic = 0;
23881          }
23882          for (j = 0; j < basic; ++j) {
23883            if (input.charCodeAt(j) >= 128) {
23884              error("not-basic");
23885            }
23886            output.push(input.charCodeAt(j));
23887          }
23888          for (index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
23889            for (oldi = i2, w = 1, k = base2; ; k += base2) {
23890              if (index >= inputLength) {
23891                error("invalid-input");
23892              }
23893              digit = basicToDigit(input.charCodeAt(index++));
23894              if (digit >= base2 || digit > floor2((maxInt - i2) / w)) {
23895                error("overflow");
23896              }
23897              i2 += digit * w;
23898              t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
23899              if (digit < t) {
23900                break;
23901              }
23902              baseMinusT = base2 - t;
23903              if (w > floor2(maxInt / baseMinusT)) {
23904                error("overflow");
23905              }
23906              w *= baseMinusT;
23907            }
23908            out = output.length + 1;
23909            bias = adapt(i2 - oldi, out, oldi == 0);
23910            if (floor2(i2 / out) > maxInt - n) {
23911              error("overflow");
23912            }
23913            n += floor2(i2 / out);
23914            i2 %= out;
23915            output.splice(i2++, 0, n);
23916          }
23917          return ucs2encode(output);
23918        }
23919        function encode2(input) {
23920          var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
23921          input = ucs2decode(input);
23922          inputLength = input.length;
23923          n = initialN;
23924          delta = 0;
23925          bias = initialBias;
23926          for (j = 0; j < inputLength; ++j) {
23927            currentValue = input[j];
23928            if (currentValue < 128) {
23929              output.push(stringFromCharCode(currentValue));
23930            }
23931          }
23932          handledCPCount = basicLength = output.length;
23933          if (basicLength) {
23934            output.push(delimiter);
23935          }
23936          while (handledCPCount < inputLength) {
23937            for (m = maxInt, j = 0; j < inputLength; ++j) {
23938              currentValue = input[j];
23939              if (currentValue >= n && currentValue < m) {
23940                m = currentValue;
23941              }
23942            }
23943            handledCPCountPlusOne = handledCPCount + 1;
23944            if (m - n > floor2((maxInt - delta) / handledCPCountPlusOne)) {
23945              error("overflow");
23946            }
23947            delta += (m - n) * handledCPCountPlusOne;
23948            n = m;
23949            for (j = 0; j < inputLength; ++j) {
23950              currentValue = input[j];
23951              if (currentValue < n && ++delta > maxInt) {
23952                error("overflow");
23953              }
23954              if (currentValue == n) {
23955                for (q = delta, k = base2; ; k += base2) {
23956                  t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
23957                  if (q < t) {
23958                    break;
23959                  }
23960                  qMinusT = q - t;
23961                  baseMinusT = base2 - t;
23962                  output.push(

vendor: 1,064 bytes, lines 23963-23991

23963                    stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
23964                  );
23965                  q = floor2(qMinusT / baseMinusT);
23966                }
23967                output.push(stringFromCharCode(digitToBasic(q, 0)));
23968                bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
23969                delta = 0;
23970                ++handledCPCount;
23971              }
23972            }
23973            ++delta;
23974            ++n;
23975          }
23976          return output.join("");
23977        }
23978        function toUnicode(input) {
23979          return mapDomain(input, function(string) {
23980            return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
23981          });
23982        }
23983        function toASCII(input) {
23984          return mapDomain(input, function(string) {
23985            return regexNonASCII.test(string) ? "xn--" + encode2(string) : string;
23986          });
23987        }
23988        punycode2 = {
23989          /**
23990           * A string representing the current Punycode.js version number.
23991           * @memberOf punycode

23992           * @type String
23993           */
23994          "version": "1.4.1",
23995          /**
23996           * An object of methods to convert from JavaScript's internal character
23997           * representation (UCS-2) to Unicode code points, and back.
23998           * @see <https://mathiasbynens.be/notes/javascript-encoding>
23999           * @memberOf punycode
24000           * @type Object
24001           */
24002          "ucs2": {
24003            "decode": ucs2decode,
24004            "encode": ucs2encode
24005          },
24006          "decode": decode,
24007          "encode": encode2,
24008          "toASCII": toASCII,
24009          "toUnicode": toUnicode
24010        };
24011        if (freeExports && freeModule) {
24012          if (module.exports == freeExports) {
24013            freeModule.exports = punycode2;
24014          } else {
24015            for (key2 in punycode2) {
24016              punycode2.hasOwnProperty(key2) && (freeExports[key2] = punycode2[key2]);
24017            }
24018          }
24019        } else {
24020          root.punycode = punycode2;
24021        }
24022      })(punycode);
24023    })(punycode$1, punycode$1.exports);
24024    return punycode$1.exports;
24025  }
24026  var util_inspect;
24027  var hasRequiredUtil_inspect;
24028  function requireUtil_inspect() {
24029    if (hasRequiredUtil_inspect) return util_inspect;
24030    hasRequiredUtil_inspect = 1;
24031    util_inspect = requireUtil$1().inspect;
24032    return util_inspect;
24033  }
24034  var objectInspect;
24035  var hasRequiredObjectInspect;
24036  function requireObjectInspect() {
24037    if (hasRequiredObjectInspect) return objectInspect;
24038    hasRequiredObjectInspect = 1;
24039    var hasMap = typeof Map === "function" && Map.prototype;
24040    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
24041    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
24042    var mapForEach = hasMap && Map.prototype.forEach;
24043    var hasSet = typeof Set === "function" && Set.prototype;
24044    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
24045    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
24046    var setForEach = hasSet && Set.prototype.forEach;
24047    var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
24048    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
24049    var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
24050    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
24051    var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
24052    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
24053    var booleanValueOf = Boolean.prototype.valueOf;
24054    var objectToString = Object.prototype.toString;
24055    var functionToString = Function.prototype.toString;
24056    var $match = String.prototype.match;
24057    var $slice = String.prototype.slice;
24058    var $replace = String.prototype.replace;
24059    var $toUpperCase = String.prototype.toUpperCase;
24060    var $toLowerCase = String.prototype.toLowerCase;
24061    var $test = RegExp.prototype.test;
24062    var $concat = Array.prototype.concat;
24063    var $join = Array.prototype.join;
24064    var $arrSlice = Array.prototype.slice;
24065    var $floor = Math.floor;
24066    var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
24067    var gOPS = Object.getOwnPropertySymbols;
24068    var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
24069    var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
24070    var toStringTag2 = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
24071    var isEnumerable = Object.prototype.propertyIsEnumerable;
24072    var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O) {
24073      return O.__proto__;
24074    } : null);
24075    function addNumericSeparator(num, str) {
24076      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str)) {
24077        return str;
24078      }
24079      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
24080      if (typeof num === "number") {
24081        var int = num < 0 ? -$floor(-num) : $floor(num);
24082        if (int !== num) {
24083          var intStr = String(int);
24084          var dec = $slice.call(str, intStr.length + 1);
24085          return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
24086        }
24087      }
24088      return $replace.call(str, sepRegex, "$&_");
24089    }
24090    var utilInspect = /* @__PURE__ */ requireUtil_inspect();

vendor: 5,246 bytes, lines 24091-24217

24091    var inspectCustom = utilInspect.custom;
24092    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
24093    var quotes = {
24094      __proto__: null,
24095      "double": '"',
24096      single: "'"
24097    };
24098    var quoteREs = {
24099      __proto__: null,
24100      "double": /(["\\])/g,
24101      single: /(['\\])/g
24102    };
24103    objectInspect = function inspect_(obj, options, depth, seen) {
24104      var opts = options || {};
24105      if (has(opts, "quoteStyle") && !has(quotes, opts.quoteStyle)) {
24106        throw new TypeError('option "quoteStyle" must be "single" or "double"');
24107      }
24108      if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
24109        throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
24110      }
24111      var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
24112      if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
24113        throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
24114      }
24115      if (has(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
24116        throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
24117      }
24118      if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
24119        throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
24120      }
24121      var numericSeparator = opts.numericSeparator;
24122      if (typeof obj === "undefined") {
24123        return "undefined";
24124      }
24125      if (obj === null) {
24126        return "null";
24127      }
24128      if (typeof obj === "boolean") {
24129        return obj ? "true" : "false";
24130      }
24131      if (typeof obj === "string") {
24132        return inspectString(obj, opts);
24133      }
24134      if (typeof obj === "number") {
24135        if (obj === 0) {
24136          return Infinity / obj > 0 ? "0" : "-0";
24137        }
24138        var str = String(obj);
24139        return numericSeparator ? addNumericSeparator(obj, str) : str;
24140      }
24141      if (typeof obj === "bigint") {
24142        var bigIntStr = String(obj) + "n";
24143        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
24144      }
24145      var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
24146      if (typeof depth === "undefined") {
24147        depth = 0;
24148      }
24149      if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
24150        return isArray2(obj) ? "[Array]" : "[Object]";
24151      }
24152      var indent = getIndent(opts, depth);
24153      if (typeof seen === "undefined") {
24154        seen = [];
24155      } else if (indexOf2(seen, obj) >= 0) {
24156        return "[Circular]";
24157      }
24158      function inspect(value, from, noIndent) {
24159        if (from) {
24160          seen = $arrSlice.call(seen);
24161          seen.push(from);
24162        }
24163        if (noIndent) {
24164          var newOpts = {
24165            depth: opts.depth
24166          };
24167          if (has(opts, "quoteStyle")) {
24168            newOpts.quoteStyle = opts.quoteStyle;
24169          }
24170          return inspect_(value, newOpts, depth + 1, seen);
24171        }
24172        return inspect_(value, opts, depth + 1, seen);
24173      }
24174      if (typeof obj === "function" && !isRegExp2(obj)) {
24175        var name = nameOf(obj);
24176        var keys = arrObjKeys(obj, inspect);
24177        return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
24178      }
24179      if (isSymbol(obj)) {
24180        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
24181        return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
24182      }
24183      if (isElement(obj)) {
24184        var s = "<" + $toLowerCase.call(String(obj.nodeName));
24185        var attrs = obj.attributes || [];
24186        for (var i2 = 0; i2 < attrs.length; i2++) {
24187          s += " " + attrs[i2].name + "=" + wrapQuotes(quote(attrs[i2].value), "double", opts);
24188        }
24189        s += ">";
24190        if (obj.childNodes && obj.childNodes.length) {
24191          s += "...";
24192        }
24193        s += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
24194        return s;
24195      }
24196      if (isArray2(obj)) {
24197        if (obj.length === 0) {
24198          return "[]";
24199        }
24200        var xs = arrObjKeys(obj, inspect);
24201        if (indent && !singleLineValues(xs)) {
24202          return "[" + indentedJoin(xs, indent) + "]";
24203        }
24204        return "[ " + $join.call(xs, ", ") + " ]";
24205      }
24206      if (isError(obj)) {
24207        var parts = arrObjKeys(obj, inspect);
24208        if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
24209          return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect(obj.cause), parts), ", ") + " }";
24210        }
24211        if (parts.length === 0) {
24212          return "[" + String(obj) + "]";
24213        }
24214        return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
24215      }
24216      if (typeof obj === "object" && customInspect) {
24217        if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {

vendor: 8,534 bytes, lines 24218-24497

24218          return utilInspect(obj, { depth: maxDepth - depth });
24219        } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
24220          return obj.inspect();
24221        }
24222      }
24223      if (isMap(obj)) {
24224        var mapParts = [];
24225        if (mapForEach) {
24226          mapForEach.call(obj, function(value, key2) {
24227            mapParts.push(inspect(key2, obj, true) + " => " + inspect(value, obj));
24228          });
24229        }
24230        return collectionOf("Map", mapSize.call(obj), mapParts, indent);
24231      }
24232      if (isSet(obj)) {
24233        var setParts = [];
24234        if (setForEach) {
24235          setForEach.call(obj, function(value) {
24236            setParts.push(inspect(value, obj));
24237          });
24238        }
24239        return collectionOf("Set", setSize.call(obj), setParts, indent);
24240      }
24241      if (isWeakMap(obj)) {
24242        return weakCollectionOf("WeakMap");
24243      }
24244      if (isWeakSet(obj)) {
24245        return weakCollectionOf("WeakSet");
24246      }
24247      if (isWeakRef(obj)) {
24248        return weakCollectionOf("WeakRef");
24249      }
24250      if (isNumber2(obj)) {
24251        return markBoxed(inspect(Number(obj)));
24252      }
24253      if (isBigInt(obj)) {
24254        return markBoxed(inspect(bigIntValueOf.call(obj)));
24255      }
24256      if (isBoolean2(obj)) {
24257        return markBoxed(booleanValueOf.call(obj));
24258      }
24259      if (isString2(obj)) {
24260        return markBoxed(inspect(String(obj)));
24261      }
24262      if (typeof window !== "undefined" && obj === window) {
24263        return "{ [object Window] }";
24264      }
24265      if (typeof globalThis !== "undefined" && obj === globalThis || typeof commonjsGlobal !== "undefined" && obj === commonjsGlobal) {
24266        return "{ [object globalThis] }";
24267      }
24268      if (!isDate2(obj) && !isRegExp2(obj)) {
24269        var ys = arrObjKeys(obj, inspect);
24270        var isPlainObject2 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
24271        var protoTag = obj instanceof Object ? "" : "null prototype";
24272        var stringTag = !isPlainObject2 && toStringTag2 && Object(obj) === obj && toStringTag2 in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
24273        var constructorTag = isPlainObject2 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
24274        var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
24275        if (ys.length === 0) {
24276          return tag + "{}";
24277        }
24278        if (indent) {
24279          return tag + "{" + indentedJoin(ys, indent) + "}";
24280        }
24281        return tag + "{ " + $join.call(ys, ", ") + " }";
24282      }
24283      return String(obj);
24284    };
24285    function wrapQuotes(s, defaultStyle, opts) {
24286      var style = opts.quoteStyle || defaultStyle;
24287      var quoteChar = quotes[style];
24288      return quoteChar + s + quoteChar;
24289    }
24290    function quote(s) {
24291      return $replace.call(String(s), /"/g, "&quot;");
24292    }
24293    function canTrustToString(obj) {
24294      return !toStringTag2 || !(typeof obj === "object" && (toStringTag2 in obj || typeof obj[toStringTag2] !== "undefined"));
24295    }
24296    function isArray2(obj) {
24297      return toStr(obj) === "[object Array]" && canTrustToString(obj);
24298    }
24299    function isDate2(obj) {
24300      return toStr(obj) === "[object Date]" && canTrustToString(obj);
24301    }
24302    function isRegExp2(obj) {
24303      return toStr(obj) === "[object RegExp]" && canTrustToString(obj);
24304    }
24305    function isError(obj) {
24306      return toStr(obj) === "[object Error]" && canTrustToString(obj);
24307    }
24308    function isString2(obj) {
24309      return toStr(obj) === "[object String]" && canTrustToString(obj);
24310    }
24311    function isNumber2(obj) {
24312      return toStr(obj) === "[object Number]" && canTrustToString(obj);
24313    }
24314    function isBoolean2(obj) {
24315      return toStr(obj) === "[object Boolean]" && canTrustToString(obj);
24316    }
24317    function isSymbol(obj) {
24318      if (hasShammedSymbols) {
24319        return obj && typeof obj === "object" && obj instanceof Symbol;
24320      }
24321      if (typeof obj === "symbol") {
24322        return true;
24323      }
24324      if (!obj || typeof obj !== "object" || !symToString) {
24325        return false;
24326      }
24327      try {
24328        symToString.call(obj);
24329        return true;
24330      } catch (e) {
24331      }
24332      return false;
24333    }
24334    function isBigInt(obj) {
24335      if (!obj || typeof obj !== "object" || !bigIntValueOf) {
24336        return false;
24337      }
24338      try {
24339        bigIntValueOf.call(obj);
24340        return true;
24341      } catch (e) {
24342      }
24343      return false;
24344    }
24345    var hasOwn = Object.prototype.hasOwnProperty || function(key2) {
24346      return key2 in this;
24347    };
24348    function has(obj, key2) {
24349      return hasOwn.call(obj, key2);
24350    }
24351    function toStr(obj) {
24352      return objectToString.call(obj);
24353    }
24354    function nameOf(f) {
24355      if (f.name) {
24356        return f.name;
24357      }
24358      var m = $match.call(functionToString.call(f), /^function\s*([\w$]+)/);
24359      if (m) {
24360        return m[1];
24361      }
24362      return null;
24363    }
24364    function indexOf2(xs, x) {
24365      if (xs.indexOf) {
24366        return xs.indexOf(x);
24367      }
24368      for (var i2 = 0, l = xs.length; i2 < l; i2++) {
24369        if (xs[i2] === x) {
24370          return i2;
24371        }
24372      }
24373      return -1;
24374    }
24375    function isMap(x) {
24376      if (!mapSize || !x || typeof x !== "object") {
24377        return false;
24378      }
24379      try {
24380        mapSize.call(x);
24381        try {
24382          setSize.call(x);
24383        } catch (s) {
24384          return true;
24385        }
24386        return x instanceof Map;
24387      } catch (e) {
24388      }
24389      return false;
24390    }
24391    function isWeakMap(x) {
24392      if (!weakMapHas || !x || typeof x !== "object") {
24393        return false;
24394      }
24395      try {
24396        weakMapHas.call(x, weakMapHas);
24397        try {
24398          weakSetHas.call(x, weakSetHas);
24399        } catch (s) {
24400          return true;
24401        }
24402        return x instanceof WeakMap;
24403      } catch (e) {
24404      }
24405      return false;
24406    }
24407    function isWeakRef(x) {
24408      if (!weakRefDeref || !x || typeof x !== "object") {
24409        return false;
24410      }
24411      try {
24412        weakRefDeref.call(x);
24413        return true;
24414      } catch (e) {
24415      }
24416      return false;
24417    }
24418    function isSet(x) {
24419      if (!setSize || !x || typeof x !== "object") {
24420        return false;
24421      }
24422      try {
24423        setSize.call(x);
24424        try {
24425          mapSize.call(x);
24426        } catch (m) {
24427          return true;
24428        }
24429        return x instanceof Set;
24430      } catch (e) {
24431      }
24432      return false;
24433    }
24434    function isWeakSet(x) {
24435      if (!weakSetHas || !x || typeof x !== "object") {
24436        return false;
24437      }
24438      try {
24439        weakSetHas.call(x, weakSetHas);
24440        try {
24441          weakMapHas.call(x, weakMapHas);
24442        } catch (s) {
24443          return true;
24444        }
24445        return x instanceof WeakSet;
24446      } catch (e) {
24447      }
24448      return false;
24449    }
24450    function isElement(x) {
24451      if (!x || typeof x !== "object") {
24452        return false;
24453      }
24454      if (typeof HTMLElement !== "undefined" && x instanceof HTMLElement) {
24455        return true;
24456      }
24457      return typeof x.nodeName === "string" && typeof x.getAttribute === "function";
24458    }
24459    function inspectString(str, opts) {
24460      if (str.length > opts.maxStringLength) {
24461        var remaining = str.length - opts.maxStringLength;
24462        var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
24463        return inspectString($slice.call(str, 0, opts.maxStringLength), opts) + trailer;
24464      }
24465      var quoteRE = quoteREs[opts.quoteStyle || "single"];
24466      quoteRE.lastIndex = 0;
24467      var s = $replace.call($replace.call(str, quoteRE, "\\$1"), /[\x00-\x1f]/g, lowbyte);
24468      return wrapQuotes(s, "single", opts);
24469    }
24470    function lowbyte(c) {
24471      var n = c.charCodeAt(0);
24472      var x = {
24473        8: "b",
24474        9: "t",
24475        10: "n",
24476        12: "f",
24477        13: "r"
24478      }[n];
24479      if (x) {
24480        return "\\" + x;
24481      }
24482      return "\\x" + (n < 16 ? "0" : "") + $toUpperCase.call(n.toString(16));
24483    }
24484    function markBoxed(str) {
24485      return "Object(" + str + ")";
24486    }
24487    function weakCollectionOf(type2) {
24488      return type2 + " { ? }";
24489    }
24490    function collectionOf(type2, size, entries, indent) {
24491      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
24492      return type2 + " (" + size + ") {" + joinedEntries + "}";
24493    }
24494    function singleLineValues(xs) {
24495      for (var i2 = 0; i2 < xs.length; i2++) {
24496        if (indexOf2(xs[i2], "\n") >= 0) {
24497          return false;

vendor: 13,592 bytes, lines 24498-24921

24498        }
24499      }
24500      return true;
24501    }
24502    function getIndent(opts, depth) {
24503      var baseIndent;
24504      if (opts.indent === "	") {
24505        baseIndent = "	";
24506      } else if (typeof opts.indent === "number" && opts.indent > 0) {
24507        baseIndent = $join.call(Array(opts.indent + 1), " ");
24508      } else {
24509        return null;
24510      }
24511      return {
24512        base: baseIndent,
24513        prev: $join.call(Array(depth + 1), baseIndent)
24514      };
24515    }
24516    function indentedJoin(xs, indent) {
24517      if (xs.length === 0) {
24518        return "";
24519      }
24520      var lineJoiner = "\n" + indent.prev + indent.base;
24521      return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
24522    }
24523    function arrObjKeys(obj, inspect) {
24524      var isArr = isArray2(obj);
24525      var xs = [];
24526      if (isArr) {
24527        xs.length = obj.length;
24528        for (var i2 = 0; i2 < obj.length; i2++) {
24529          xs[i2] = has(obj, i2) ? inspect(obj[i2], obj) : "";
24530        }
24531      }
24532      var syms = typeof gOPS === "function" ? gOPS(obj) : [];
24533      var symMap;
24534      if (hasShammedSymbols) {
24535        symMap = {};
24536        for (var k = 0; k < syms.length; k++) {
24537          symMap["$" + syms[k]] = syms[k];
24538        }
24539      }
24540      for (var key2 in obj) {
24541        if (!has(obj, key2)) {
24542          continue;
24543        }
24544        if (isArr && String(Number(key2)) === key2 && key2 < obj.length) {
24545          continue;
24546        }
24547        if (hasShammedSymbols && symMap["$" + key2] instanceof Symbol) {
24548          continue;
24549        } else if ($test.call(/[^\w$]/, key2)) {
24550          xs.push(inspect(key2, obj) + ": " + inspect(obj[key2], obj));
24551        } else {
24552          xs.push(key2 + ": " + inspect(obj[key2], obj));
24553        }
24554      }
24555      if (typeof gOPS === "function") {
24556        for (var j = 0; j < syms.length; j++) {
24557          if (isEnumerable.call(obj, syms[j])) {
24558            xs.push("[" + inspect(syms[j]) + "]: " + inspect(obj[syms[j]], obj));
24559          }
24560        }
24561      }
24562      return xs;
24563    }
24564    return objectInspect;
24565  }
24566  var sideChannelList;
24567  var hasRequiredSideChannelList;
24568  function requireSideChannelList() {
24569    if (hasRequiredSideChannelList) return sideChannelList;
24570    hasRequiredSideChannelList = 1;
24571    var inspect = /* @__PURE__ */ requireObjectInspect();
24572    var $TypeError = /* @__PURE__ */ requireType();
24573    var listGetNode = function(list, key2, isDelete) {
24574      var prev = list;
24575      var curr;
24576      for (; (curr = prev.next) != null; prev = curr) {
24577        if (curr.key === key2) {
24578          prev.next = curr.next;
24579          if (!isDelete) {
24580            curr.next = /** @type {NonNullable<typeof list.next>} */
24581            list.next;
24582            list.next = curr;
24583          }
24584          return curr;
24585        }
24586      }
24587    };
24588    var listGet = function(objects, key2) {
24589      if (!objects) {
24590        return void 0;
24591      }
24592      var node2 = listGetNode(objects, key2);
24593      return node2 && node2.value;
24594    };
24595    var listSet = function(objects, key2, value) {
24596      var node2 = listGetNode(objects, key2);
24597      if (node2) {
24598        node2.value = value;
24599      } else {
24600        objects.next = /** @type {import('./list.d.ts').ListNode<typeof value, typeof key>} */
24601        {
24602          // eslint-disable-line no-param-reassign, no-extra-parens
24603          key: key2,
24604          next: objects.next,
24605          value
24606        };
24607      }
24608    };
24609    var listHas = function(objects, key2) {
24610      if (!objects) {
24611        return false;
24612      }
24613      return !!listGetNode(objects, key2);
24614    };
24615    var listDelete = function(objects, key2) {
24616      if (objects) {
24617        return listGetNode(objects, key2, true);
24618      }
24619    };
24620    sideChannelList = function getSideChannelList() {
24621      var $o;
24622      var channel = {
24623        assert: function(key2) {
24624          if (!channel.has(key2)) {
24625            throw new $TypeError("Side channel does not contain " + inspect(key2));
24626          }
24627        },
24628        "delete": function(key2) {
24629          var deletedNode = listDelete($o, key2);
24630          if (deletedNode && $o && !$o.next) {
24631            $o = void 0;
24632          }
24633          return !!deletedNode;
24634        },
24635        get: function(key2) {
24636          return listGet($o, key2);
24637        },
24638        has: function(key2) {
24639          return listHas($o, key2);
24640        },
24641        set: function(key2, value) {
24642          if (!$o) {
24643            $o = {
24644              next: void 0
24645            };
24646          }
24647          listSet(
24648            /** @type {NonNullable<typeof $o>} */
24649            $o,
24650            key2,
24651            value
24652          );
24653        }
24654      };
24655      return channel;
24656    };
24657    return sideChannelList;
24658  }
24659  var sideChannelMap;
24660  var hasRequiredSideChannelMap;
24661  function requireSideChannelMap() {
24662    if (hasRequiredSideChannelMap) return sideChannelMap;
24663    hasRequiredSideChannelMap = 1;
24664    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
24665    var callBound2 = /* @__PURE__ */ requireCallBound$1();
24666    var inspect = /* @__PURE__ */ requireObjectInspect();
24667    var $TypeError = /* @__PURE__ */ requireType();
24668    var $Map = GetIntrinsic("%Map%", true);
24669    var $mapGet = callBound2("Map.prototype.get", true);
24670    var $mapSet = callBound2("Map.prototype.set", true);
24671    var $mapHas = callBound2("Map.prototype.has", true);
24672    var $mapDelete = callBound2("Map.prototype.delete", true);
24673    var $mapSize = callBound2("Map.prototype.size", true);
24674    sideChannelMap = !!$Map && /** @type {Exclude<import('.'), false>} */
24675    function getSideChannelMap() {
24676      var $m;
24677      var channel = {
24678        assert: function(key2) {
24679          if (!channel.has(key2)) {
24680            throw new $TypeError("Side channel does not contain " + inspect(key2));
24681          }
24682        },
24683        "delete": function(key2) {
24684          if ($m) {
24685            var result = $mapDelete($m, key2);
24686            if ($mapSize($m) === 0) {
24687              $m = void 0;
24688            }
24689            return result;
24690          }
24691          return false;
24692        },
24693        get: function(key2) {
24694          if ($m) {
24695            return $mapGet($m, key2);
24696          }
24697        },
24698        has: function(key2) {
24699          if ($m) {
24700            return $mapHas($m, key2);
24701          }
24702          return false;
24703        },
24704        set: function(key2, value) {
24705          if (!$m) {
24706            $m = new $Map();
24707          }
24708          $mapSet($m, key2, value);
24709        }
24710      };
24711      return channel;
24712    };
24713    return sideChannelMap;
24714  }
24715  var sideChannelWeakmap;
24716  var hasRequiredSideChannelWeakmap;
24717  function requireSideChannelWeakmap() {
24718    if (hasRequiredSideChannelWeakmap) return sideChannelWeakmap;
24719    hasRequiredSideChannelWeakmap = 1;
24720    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
24721    var callBound2 = /* @__PURE__ */ requireCallBound$1();
24722    var inspect = /* @__PURE__ */ requireObjectInspect();
24723    var getSideChannelMap = requireSideChannelMap();
24724    var $TypeError = /* @__PURE__ */ requireType();
24725    var $WeakMap = GetIntrinsic("%WeakMap%", true);
24726    var $weakMapGet = callBound2("WeakMap.prototype.get", true);
24727    var $weakMapSet = callBound2("WeakMap.prototype.set", true);
24728    var $weakMapHas = callBound2("WeakMap.prototype.has", true);
24729    var $weakMapDelete = callBound2("WeakMap.prototype.delete", true);
24730    sideChannelWeakmap = $WeakMap ? (
24731      /** @type {Exclude<import('.'), false>} */
24732      function getSideChannelWeakMap() {
24733        var $wm;
24734        var $m;
24735        var channel = {
24736          assert: function(key2) {
24737            if (!channel.has(key2)) {
24738              throw new $TypeError("Side channel does not contain " + inspect(key2));
24739            }
24740          },
24741          "delete": function(key2) {
24742            if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) {
24743              if ($wm) {
24744                return $weakMapDelete($wm, key2);
24745              }
24746            } else if (getSideChannelMap) {
24747              if ($m) {
24748                return $m["delete"](key2);
24749              }
24750            }
24751            return false;
24752          },
24753          get: function(key2) {
24754            if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) {
24755              if ($wm) {
24756                return $weakMapGet($wm, key2);
24757              }
24758            }
24759            return $m && $m.get(key2);
24760          },
24761          has: function(key2) {
24762            if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) {
24763              if ($wm) {
24764                return $weakMapHas($wm, key2);
24765              }
24766            }
24767            return !!$m && $m.has(key2);
24768          },
24769          set: function(key2, value) {
24770            if ($WeakMap && key2 && (typeof key2 === "object" || typeof key2 === "function")) {
24771              if (!$wm) {
24772                $wm = new $WeakMap();
24773              }
24774              $weakMapSet($wm, key2, value);
24775            } else if (getSideChannelMap) {
24776              if (!$m) {
24777                $m = getSideChannelMap();
24778              }
24779              $m.set(key2, value);
24780            }
24781          }
24782        };
24783        return channel;
24784      }
24785    ) : getSideChannelMap;
24786    return sideChannelWeakmap;
24787  }
24788  var sideChannel;
24789  var hasRequiredSideChannel;
24790  function requireSideChannel() {
24791    if (hasRequiredSideChannel) return sideChannel;
24792    hasRequiredSideChannel = 1;
24793    var $TypeError = /* @__PURE__ */ requireType();
24794    var inspect = /* @__PURE__ */ requireObjectInspect();
24795    var getSideChannelList = requireSideChannelList();
24796    var getSideChannelMap = requireSideChannelMap();
24797    var getSideChannelWeakMap = requireSideChannelWeakmap();
24798    var makeChannel = getSideChannelWeakMap || getSideChannelMap || getSideChannelList;
24799    sideChannel = function getSideChannel() {
24800      var $channelData;
24801      var channel = {
24802        assert: function(key2) {
24803          if (!channel.has(key2)) {
24804            throw new $TypeError("Side channel does not contain " + inspect(key2));
24805          }
24806        },
24807        "delete": function(key2) {
24808          return !!$channelData && $channelData["delete"](key2);
24809        },
24810        get: function(key2) {
24811          return $channelData && $channelData.get(key2);
24812        },
24813        has: function(key2) {
24814          return !!$channelData && $channelData.has(key2);
24815        },
24816        set: function(key2, value) {
24817          if (!$channelData) {
24818            $channelData = makeChannel();
24819          }
24820          $channelData.set(key2, value);
24821        }
24822      };
24823      return channel;
24824    };
24825    return sideChannel;
24826  }
24827  var formats;
24828  var hasRequiredFormats;
24829  function requireFormats() {
24830    if (hasRequiredFormats) return formats;
24831    hasRequiredFormats = 1;
24832    var replace = String.prototype.replace;
24833    var percentTwenties = /%20/g;
24834    var Format = {
24835      RFC1738: "RFC1738",
24836      RFC3986: "RFC3986"
24837    };
24838    formats = {
24839      "default": Format.RFC3986,
24840      formatters: {
24841        RFC1738: function(value) {
24842          return replace.call(value, percentTwenties, "+");
24843        },
24844        RFC3986: function(value) {
24845          return String(value);
24846        }
24847      },
24848      RFC1738: Format.RFC1738,
24849      RFC3986: Format.RFC3986
24850    };
24851    return formats;
24852  }
24853  var utils$4;
24854  var hasRequiredUtils$3;
24855  function requireUtils$3() {
24856    if (hasRequiredUtils$3) return utils$4;
24857    hasRequiredUtils$3 = 1;
24858    var formats2 = /* @__PURE__ */ requireFormats();
24859    var getSideChannel = requireSideChannel();
24860    var has = Object.prototype.hasOwnProperty;
24861    var isArray2 = Array.isArray;
24862    var overflowChannel = getSideChannel();
24863    var markOverflow = function markOverflow2(obj, maxIndex) {
24864      overflowChannel.set(obj, maxIndex);
24865      return obj;
24866    };
24867    var isOverflow = function isOverflow2(obj) {
24868      return overflowChannel.has(obj);
24869    };
24870    var getMaxIndex = function getMaxIndex2(obj) {
24871      return overflowChannel.get(obj);
24872    };
24873    var setMaxIndex = function setMaxIndex2(obj, maxIndex) {
24874      overflowChannel.set(obj, maxIndex);
24875    };
24876    var hexTable = (function() {
24877      var array = [];
24878      for (var i2 = 0; i2 < 256; ++i2) {
24879        array[array.length] = "%" + ((i2 < 16 ? "0" : "") + i2.toString(16)).toUpperCase();
24880      }
24881      return array;
24882    })();
24883    var compactQueue = function compactQueue2(queue2) {
24884      while (queue2.length > 1) {
24885        var item = queue2.pop();
24886        var obj = item.obj[item.prop];
24887        if (isArray2(obj)) {
24888          var compacted = [];
24889          for (var j = 0; j < obj.length; ++j) {
24890            if (typeof obj[j] !== "undefined") {
24891              compacted[compacted.length] = obj[j];
24892            }
24893          }
24894          item.obj[item.prop] = compacted;
24895        }
24896      }
24897    };
24898    var arrayToObject2 = function arrayToObject3(source, options) {
24899      var obj = options && options.plainObjects ? { __proto__: null } : {};
24900      for (var i2 = 0; i2 < source.length; ++i2) {
24901        if (typeof source[i2] !== "undefined") {
24902          obj[i2] = source[i2];
24903        }
24904      }
24905      return obj;
24906    };
24907    var merge2 = function merge3(target, source, options) {
24908      if (!source) {
24909        return target;
24910      }
24911      if (typeof source !== "object" && typeof source !== "function") {
24912        if (isArray2(target)) {
24913          var nextIndex = target.length;
24914          if (options && typeof options.arrayLimit === "number" && nextIndex > options.arrayLimit) {
24915            return markOverflow(arrayToObject2(target.concat(source), options), nextIndex);
24916          }
24917          target[nextIndex] = source;
24918        } else if (target && typeof target === "object") {
24919          if (isOverflow(target)) {
24920            var newIndex = getMaxIndex(target) + 1;
24921            target[newIndex] = source;

vendor: 12,366 bytes, lines 24922-25256

24922            setMaxIndex(target, newIndex);
24923          } else if (options && options.strictMerge) {
24924            return [target, source];
24925          } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
24926            target[source] = true;
24927          }
24928        } else {
24929          return [target, source];
24930        }
24931        return target;
24932      }
24933      if (!target || typeof target !== "object") {
24934        if (isOverflow(source)) {
24935          var sourceKeys = Object.keys(source);
24936          var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };
24937          for (var m = 0; m < sourceKeys.length; m++) {
24938            var oldKey = parseInt(sourceKeys[m], 10);
24939            result[oldKey + 1] = source[sourceKeys[m]];
24940          }
24941          return markOverflow(result, getMaxIndex(source) + 1);
24942        }
24943        var combined = [target].concat(source);
24944        if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
24945          return markOverflow(arrayToObject2(combined, options), combined.length - 1);
24946        }
24947        return combined;
24948      }
24949      var mergeTarget = target;
24950      if (isArray2(target) && !isArray2(source)) {
24951        mergeTarget = arrayToObject2(target, options);
24952      }
24953      if (isArray2(target) && isArray2(source)) {
24954        source.forEach(function(item, i2) {
24955          if (has.call(target, i2)) {
24956            var targetItem = target[i2];
24957            if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
24958              target[i2] = merge3(targetItem, item, options);
24959            } else {
24960              target[target.length] = item;
24961            }
24962          } else {
24963            target[i2] = item;
24964          }
24965        });
24966        return target;
24967      }
24968      return Object.keys(source).reduce(function(acc, key2) {
24969        var value = source[key2];
24970        if (has.call(acc, key2)) {
24971          acc[key2] = merge3(acc[key2], value, options);
24972        } else {
24973          acc[key2] = value;
24974        }
24975        if (isOverflow(source) && !isOverflow(acc)) {
24976          markOverflow(acc, getMaxIndex(source));
24977        }
24978        if (isOverflow(acc)) {
24979          var keyNum = parseInt(key2, 10);
24980          if (String(keyNum) === key2 && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
24981            setMaxIndex(acc, keyNum);
24982          }
24983        }
24984        return acc;
24985      }, mergeTarget);
24986    };
24987    var assign = function assignSingleSource(target, source) {
24988      return Object.keys(source).reduce(function(acc, key2) {
24989        acc[key2] = source[key2];
24990        return acc;
24991      }, target);
24992    };
24993    var decode = function(str, defaultDecoder, charset) {
24994      var strWithoutPlus = str.replace(/\+/g, " ");
24995      if (charset === "iso-8859-1") {
24996        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
24997      }
24998      try {
24999        return decodeURIComponent(strWithoutPlus);
25000      } catch (e) {
25001        return strWithoutPlus;
25002      }
25003    };
25004    var limit = 1024;
25005    var encode2 = function encode3(str, defaultEncoder, charset, kind, format) {
25006      if (str.length === 0) {
25007        return str;
25008      }
25009      var string = str;
25010      if (typeof str === "symbol") {
25011        string = Symbol.prototype.toString.call(str);
25012      } else if (typeof str !== "string") {
25013        string = String(str);
25014      }
25015      if (charset === "iso-8859-1") {
25016        return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
25017          return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
25018        });
25019      }
25020      var out = "";
25021      for (var j = 0; j < string.length; j += limit) {
25022        var segment = string.length >= limit ? string.slice(j, j + limit) : string;
25023        var arr = [];
25024        for (var i2 = 0; i2 < segment.length; ++i2) {
25025          var c = segment.charCodeAt(i2);
25026          if (c === 45 || c === 46 || c === 95 || c === 126 || c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || format === formats2.RFC1738 && (c === 40 || c === 41)) {
25027            arr[arr.length] = segment.charAt(i2);
25028            continue;
25029          }
25030          if (c < 128) {
25031            arr[arr.length] = hexTable[c];
25032            continue;
25033          }
25034          if (c < 2048) {
25035            arr[arr.length] = hexTable[192 | c >> 6] + hexTable[128 | c & 63];
25036            continue;
25037          }
25038          if (c < 55296 || c >= 57344) {
25039            arr[arr.length] = hexTable[224 | c >> 12] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
25040            continue;
25041          }
25042          i2 += 1;
25043          c = 65536 + ((c & 1023) << 10 | segment.charCodeAt(i2) & 1023);
25044          arr[arr.length] = hexTable[240 | c >> 18] + hexTable[128 | c >> 12 & 63] + hexTable[128 | c >> 6 & 63] + hexTable[128 | c & 63];
25045        }
25046        out += arr.join("");
25047      }
25048      return out;
25049    };
25050    var compact = function compact2(value) {
25051      var queue2 = [{ obj: { o: value }, prop: "o" }];
25052      var refs = [];
25053      for (var i2 = 0; i2 < queue2.length; ++i2) {
25054        var item = queue2[i2];
25055        var obj = item.obj[item.prop];
25056        var keys = Object.keys(obj);
25057        for (var j = 0; j < keys.length; ++j) {
25058          var key2 = keys[j];
25059          var val = obj[key2];
25060          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
25061            queue2[queue2.length] = { obj, prop: key2 };
25062            refs[refs.length] = val;
25063          }
25064        }
25065      }
25066      compactQueue(queue2);
25067      return value;
25068    };
25069    var isRegExp2 = function isRegExp3(obj) {
25070      return Object.prototype.toString.call(obj) === "[object RegExp]";
25071    };
25072    var isBuffer2 = function isBuffer3(obj) {
25073      if (!obj || typeof obj !== "object") {
25074        return false;
25075      }
25076      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
25077    };
25078    var combine = function combine2(a, b, arrayLimit, plainObjects) {
25079      if (isOverflow(a)) {
25080        var newIndex = getMaxIndex(a) + 1;
25081        a[newIndex] = b;
25082        setMaxIndex(a, newIndex);
25083        return a;
25084      }
25085      var result = [].concat(a, b);
25086      if (result.length > arrayLimit) {
25087        return markOverflow(arrayToObject2(result, { plainObjects }), result.length - 1);
25088      }
25089      return result;
25090    };
25091    var maybeMap = function maybeMap2(val, fn) {
25092      if (isArray2(val)) {
25093        var mapped = [];
25094        for (var i2 = 0; i2 < val.length; i2 += 1) {
25095          mapped[mapped.length] = fn(val[i2]);
25096        }
25097        return mapped;
25098      }
25099      return fn(val);
25100    };
25101    utils$4 = {
25102      arrayToObject: arrayToObject2,
25103      assign,
25104      combine,
25105      compact,
25106      decode,
25107      encode: encode2,
25108      isBuffer: isBuffer2,
25109      isOverflow,
25110      isRegExp: isRegExp2,
25111      markOverflow,
25112      maybeMap,
25113      merge: merge2
25114    };
25115    return utils$4;
25116  }
25117  var stringify_1;
25118  var hasRequiredStringify;
25119  function requireStringify() {
25120    if (hasRequiredStringify) return stringify_1;
25121    hasRequiredStringify = 1;
25122    var getSideChannel = requireSideChannel();
25123    var utils2 = /* @__PURE__ */ requireUtils$3();
25124    var formats2 = /* @__PURE__ */ requireFormats();
25125    var has = Object.prototype.hasOwnProperty;
25126    var arrayPrefixGenerators = {
25127      brackets: function brackets(prefix) {
25128        return prefix + "[]";
25129      },
25130      comma: "comma",
25131      indices: function indices(prefix, key2) {
25132        return prefix + "[" + key2 + "]";
25133      },
25134      repeat: function repeat(prefix) {
25135        return prefix;
25136      }
25137    };
25138    var isArray2 = Array.isArray;
25139    var push = Array.prototype.push;
25140    var pushToArray = function(arr, valueOrArray) {
25141      push.apply(arr, isArray2(valueOrArray) ? valueOrArray : [valueOrArray]);
25142    };
25143    var toISO = Date.prototype.toISOString;
25144    var defaultFormat = formats2["default"];
25145    var defaults2 = {
25146      addQueryPrefix: false,
25147      allowDots: false,
25148      allowEmptyArrays: false,
25149      arrayFormat: "indices",
25150      charset: "utf-8",
25151      charsetSentinel: false,
25152      commaRoundTrip: false,
25153      delimiter: "&",
25154      encode: true,
25155      encodeDotInKeys: false,
25156      encoder: utils2.encode,
25157      encodeValuesOnly: false,
25158      filter: void 0,
25159      format: defaultFormat,
25160      formatter: formats2.formatters[defaultFormat],
25161      // deprecated
25162      indices: false,
25163      serializeDate: function serializeDate(date) {
25164        return toISO.call(date);
25165      },
25166      skipNulls: false,
25167      strictNullHandling: false
25168    };
25169    var isNonNullishPrimitive = function isNonNullishPrimitive2(v) {
25170      return typeof v === "string" || typeof v === "number" || typeof v === "boolean" || typeof v === "symbol" || typeof v === "bigint";
25171    };
25172    var sentinel = {};
25173    var stringify = function stringify2(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel2) {
25174      var obj = object;
25175      var tmpSc = sideChannel2;
25176      var step = 0;
25177      var findFlag = false;
25178      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
25179        var pos = tmpSc.get(object);
25180        step += 1;
25181        if (typeof pos !== "undefined") {
25182          if (pos === step) {
25183            throw new RangeError("Cyclic object value");
25184          } else {
25185            findFlag = true;
25186          }
25187        }
25188        if (typeof tmpSc.get(sentinel) === "undefined") {
25189          step = 0;
25190        }
25191      }
25192      if (typeof filter === "function") {
25193        obj = filter(prefix, obj);
25194      } else if (obj instanceof Date) {
25195        obj = serializeDate(obj);
25196      } else if (generateArrayPrefix === "comma" && isArray2(obj)) {
25197        obj = utils2.maybeMap(obj, function(value2) {
25198          if (value2 instanceof Date) {
25199            return serializeDate(value2);
25200          }
25201          return value2;
25202        });
25203      }
25204      if (obj === null) {
25205        if (strictNullHandling) {
25206          return formatter(encoder && !encodeValuesOnly ? encoder(prefix, defaults2.encoder, charset, "key", format) : prefix);
25207        }
25208        obj = "";
25209      }
25210      if (isNonNullishPrimitive(obj) || utils2.isBuffer(obj)) {
25211        if (encoder) {
25212          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults2.encoder, charset, "key", format);
25213          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults2.encoder, charset, "value", format))];
25214        }
25215        return [formatter(prefix) + "=" + formatter(String(obj))];
25216      }
25217      var values = [];
25218      if (typeof obj === "undefined") {
25219        return values;
25220      }
25221      var objKeys;
25222      if (generateArrayPrefix === "comma" && isArray2(obj)) {
25223        if (encodeValuesOnly && encoder) {
25224          obj = utils2.maybeMap(obj, function(v) {
25225            return v == null ? v : encoder(v);
25226          });
25227        }
25228        objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
25229      } else if (isArray2(filter)) {
25230        objKeys = filter;
25231      } else {
25232        var keys = Object.keys(obj);
25233        objKeys = sort ? keys.sort(sort) : keys;
25234      }
25235      var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
25236      var adjustedPrefix = commaRoundTrip && isArray2(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
25237      if (allowEmptyArrays && isArray2(obj) && obj.length === 0) {
25238        return adjustedPrefix + "[]";
25239      }
25240      for (var j = 0; j < objKeys.length; ++j) {
25241        var key2 = objKeys[j];
25242        var value = typeof key2 === "object" && key2 && typeof key2.value !== "undefined" ? key2.value : obj[key2];
25243        if (skipNulls && value === null) {
25244          continue;
25245        }
25246        var encodedKey = allowDots && encodeDotInKeys ? String(key2).replace(/\./g, "%2E") : String(key2);
25247        var keyPrefix = isArray2(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
25248        sideChannel2.set(object, step);
25249        var valueSideChannel = getSideChannel();
25250        valueSideChannel.set(sentinel, sideChannel2);
25251        pushToArray(values, stringify2(
25252          value,
25253          keyPrefix,
25254          generateArrayPrefix,
25255          commaRoundTrip,
25256          allowEmptyArrays,

vendor: 6,019 bytes, lines 25257-25401

25257          strictNullHandling,
25258          skipNulls,
25259          encodeDotInKeys,
25260          generateArrayPrefix === "comma" && encodeValuesOnly && isArray2(obj) ? null : encoder,
25261          filter,
25262          sort,
25263          allowDots,
25264          serializeDate,
25265          format,
25266          formatter,
25267          encodeValuesOnly,
25268          charset,
25269          valueSideChannel
25270        ));
25271      }
25272      return values;
25273    };
25274    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
25275      if (!opts) {
25276        return defaults2;
25277      }
25278      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
25279        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
25280      }
25281      if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
25282        throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
25283      }
25284      if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
25285        throw new TypeError("Encoder has to be a function.");
25286      }
25287      var charset = opts.charset || defaults2.charset;
25288      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
25289        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
25290      }
25291      var format = formats2["default"];
25292      if (typeof opts.format !== "undefined") {
25293        if (!has.call(formats2.formatters, opts.format)) {
25294          throw new TypeError("Unknown format option provided.");
25295        }
25296        format = opts.format;
25297      }
25298      var formatter = formats2.formatters[format];
25299      var filter = defaults2.filter;
25300      if (typeof opts.filter === "function" || isArray2(opts.filter)) {
25301        filter = opts.filter;
25302      }
25303      var arrayFormat;
25304      if (opts.arrayFormat in arrayPrefixGenerators) {
25305        arrayFormat = opts.arrayFormat;
25306      } else if ("indices" in opts) {
25307        arrayFormat = opts.indices ? "indices" : "repeat";
25308      } else {
25309        arrayFormat = defaults2.arrayFormat;
25310      }
25311      if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
25312        throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
25313      }
25314      var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
25315      return {
25316        addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults2.addQueryPrefix,
25317        allowDots,
25318        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
25319        arrayFormat,
25320        charset,
25321        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
25322        commaRoundTrip: !!opts.commaRoundTrip,
25323        delimiter: typeof opts.delimiter === "undefined" ? defaults2.delimiter : opts.delimiter,
25324        encode: typeof opts.encode === "boolean" ? opts.encode : defaults2.encode,
25325        encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults2.encodeDotInKeys,
25326        encoder: typeof opts.encoder === "function" ? opts.encoder : defaults2.encoder,
25327        encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults2.encodeValuesOnly,
25328        filter,
25329        format,
25330        formatter,
25331        serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults2.serializeDate,
25332        skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults2.skipNulls,
25333        sort: typeof opts.sort === "function" ? opts.sort : null,
25334        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling
25335      };
25336    };
25337    stringify_1 = function(object, opts) {
25338      var obj = object;
25339      var options = normalizeStringifyOptions(opts);
25340      var objKeys;
25341      var filter;
25342      if (typeof options.filter === "function") {
25343        filter = options.filter;
25344        obj = filter("", obj);
25345      } else if (isArray2(options.filter)) {
25346        filter = options.filter;
25347        objKeys = filter;
25348      }
25349      var keys = [];
25350      if (typeof obj !== "object" || obj === null) {
25351        return "";
25352      }
25353      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
25354      var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
25355      if (!objKeys) {
25356        objKeys = Object.keys(obj);
25357      }
25358      if (options.sort) {
25359        objKeys.sort(options.sort);
25360      }
25361      var sideChannel2 = getSideChannel();
25362      for (var i2 = 0; i2 < objKeys.length; ++i2) {
25363        var key2 = objKeys[i2];
25364        if (typeof key2 === "undefined" || key2 === null) {
25365          continue;
25366        }
25367        var value = obj[key2];
25368        if (options.skipNulls && value === null) {
25369          continue;
25370        }
25371        pushToArray(keys, stringify(
25372          value,
25373          key2,
25374          generateArrayPrefix,
25375          commaRoundTrip,
25376          options.allowEmptyArrays,
25377          options.strictNullHandling,
25378          options.skipNulls,
25379          options.encodeDotInKeys,
25380          options.encode ? options.encoder : null,
25381          options.filter,
25382          options.sort,
25383          options.allowDots,
25384          options.serializeDate,
25385          options.format,
25386          options.formatter,
25387          options.encodeValuesOnly,
25388          options.charset,
25389          sideChannel2
25390        ));
25391      }
25392      var joined = keys.join(options.delimiter);
25393      var prefix = options.addQueryPrefix === true ? "?" : "";
25394      if (options.charsetSentinel) {
25395        if (options.charset === "iso-8859-1") {
25396          prefix += "utf8=%26%2310003%3B" + options.delimiter;
25397        } else {
25398          prefix += "utf8=%E2%9C%93" + options.delimiter;
25399        }
25400      }
25401      return joined.length >

vendor: 11,237 bytes, lines 25401-25678

25401 0 ? prefix + joined : "";
25402    };
25403    return stringify_1;
25404  }
25405  var parse;
25406  var hasRequiredParse;
25407  function requireParse() {
25408    if (hasRequiredParse) return parse;
25409    hasRequiredParse = 1;
25410    var utils2 = /* @__PURE__ */ requireUtils$3();
25411    var has = Object.prototype.hasOwnProperty;
25412    var isArray2 = Array.isArray;
25413    var defaults2 = {
25414      allowDots: false,
25415      allowEmptyArrays: false,
25416      allowPrototypes: false,
25417      allowSparse: false,
25418      arrayLimit: 20,
25419      charset: "utf-8",
25420      charsetSentinel: false,
25421      comma: false,
25422      decodeDotInKeys: false,
25423      decoder: utils2.decode,
25424      delimiter: "&",
25425      depth: 5,
25426      duplicates: "combine",
25427      ignoreQueryPrefix: false,
25428      interpretNumericEntities: false,
25429      parameterLimit: 1e3,
25430      parseArrays: true,
25431      plainObjects: false,
25432      strictDepth: false,
25433      strictMerge: true,
25434      strictNullHandling: false,
25435      throwOnLimitExceeded: false
25436    };
25437    var interpretNumericEntities = function(str) {
25438      return str.replace(/&#(\d+);/g, function($0, numberStr) {
25439        return String.fromCharCode(parseInt(numberStr, 10));
25440      });
25441    };
25442    var parseArrayValue = function(val, options, currentArrayLength) {
25443      if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
25444        return val.split(",");
25445      }
25446      if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
25447        throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
25448      }
25449      return val;
25450    };
25451    var isoSentinel = "utf8=%26%2310003%3B";
25452    var charsetSentinel = "utf8=%E2%9C%93";
25453    var parseValues = function parseQueryStringValues(str, options) {
25454      var obj = { __proto__: null };
25455      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
25456      cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
25457      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
25458      var parts = cleanStr.split(
25459        options.delimiter,
25460        options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit
25461      );
25462      if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) {
25463        throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
25464      }
25465      var skipIndex = -1;
25466      var i2;
25467      var charset = options.charset;
25468      if (options.charsetSentinel) {
25469        for (i2 = 0; i2 < parts.length; ++i2) {
25470          if (parts[i2].indexOf("utf8=") === 0) {
25471            if (parts[i2] === charsetSentinel) {
25472              charset = "utf-8";
25473            } else if (parts[i2] === isoSentinel) {
25474              charset = "iso-8859-1";
25475            }
25476            skipIndex = i2;
25477            i2 = parts.length;
25478          }
25479        }
25480      }
25481      for (i2 = 0; i2 < parts.length; ++i2) {
25482        if (i2 === skipIndex) {
25483          continue;
25484        }
25485        var part = parts[i2];
25486        var bracketEqualsPos = part.indexOf("]=");
25487        var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
25488        var key2;
25489        var val;
25490        if (pos === -1) {
25491          key2 = options.decoder(part, defaults2.decoder, charset, "key");
25492          val = options.strictNullHandling ? null : "";
25493        } else {
25494          key2 = options.decoder(part.slice(0, pos), defaults2.decoder, charset, "key");
25495          if (key2 !== null) {
25496            val = utils2.maybeMap(
25497              parseArrayValue(
25498                part.slice(pos + 1),
25499                options,
25500                isArray2(obj[key2]) ? obj[key2].length : 0
25501              ),
25502              function(encodedVal) {
25503                return options.decoder(encodedVal, defaults2.decoder, charset, "value");
25504              }
25505            );
25506          }
25507        }
25508        if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
25509          val = interpretNumericEntities(String(val));
25510        }
25511        if (part.indexOf("[]=") > -1) {
25512          val = isArray2(val) ? [val] : val;
25513        }
25514        if (options.comma && isArray2(val) && val.length > options.arrayLimit) {
25515          if (options.throwOnLimitExceeded) {
25516            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
25517          }
25518          val = utils2.combine([], val, options.arrayLimit, options.plainObjects);
25519        }
25520        if (key2 !== null) {
25521          var existing = has.call(obj, key2);
25522          if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
25523            obj[key2] = utils2.combine(
25524              obj[key2],
25525              val,
25526              options.arrayLimit,
25527              options.plainObjects
25528            );
25529          } else if (!existing || options.duplicates === "last") {
25530            obj[key2] = val;
25531          }
25532        }
25533      }
25534      return obj;
25535    };
25536    var parseObject = function(chain, val, options, valuesParsed) {
25537      var currentArrayLength = 0;
25538      if (chain.length > 0 && chain[chain.length - 1] === "[]") {
25539        var parentKey = chain.slice(0, -1).join("");
25540        currentArrayLength = Array.isArray(val) && val[parentKey] ? val[parentKey].length : 0;
25541      }
25542      var leaf = valuesParsed ? val : parseArrayValue(val, options, currentArrayLength);
25543      for (var i2 = chain.length - 1; i2 >= 0; --i2) {
25544        var obj;
25545        var root = chain[i2];
25546        if (root === "[]" && options.parseArrays) {
25547          if (utils2.isOverflow(leaf)) {
25548            obj = leaf;
25549          } else {
25550            obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils2.combine(
25551              [],
25552              leaf,
25553              options.arrayLimit,
25554              options.plainObjects
25555            );
25556          }
25557        } else {
25558          obj = options.plainObjects ? { __proto__: null } : {};
25559          var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
25560          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
25561          var index = parseInt(decodedRoot, 10);
25562          var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
25563          if (!options.parseArrays && decodedRoot === "") {
25564            obj = { 0: leaf };
25565          } else if (isValidArrayIndex && index < options.arrayLimit) {
25566            obj = [];
25567            obj[index] = leaf;
25568          } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
25569            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
25570          } else if (isValidArrayIndex) {
25571            obj[index] = leaf;
25572            utils2.markOverflow(obj, index);
25573          } else if (decodedRoot !== "__proto__") {
25574            obj[decodedRoot] = leaf;
25575          }
25576        }
25577        leaf = obj;
25578      }
25579      return leaf;
25580    };
25581    var splitKeyIntoSegments = function splitKeyIntoSegments2(originalKey, options) {
25582      var key2 = options.allowDots ? originalKey.replace(/\.([^.[]+)/g, "[$1]") : originalKey;
25583      if (options.depth <= 0) {
25584        if (!options.plainObjects && has.call(Object.prototype, key2)) {
25585          if (!options.allowPrototypes) {
25586            return;
25587          }
25588        }
25589        return [key2];
25590      }
25591      var segments = [];
25592      var first = key2.indexOf("[");
25593      var parent = first >= 0 ? key2.slice(0, first) : key2;
25594      if (parent) {
25595        if (!options.plainObjects && has.call(Object.prototype, parent)) {
25596          if (!options.allowPrototypes) {
25597            return;
25598          }
25599        }
25600        segments[segments.length] = parent;
25601      }
25602      var n = key2.length;
25603      var open = first;
25604      var collected = 0;
25605      while (open >= 0 && collected < options.depth) {
25606        var level = 1;
25607        var i2 = open + 1;
25608        var close = -1;
25609        while (i2 < n && close < 0) {
25610          var cu = key2.charCodeAt(i2);
25611          if (cu === 91) {
25612            level += 1;
25613          } else if (cu === 93) {
25614            level -= 1;
25615            if (level === 0) {
25616              close = i2;
25617            }
25618          }
25619          i2 += 1;
25620        }
25621        if (close < 0) {
25622          segments[segments.length] = "[" + key2.slice(open) + "]";
25623          return segments;
25624        }
25625        var seg = key2.slice(open, close + 1);
25626        var content = seg.slice(1, -1);
25627        if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
25628          return;
25629        }
25630        segments[segments.length] = seg;
25631        collected += 1;
25632        open = key2.indexOf("[", close + 1);
25633      }
25634      if (open >= 0) {
25635        if (options.strictDepth === true) {
25636          throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
25637        }
25638        segments[segments.length] = "[" + key2.slice(open) + "]";
25639      }
25640      return segments;
25641    };
25642    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
25643      if (!givenKey) {
25644        return;
25645      }
25646      var keys = splitKeyIntoSegments(givenKey, options);
25647      if (!keys) {
25648        return;
25649      }
25650      return parseObject(keys, val, options, valuesParsed);
25651    };
25652    var normalizeParseOptions = function normalizeParseOptions2(opts) {
25653      if (!opts) {
25654        return defaults2;
25655      }
25656      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
25657        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
25658      }
25659      if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") {
25660        throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
25661      }
25662      if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") {
25663        throw new TypeError("Decoder has to be a function.");
25664      }
25665      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
25666        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
25667      }
25668      if (typeof opts.throwOnLimitExceeded !== "undefined" && typeof opts.throwOnLimitExceeded !== "boolean") {
25669        throw new TypeError("`throwOnLimitExceeded` option must be a boolean");
25670      }
25671      var charset = typeof opts.charset === "undefined" ? defaults2.charset : opts.charset;
25672      var duplicates = typeof opts.duplicates === "undefined" ? defaults2.duplicates : opts.duplicates;
25673      if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") {
25674        throw new TypeError("The duplicates option must be either combine, first, or last");
25675      }
25676      var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
25677      return {
25678        allowDots,

25679        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
25680        allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults2.allowPrototypes,
25681        allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults2.allowSparse,
25682        arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults2.arrayLimit,
25683        charset,
25684        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
25685        comma: typeof opts.comma === "boolean" ? opts.comma : defaults2.comma,
25686        decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults2.decodeDotInKeys,
25687        decoder: typeof opts.decoder === "function" ? opts.decoder : defaults2.decoder,
25688        delimiter: typeof opts.delimiter === "string" || utils2.isRegExp(opts.delimiter) ? opts.delimiter : defaults2.delimiter,
25689        // eslint-disable-next-line no-implicit-coercion, no-extra-parens
25690        depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults2.depth,
25691        duplicates,
25692        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
25693        interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults2.interpretNumericEntities,
25694        parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults2.parameterLimit,
25695        parseArrays: opts.parseArrays !== false,
25696        plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults2.plainObjects,
25697        strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults2.strictDepth,
25698        strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults2.strictMerge,
25699        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling,
25700        throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
25701      };
25702    };
25703    parse = function(str, opts) {
25704      var options = normalizeParseOptions(opts);
25705      if (str === "" || str === null || typeof str === "undefined") {
25706        return options.plainObjects ? { __proto__: null } : {};
25707      }
25708      var tempObj = typeof str === "string" ? parseValues(str, options) : str;
25709      var obj = options.plainObjects ? { __proto__: null } : {};
25710      var keys = Object.keys(tempObj);
25711      for (var i2 = 0; i2 < keys.length; ++i2) {
25712        var key2 = keys[i2];
25713        var newObj = parseKeys(key2, tempObj[key2], options, typeof str === "string");
25714        obj = utils2.merge(obj, newObj, options);
25715      }
25716      if (options.allowSparse === true) {
25717        return obj;
25718      }
25719      return utils2.compact(obj);
25720    };
25721    return parse;
25722  }
25723  var lib;
25724  var hasRequiredLib;
25725  function requireLib() {
25726    if (hasRequiredLib) return lib;
25727    hasRequiredLib = 1;
25728    var stringify = /* @__PURE__ */ requireStringify();
25729    var parse2 = /* @__PURE__ */ requireParse();
25730    var formats2 = /* @__PURE__ */ requireFormats();
25731    lib = {
25732      formats: formats2,
25733      parse: parse2,
25734      stringify
25735    };
25736    return lib;
25737  }
25738  var hasRequiredUrl;
25739  function requireUrl() {
25740    if (hasRequiredUrl) return url$1.exports;
25741    hasRequiredUrl = 1;
25742    (function(module, exports$12) {
25743      Object.defineProperty(exports$12, "__esModule", { value: true });
25744      var require$$02 = requirePunycode();
25745      var require$$12 = /* @__PURE__ */ requireLib();
25746      function _interopDefaultLegacy(e) {
25747        return e && typeof e === "object" && "default" in e ? e : { "default": e };
25748      }
25749      var require$$0__default = /* @__PURE__ */ _interopDefaultLegacy(require$$02);
25750      var require$$1__default = /* @__PURE__ */ _interopDefaultLegacy(require$$12);
25751      var punycode2 = require$$0__default["default"];
25752      function Url() {
25753        this.protocol = null;
25754        this.slashes = null;
25755        this.auth = null;
25756        this.host = null;
25757        this.port = null;
25758        this.hostname = null;
25759        this.hash = null;
25760        this.search = null;
25761        this.query = null;
25762        this.pathname = null;
25763        this.path = null;
25764        this.href = null;
25765      }
25766      var protocolPattern = /^([a-z0-9.+-]+:)/i, portPattern = /:[0-9]*$/, simplePathPattern = /^(\/\/?(?!\/)[^?\

vendor: 19,198 bytes, lines 25766-26301

25766s]*)(\?[^\s]*)?$/, delims = [
25767        "<",
25768        ">",
25769        '"',
25770        "`",
25771        " ",
25772        "\r",
25773        "\n",
25774        "	"
25775      ], unwise = [
25776        "{",
25777        "}",
25778        "|",
25779        "\\",
25780        "^",
25781        "`"
25782      ].concat(delims), autoEscape = ["'"].concat(unwise), nonHostChars = [
25783        "%",
25784        "/",
25785        "?",
25786        ";",
25787        "#"
25788      ].concat(autoEscape), hostEndingChars = [
25789        "/",
25790        "?",
25791        "#"
25792      ], hostnameMaxLen = 255, hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, unsafeProtocol = {
25793        javascript: true,
25794        "javascript:": true
25795      }, hostlessProtocol = {
25796        javascript: true,
25797        "javascript:": true
25798      }, slashedProtocol = {
25799        http: true,
25800        https: true,
25801        ftp: true,
25802        gopher: true,
25803        file: true,
25804        "http:": true,
25805        "https:": true,
25806        "ftp:": true,
25807        "gopher:": true,
25808        "file:": true
25809      }, querystring = require$$1__default["default"];
25810      function urlParse(url2, parseQueryString, slashesDenoteHost) {
25811        if (url2 && typeof url2 === "object" && url2 instanceof Url) {
25812          return url2;
25813        }
25814        var u = new Url();
25815        u.parse(url2, parseQueryString, slashesDenoteHost);
25816        return u;
25817      }
25818      Url.prototype.parse = function(url2, parseQueryString, slashesDenoteHost) {
25819        if (typeof url2 !== "string") {
25820          throw new TypeError("Parameter 'url' must be a string, not " + typeof url2);
25821        }
25822        var queryIndex = url2.indexOf("?"), splitter = queryIndex !== -1 && queryIndex < url2.indexOf("#") ? "?" : "#", uSplit = url2.split(splitter), slashRegex = /\\/g;
25823        uSplit[0] = uSplit[0].replace(slashRegex, "/");
25824        url2 = uSplit.join(splitter);
25825        var rest = url2;
25826        rest = rest.trim();
25827        if (!slashesDenoteHost && url2.split("#").length === 1) {
25828          var simplePath = simplePathPattern.exec(rest);
25829          if (simplePath) {
25830            this.path = rest;
25831            this.href = rest;
25832            this.pathname = simplePath[1];
25833            if (simplePath[2]) {
25834              this.search = simplePath[2];
25835              if (parseQueryString) {
25836                this.query = querystring.parse(this.search.substr(1));
25837              } else {
25838                this.query = this.search.substr(1);
25839              }
25840            } else if (parseQueryString) {
25841              this.search = "";
25842              this.query = {};
25843            }
25844            return this;
25845          }
25846        }
25847        var proto = protocolPattern.exec(rest);
25848        if (proto) {
25849          proto = proto[0];
25850          var lowerProto = proto.toLowerCase();
25851          this.protocol = lowerProto;
25852          rest = rest.substr(proto.length);
25853        }
25854        if (slashesDenoteHost || proto || rest.match(/^\/\/[^@/]+@[^@/]+/)) {
25855          var slashes = rest.substr(0, 2) === "//";
25856          if (slashes && !(proto && hostlessProtocol[proto])) {
25857            rest = rest.substr(2);
25858            this.slashes = true;
25859          }
25860        }
25861        if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
25862          var hostEnd = -1;
25863          for (var i2 = 0; i2 < hostEndingChars.length; i2++) {
25864            var hec = rest.indexOf(hostEndingChars[i2]);
25865            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
25866              hostEnd = hec;
25867            }
25868          }
25869          var auth, atSign;
25870          if (hostEnd === -1) {
25871            atSign = rest.lastIndexOf("@");
25872          } else {
25873            atSign = rest.lastIndexOf("@", hostEnd);
25874          }
25875          if (atSign !== -1) {
25876            auth = rest.slice(0, atSign);
25877            rest = rest.slice(atSign + 1);
25878            this.auth = decodeURIComponent(auth);
25879          }
25880          hostEnd = -1;
25881          for (var i2 = 0; i2 < nonHostChars.length; i2++) {
25882            var hec = rest.indexOf(nonHostChars[i2]);
25883            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
25884              hostEnd = hec;
25885            }
25886          }
25887          if (hostEnd === -1) {
25888            hostEnd = rest.length;
25889          }
25890          this.host = rest.slice(0, hostEnd);
25891          rest = rest.slice(hostEnd);
25892          this.parseHost();
25893          this.hostname = this.hostname || "";
25894          var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
25895          if (!ipv6Hostname) {
25896            var hostparts = this.hostname.split(/\./);
25897            for (var i2 = 0, l = hostparts.length; i2 < l; i2++) {
25898              var part = hostparts[i2];
25899              if (!part) {
25900                continue;
25901              }
25902              if (!part.match(hostnamePartPattern)) {
25903                var newpart = "";
25904                for (var j = 0, k = part.length; j < k; j++) {
25905                  if (part.charCodeAt(j) > 127) {
25906                    newpart += "x";
25907                  } else {
25908                    newpart += part[j];
25909                  }
25910                }
25911                if (!newpart.match(hostnamePartPattern)) {
25912                  var validParts = hostparts.slice(0, i2);
25913                  var notHost = hostparts.slice(i2 + 1);
25914                  var bit = part.match(hostnamePartStart);
25915                  if (bit) {
25916                    validParts.push(bit[1]);
25917                    notHost.unshift(bit[2]);
25918                  }
25919                  if (notHost.length) {
25920                    rest = "/" + notHost.join(".") + rest;
25921                  }
25922                  this.hostname = validParts.join(".");
25923                  break;
25924                }
25925              }
25926            }
25927          }
25928          if (this.hostname.length > hostnameMaxLen) {
25929            this.hostname = "";
25930          } else {
25931            this.hostname = this.hostname.toLowerCase();
25932          }
25933          if (!ipv6Hostname) {
25934            this.hostname = punycode2.toASCII(this.hostname);
25935          }
25936          var p = this.port ? ":" + this.port : "";
25937          var h = this.hostname || "";
25938          this.host = h + p;
25939          this.href += this.host;
25940          if (ipv6Hostname) {
25941            this.hostname = this.hostname.substr(1, this.hostname.length - 2);
25942            if (rest[0] !== "/") {
25943              rest = "/" + rest;
25944            }
25945          }
25946        }
25947        if (!unsafeProtocol[lowerProto]) {
25948          for (var i2 = 0, l = autoEscape.length; i2 < l; i2++) {
25949            var ae = autoEscape[i2];
25950            if (rest.indexOf(ae) === -1) {
25951              continue;
25952            }
25953            var esc = encodeURIComponent(ae);
25954            if (esc === ae) {
25955              esc = escape(ae);
25956            }
25957            rest = rest.split(ae).join(esc);
25958          }
25959        }
25960        var hash2 = rest.indexOf("#");
25961        if (hash2 !== -1) {
25962          this.hash = rest.substr(hash2);
25963          rest = rest.slice(0, hash2);
25964        }
25965        var qm = rest.indexOf("?");
25966        if (qm !== -1) {
25967          this.search = rest.substr(qm);
25968          this.query = rest.substr(qm + 1);
25969          if (parseQueryString) {
25970            this.query = querystring.parse(this.query);
25971          }
25972          rest = rest.slice(0, qm);
25973        } else if (parseQueryString) {
25974          this.search = "";
25975          this.query = {};
25976        }
25977        if (rest) {
25978          this.pathname = rest;
25979        }
25980        if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
25981          this.pathname = "/";
25982        }
25983        if (this.pathname || this.search) {
25984          var p = this.pathname || "";
25985          var s = this.search || "";
25986          this.path = p + s;
25987        }
25988        this.href = this.format();
25989        return this;
25990      };
25991      function urlFormat(obj) {
25992        if (typeof obj === "string") {
25993          obj = urlParse(obj);
25994        }
25995        if (!(obj instanceof Url)) {
25996          return Url.prototype.format.call(obj);
25997        }
25998        return obj.format();
25999      }
26000      Url.prototype.format = function() {
26001        var auth = this.auth || "";
26002        if (auth) {
26003          auth = encodeURIComponent(auth);
26004          auth = auth.replace(/%3A/i, ":");
26005          auth += "@";
26006        }
26007        var protocol = this.protocol || "", pathname = this.pathname || "", hash2 = this.hash || "", host = false, query = "";
26008        if (this.host) {
26009          host = auth + this.host;
26010        } else if (this.hostname) {
26011          host = auth + (this.hostname.indexOf(":") === -1 ? this.hostname : "[" + this.hostname + "]");
26012          if (this.port) {
26013            host += ":" + this.port;
26014          }
26015        }
26016        if (this.query && typeof this.query === "object" && Object.keys(this.query).length) {
26017          query = querystring.stringify(this.query, {
26018            arrayFormat: "repeat",
26019            addQueryPrefix: false
26020          });
26021        }
26022        var search = this.search || query && "?" + query || "";
26023        if (protocol && protocol.substr(-1) !== ":") {
26024          protocol += ":";
26025        }
26026        if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
26027          host = "//" + (host || "");
26028          if (pathname && pathname.charAt(0) !== "/") {
26029            pathname = "/" + pathname;
26030          }
26031        } else if (!host) {
26032          host = "";
26033        }
26034        if (hash2 && hash2.charAt(0) !== "#") {
26035          hash2 = "#" + hash2;
26036        }
26037        if (search && search.charAt(0) !== "?") {
26038          search = "?" + search;
26039        }
26040        pathname = pathname.replace(/[?#]/g, function(match) {
26041          return encodeURIComponent(match);
26042        });
26043        search = search.replace("#", "%23");
26044        return protocol + host + pathname + search + hash2;
26045      };
26046      function urlResolve(source, relative) {
26047        return urlParse(source, false, true).resolve(relative);
26048      }
26049      Url.prototype.resolve = function(relative) {
26050        return this.resolveObject(urlParse(relative, false, true)).format();
26051      };
26052      function urlResolveObject(source, relative) {
26053        if (!source) {
26054          return relative;
26055        }
26056        return urlParse(source, false, true).resolveObject(relative);
26057      }
26058      Url.prototype.resolveObject = function(relative) {
26059        if (typeof relative === "string") {
26060          var rel = new Url();
26061          rel.parse(relative, false, true);
26062          relative = rel;
26063        }
26064        var result = new Url();
26065        var tkeys = Object.keys(this);
26066        for (var tk = 0; tk < tkeys.length; tk++) {
26067          var tkey = tkeys[tk];
26068          result[tkey] = this[tkey];
26069        }
26070        result.hash = relative.hash;
26071        if (relative.href === "") {
26072          result.href = result.format();
26073          return result;
26074        }
26075        if (relative.slashes && !relative.protocol) {
26076          var rkeys = Object.keys(relative);
26077          for (var rk = 0; rk < rkeys.length; rk++) {
26078            var rkey = rkeys[rk];
26079            if (rkey !== "protocol") {
26080              result[rkey] = relative[rkey];
26081            }
26082          }
26083          if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {
26084            result.pathname = "/";
26085            result.path = result.pathname;
26086          }
26087          result.href = result.format();
26088          return result;
26089        }
26090        if (relative.protocol && relative.protocol !== result.protocol) {
26091          if (!slashedProtocol[relative.protocol]) {
26092            var keys = Object.keys(relative);
26093            for (var v = 0; v < keys.length; v++) {
26094              var k = keys[v];
26095              result[k] = relative[k];
26096            }
26097            result.href = result.format();
26098            return result;
26099          }
26100          result.protocol = relative.protocol;
26101          if (!relative.host && !hostlessProtocol[relative.protocol]) {
26102            var relPath = (relative.pathname || "").split("/");
26103            while (relPath.length && !(relative.host = relPath.shift())) {
26104            }
26105            if (!relative.host) {
26106              relative.host = "";
26107            }
26108            if (!relative.hostname) {
26109              relative.hostname = "";
26110            }
26111            if (relPath[0] !== "") {
26112              relPath.unshift("");
26113            }
26114            if (relPath.length < 2) {
26115              relPath.unshift("");
26116            }
26117            result.pathname = relPath.join("/");
26118          } else {
26119            result.pathname = relative.pathname;
26120          }
26121          result.search = relative.search;
26122          result.query = relative.query;
26123          result.host = relative.host || "";
26124          result.auth = relative.auth;
26125          result.hostname = relative.hostname || relative.host;
26126          result.port = relative.port;
26127          if (result.pathname || result.search) {
26128            var p = result.pathname || "";
26129            var s = result.search || "";
26130            result.path = p + s;
26131          }
26132          result.slashes = result.slashes || relative.slashes;
26133          result.href = result.format();
26134          return result;
26135        }
26136        var isSourceAbs = result.pathname && result.pathname.charAt(0) === "/", isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === "/", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split("/") || [], relPath = relative.pathname && relative.pathname.split("/") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];
26137        if (psychotic) {
26138          result.hostname = "";
26139          result.port = null;
26140          if (result.host) {
26141            if (srcPath[0] === "") {
26142              srcPath[0] = result.host;
26143            } else {
26144              srcPath.unshift(result.host);
26145            }
26146          }
26147          result.host = "";
26148          if (relative.protocol) {
26149            relative.hostname = null;
26150            relative.port = null;
26151            if (relative.host) {
26152              if (relPath[0] === "") {
26153                relPath[0] = relative.host;
26154              } else {
26155                relPath.unshift(relative.host);
26156              }
26157            }
26158            relative.host = null;
26159          }
26160          mustEndAbs = mustEndAbs && (relPath[0] === "" || srcPath[0] === "");
26161        }
26162        if (isRelAbs) {
26163          result.host = relative.host || relative.host === "" ? relative.host : result.host;
26164          result.hostname = relative.hostname || relative.hostname === "" ? relative.hostname : result.hostname;
26165          result.search = relative.search;
26166          result.query = relative.query;
26167          srcPath = relPath;
26168        } else if (relPath.length) {
26169          if (!srcPath) {
26170            srcPath = [];
26171          }
26172          srcPath.pop();
26173          srcPath = srcPath.concat(relPath);
26174          result.search = relative.search;
26175          result.query = relative.query;
26176        } else if (relative.search != null) {
26177          if (psychotic) {
26178            result.host = srcPath.shift();
26179            result.hostname = result.host;
26180            var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
26181            if (authInHost) {
26182              result.auth = authInHost.shift();
26183              result.hostname = authInHost.shift();
26184              result.host = result.hostname;
26185            }
26186          }
26187          result.search = relative.search;
26188          result.query = relative.query;
26189          if (result.pathname !== null || result.search !== null) {
26190            result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
26191          }
26192          result.href = result.format();
26193          return result;
26194        }
26195        if (!srcPath.length) {
26196          result.pathname = null;
26197          if (result.search) {
26198            result.path = "/" + result.search;
26199          } else {
26200            result.path = null;
26201          }
26202          result.href = result.format();
26203          return result;
26204        }
26205        var last = srcPath.slice(-1)[0];
26206        var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === "." || last === "..") || last === "";
26207        var up = 0;
26208        for (var i2 = srcPath.length; i2 >= 0; i2--) {
26209          last = srcPath[i2];
26210          if (last === ".") {
26211            srcPath.splice(i2, 1);
26212          } else if (last === "..") {
26213            srcPath.splice(i2, 1);
26214            up++;
26215          } else if (up) {
26216            srcPath.splice(i2, 1);
26217            up--;
26218          }
26219        }
26220        if (!mustEndAbs && !removeAllDots) {
26221          for (; up--; up) {
26222            srcPath.unshift("..");
26223          }
26224        }
26225        if (mustEndAbs && srcPath[0] !== "" && (!srcPath[0] || srcPath[0].charAt(0) !== "/")) {
26226          srcPath.unshift("");
26227        }
26228        if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/") {
26229          srcPath.push("");
26230        }
26231        var isAbsolute = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
26232        if (psychotic) {
26233          result.hostname = isAbsolute ? "" : srcPath.length ? srcPath.shift() : "";
26234          result.host = result.hostname;
26235          var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
26236          if (authInHost) {
26237            result.auth = authInHost.shift();
26238            result.hostname = authInHost.shift();
26239            result.host = result.hostname;
26240          }
26241        }
26242        mustEndAbs = mustEndAbs || result.host && srcPath.length;
26243        if (mustEndAbs && !isAbsolute) {
26244          srcPath.unshift("");
26245        }
26246        if (srcPath.length > 0) {
26247          result.pathname = srcPath.join("/");
26248        } else {
26249          result.pathname = null;
26250          result.path = null;
26251        }
26252        if (result.pathname !== null || result.search !== null) {
26253          result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
26254        }
26255        result.auth = relative.auth || result.auth;
26256        result.slashes = result.slashes || relative.slashes;
26257        result.href = result.format();
26258        return result;
26259      };
26260      Url.prototype.parseHost = function() {
26261        var host = this.host;
26262        var port = portPattern.exec(host);
26263        if (port) {
26264          port = port[0];
26265          if (port !== ":") {
26266            this.port = port.substr(1);
26267          }
26268          host = host.substr(0, host.length - port.length);
26269        }
26270        if (host) {
26271          this.hostname = host;
26272        }
26273      };
26274      var parse2 = urlParse;
26275      var resolve$1 = urlResolve;
26276      var resolveObject = urlResolveObject;
26277      var format = urlFormat;
26278      var Url_1 = Url;
26279      function normalizeArray(parts, allowAboveRoot) {
26280        var up = 0;
26281        for (var i2 = parts.length - 1; i2 >= 0; i2--) {
26282          var last = parts[i2];
26283          if (last === ".") {
26284            parts.splice(i2, 1);
26285          } else if (last === "..") {
26286            parts.splice(i2, 1);
26287            up++;
26288          } else if (up) {
26289            parts.splice(i2, 1);
26290            up--;
26291          }
26292        }
26293        if (allowAboveRoot) {
26294          for (; up--; up) {
26295            parts.unshift("..");
26296          }
26297        }
26298        return parts;
26299      }
26300      function resolve() {
26301        var resolvedPath = "", resolvedAbsolute = false;

26302        for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
26303          var path = i2 >= 0 ? arguments[i2] : "/";
26304          if (typeof path !== "string") {
26305            throw new TypeError("Arguments to path.resolve must be strings");
26306          } else if (!path) {
26307            continue;
26308          }
26309          resolvedPath = path + "/" + resolvedPath;
26310          resolvedAbsolute = path.charAt(0) === "/";
26311        }
26312        resolvedPath = normalizeArray(filter(resolvedPath.split("/"), function(p) {
26313          return !!p;
26314        }), !resolvedAbsolute).join("/");
26315        return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
26316      }
26317      function filter(xs, f) {
26318        if (xs.filter) return xs.filter(f);
26319        var res = [];
26320        for (var i2 = 0; i2 < xs.length; i2++) {
26321          if (f(xs[i2], i2, xs)) res.push(xs[i2]);
26322        }
26323        return res;
26324      }
26325      var _globalThis = (function(Object2) {
26326        function get2() {
26327          var _global3 = this || self;
26328          delete Object2.prototype.__magic__;
26329          return _global3;
26330        }
26331        if (typeof globalThis === "object") {
26332          return globalThis;
26333        }
26334        if (this) {
26335          return get2();
26336        } else {
26337          Object2.defineProperty(Object2.prototype, "__magic__", {
26338            configurable: true,
26339            get: get2
26340          });
26341          var _global2 = __magic__;
26342          return _global2;
26343        }
26344      })(Object);
26345      var formatImport = (
26346        /** @type {formatImport}*/
26347        format
26348      );
26349      var parseImport = (
26350        /** @type {parseImport}*/
26351        parse2
26352      );
26353      var resolveImport = (
26354        /** @type {resolveImport}*/
26355        resolve$1
26356      );
26357      var UrlImport = (
26358        /** @type {UrlImport}*/
26359        Url_1
26360      );
26361      var URL2 = _globalThis.URL;
26362      var URLSearchParams2 = _globalThis.URLSearchParams;
26363      var percentRegEx = /%/g;
26364      var backslashRegEx = /\\/g;
26365      var newlineRegEx = /\n/g;
26366      var carriageReturnRegEx = /\r/g;
26367      var tabRegEx = /\t/g;
26368      var CHAR_FORWARD_SLASH = 47;
26369      function isURLInstance(instance) {
26370        var resolved = (
26371          /** @type {URL|null} */
26372          instance != null ? instance : null
26373        );
26374        return Boolean(resolved !== null && (resolved == null ? void 0 : resolved.href) && (resolved == null ? void 0 : resolved.origin));
26375      }
26376      function getPathFromURLPosix(url2) {
26377        if (url2.hostname !== "") {
26378          throw new TypeError('File URL host must be "localhost" or empty on browser');
26379        }
26380        var pathname = url2.pathname;
26381        for (var n = 0; n < pathname.length; n++) {
26382          if (pathname[n] === "%") {
26383            var third = pathname.codePointAt(n + 2) | 32;
26384            if (pathname[n + 1] === "2" && third === 102) {
26385              throw new TypeError("File URL path must not include encoded / characters");
26386            }
26387          }
26388        }
26389        return decodeURIComponent(pathname);
26390      }
26391      function encodePathChars(filepath) {
26392        if (filepath.includes("%")) {
26393          filepath = filepath.replace(percentRegEx, "%25");
26394        }
26395        if (filepath.includes("\\")) {
26396          filepath = filepath.replace(backslashRegEx, "%5C");
26397        }
26398        if (filepath.includes("\n")) {
26399          filepath = filepath.replace(newlineRegEx, "%0A");
26400        }
26401        if (filepath.includes("\r")) {
26402          filepath = filepath.replace(carriageReturnRegEx, "%0D");
26403        }
26404        if (filepath.includes("	")) {
26405          filepath = filepath.replace(tabRegEx, "%09");
26406        }
26407        return filepath;
26408      }
26409      var domainToASCII = (
26410        /**
26411         * @type {domainToASCII}
26412         */
26413        function domainToASCII2(domain) {
26414          if (typeof domain === "undefined") {
26415            throw new TypeError('The "domain" argument must be specified');
26416          }
26417          return new URL2("http://" + domain).hostname;
26418        }
26419      );
26420      var domainToUnicode = (
26421        /**
26422         * @type {domainToUnicode}
26423         */
26424        function domainToUnicode2(domain) {
26425          if (typeof domain === "undefined") {
26426            throw new TypeError('The "domain" argument must be specified');
26427          }
26428          return new URL2("http://" + domain).hostname;
26429        }
26430      );
26431      var pathToFileURL = (
26432        /**
26433         * @type {(url: string) =>

26433 URL}
26434         */
26435        function pathToFileURL2(filepath) {
26436          var outURL = new URL2("file://");
26437          var resolved = resolve(filepath);
26438          var filePathLast = filepath.charCodeAt(filepath.length - 1);
26439          if (filePathLast === CHAR_FORWARD_SLASH && resolved[resolved.length - 1] !== "/") {
26440            resolved += "/";
26441          }
26442          outURL.pathname = encodePathChars(resolved);
26443          return outURL;
26444        }
26445      );
26446      var fileURLToPath = (
26447        /**
26448         * @type {fileURLToPath & ((path: string | URL) => string)}
26449         */
26450        function fileURLToPath2(path) {
26451          if (!isURLInstance(path) && typeof path !== "string") {
26452            throw new TypeError('The "path" argument must be of type string or an instance of URL. Received type ' + typeof path + " (" + path + ")");
26453          }
26454          var resolved = new URL2(path);
26455          if (resolved.protocol !== "file:") {
26456            throw new TypeError("The URL must be of scheme file");
26457          }
26458          return getPathFromURLPosix(resolved);
26459        }
26460      );
26461      var formatImportWithOverloads = (
26462        /**
26463         * @type {(
26464         *   ((urlObject: URL, options?: URLFormatOptions) => string) &
26465         *   ((urlObject: UrlObject | string, options?: never) => string)
26466         * )}
26467         */
26468        function formatImportWithOverloads2(urlObject, options) {
26469          var _options$auth, _options$fragment, _options$search, _options$unicode;
26470          if (options === void 0) {
26471            options = {};
26472          }
26473          if (!(urlObject instanceof URL2)) {
26474            return formatImport(urlObject);
26475          }
26476          if (typeof options !== "object" || options === null) {
26477            throw new TypeError('The "options" argument must be of type object.');
26478          }
26479          var auth = (_options$auth = options.auth) != null ? _options$auth : true;
26480          var fragment = (_options$fragment = options.fragment) != null ? _options$fragment : true;
26481          var search = (_options$search = options.search) != null ? _options$search : true;
26482          (_options$unicode = options.unicode) != null ? _options$unicode : false;
26483          var parsed = new URL2(urlObject.toString());
26484          if (!auth) {
26485            parsed.username = "";
26486            parsed.password = "";
26487          }
26488          if (!fragment) {
26489            parsed.hash = "";
26490          }
26491          if (!search) {
26492            parsed.search = "";
26493          }
26494          return parsed.toString();
26495        }
26496      );
26497      var api2 = {
26498        format: formatImportWithOverloads,
26499        parse: parseImport,
26500        resolve: resolveImport,
26501        resolveObject,
26502        Url: UrlImport,
26503        URL: URL2,
26504        URLSearchParams: URLSearchParams2,
26505        domainToASCII,
26506        domainToUnicode,
26507        pathToFileURL,
26508        fileURLToPath
26509      };
26510      exports$12.URL = URL2;
26511      exports$12.URLSearchParams = URLSearchParams2;
26512      exports$12.Url = UrlImport;
26513      exports$12["default"] = api2;
26514      exports$12.domainToASCII = domainToASCII;
26515      exports$12.domainToUnicode = domainToUnicode;
26516      exports$12.fileURLToPath = fileURLToPath;
26517      exports$12.format = formatImportWithOverloads;
26518      exports$12.parse = parseImport;
26519      exports$12.pathToFileURL = pathToFileURL;
26520      exports$12.resolve = resolveImport;
26521      exports$12.resolveObject = resolveObject;
26522      exports$12 = module.exports = api2;
26523    })(url$1, url$1.exports);
26524    return url$1.exports;
26525  }
26526  var hasRequiredStreamHttp;
26527  function requireStreamHttp() {
26528    if (hasRequiredStreamHttp) return streamHttp;
26529    hasRequiredStreamHttp = 1;
26530    (function(exports$12) {
26531      var ClientRequest = requireRequest();
26532      var response2 = requireResponse();
26533      var extend2 = requireImmutable();
26534      var statusCodes = requireBuiltinStatusCodes();
26535      var url2 = requireUrl();
26536      var http3 = exports$12;
26537      http3.request = function(opts, cb) {
26538        if (typeof opts === "string")
26539          opts = url2.parse(opts);
26540        else
26541          opts = extend2(opts);
26542        var defaultProtocol = commonjsGlobal.location.protocol.search(/^https?:$/) === -1 ? "http:" : "";
26543        var protocol = opts.protocol || defaultProtocol;
26544        var host = opts.hostname || opts.host;
26545        var port = opts.port;
26546        var path = opts.path || "/";
26547        if (host && host.indexOf(":") !== -1)

26548          host = "[" + host + "]";
26549        opts.url = (host ? protocol + "//" + host : "") + (port ? ":" + port : "") + path;
26550        opts.method = (opts.method || "GET").toUpperCase();
26551        opts.headers = opts.headers || {};
26552        var req = new ClientRequest(opts);
26553        if (cb)
26554          req.on("response", cb);
26555        return req;
26556      };
26557      http3.get = function get2(opts, cb) {
26558        var req = http3.request(opts, cb);
26559        req.end();
26560        return req;
26561      };
26562      http3.ClientRequest = ClientRequest;
26563      http3.IncomingMessage = response2.IncomingMessage;
26564      http3.Agent = function() {
26565      };
26566      http3.Agent.defaultMaxSockets = 4;
26567      http3.globalAgent = new http3.Agent();
26568      http3.STATUS_CODES = statusCodes;
26569      http3.METHODS = [
26570        "CHECKOUT",
26571        "CONNECT",
26572        "COPY",
26573        "DELETE",
26574        "GET",
26575        "HEAD",
26576        "LOCK",
26577        "M-SEARCH",
26578        "MERGE",
26579        "MKACTIVITY",
26580        "MKCOL",
26581        "MOVE",
26582        "NOTIFY",
26583        "OPTIONS",
26584        "PATCH",
26585        "POST",
26586        "PROPFIND",
26587        "PROPPATCH",
26588        "PURGE",
26589        "PUT",
26590        "REPORT",
26591        "SEARCH",
26592        "SUBSCRIBE",
26593        "TRACE",
26594        "UNLOCK",
26595        "UNSUBSCRIBE"
26596      ];
26597    })(streamHttp);
26598    return streamHttp;
26599  }
26600  var httpsBrowserify = { exports: {} };
26601  var hasRequiredHttpsBrowserify;
26602  function requireHttpsBrowserify() {
26603    if (hasRequiredHttpsBrowserify) return httpsBrowserify.exports;
26604    hasRequiredHttpsBrowserify = 1;
26605    (function(module) {
26606      var http3 = requireStreamHttp();
26607      var url2 = requireUrl();
26608      var https2 = module.exports;
26609      for (var key2 in http3) {
26610        if (http3.hasOwnProperty(key2)) https2[key2] = http3[key2];
26611      }
26612      https2.request = function(params, cb) {
26613        params = validateParams(params);
26614        return http3.request.call(this, params, cb);
26615      };
26616      https2.get = function(params, cb) {
26617        params = validateParams(params);
26618        return http3.get.call(this, params, cb);
26619      };
26620      function validateParams(params) {
26621        if (typeof params === "string") {
26622          params = url2.parse(params);
26623        }
26624        if (!params.protocol) {
26625          params.protocol = "https:";
26626        }
26627        if (params.protocol !== "https:") {
26628          throw new Error('Protocol "' + params.protocol + '" not supported. Expected "https:"');
26629        }
26630        return params;
26631      }
26632    })(httpsBrowserify);
26633    return httpsBrowserify.exports;
26634  }
26635  var empty_1;
26636  var hasRequiredEmpty;
26637  function requireEmpty() {
26638    if (hasRequiredEmpty) return empty_1;
26639    hasRequiredEmpty = 1;
26640    var empty = null;
26641    empty_1 = empty;
26642    return empty_1;
26643  }
26644  var cryptoBrowserify = {};
26645  var randombytes;
26646  var hasRequiredRandombytes;
26647  function requireRandombytes() {
26648    if (hasRequiredRandombytes) return randombytes;
26649    hasRequiredRandombytes = 1;
26650    randombytes = requireCryptoBrowserify().randomBytes;
26651    return randombytes;
26652  }
26653  var createHash;
26654  var hasRequiredCreateHash;
26655  function requireCreateHash() {
26656    if (hasRequiredCreateHash) return createHash;
26657    hasRequiredCreateHash = 1;
26658    createHash = requireCryptoBrowserify().createHash;
26659    return createHash;
26660  }
26661  var createHmac;
26662  var hasRequiredCreateHmac;
26663  function requireCreateHmac() {
26664    if (hasRequiredCreateHmac) return createHmac;
26665    hasRequiredCreateHmac = 1;
26666    createHmac = requireCryptoBrowserify().createHmac;
26667    return createHmac;
26668  }
26669  const sha224WithRSAEncryption = { "sign": "rsa", "hash": "sha224", "id": "302d300d06096086480165030402040500041c" };
26670  const sha256WithRSAEncryption = { "sign": "rsa", "hash": "sha256", "id": "3031300d060960864801650304020105000420" };
26671  const sha384WithRSAEncryption = { "sign": "rsa", "hash": "sha384", "id": "3041300d060960864801650304020205000430" };
26672  const sha512WithRSAEncryption = { "sign": "rsa", "hash": "sha512", "id": "3051300d060960864801650304020305000440" };
26673  const sha256 = { "sign": "ecdsa", "hash": "sha256", "id": "" };
26674  const sha224 = { "sign": "ecdsa", "hash": "sha224", "id": "" };
26675  const sha384 = { "sign": "ecdsa", "hash": "sha384", "id": "" };
26676  const sha512 = { "sign": "ecdsa", "hash": "sha512", "id": "" };
26677  const DSA = { "sign": "dsa", "hash": "sha1", "id": "" };
26678  const ripemd160WithRSA = { "sign": "rsa", "hash": "rmd160", "id": "3021300906052b2403020105000414" };
26679  const md5WithRSAEncryption = { "sign": "rsa", "hash": "md5", "id": "3020300c06082a864886f70d020505000410" };
26680  const require$$0$2 = {
26681    sha224WithRSAEncryption,
26682    "RSA-SHA224": { "sign": "ecdsa/rsa", "hash": "sha224", "id": "302d300d06096086480165030402040500041c" },
26683    sha256WithRSAEncryption,
26684    "RSA-SHA256": { "sign": "ecdsa/rsa", "hash": "sha256", "id": "3031300d060960864801650304020105000420" },
26685    sha384WithRSAEncryption,
26686    "RSA-SHA384": { "sign": "ecdsa/rsa", "hash": "sha384", "id": "3041300d060960864801650304020205000430" },
26687    sha512WithRSAEncryption,
26688    "RSA-SHA512": { "sign": "ecdsa/rsa", "hash": "sha512", "id": "3051300d060960864801650304020305000440" },
26689    "RSA-SHA1": { "sign": "rsa", "hash": "sha1", "id": "3021300906052b0e03021a05000414" },
26690    "ecdsa-with-SHA1": { "sign": "ecdsa", "hash": "sha1", "id": "" },
26691    sha256,
26692    sha224,
26693    sha384,
26694    sha512,
26695    "DSA-SHA": { "sign": "dsa", "hash": "sha1", "id": "" },
26696    "DSA-SHA1": { "sign": "dsa", "hash": "sha1", "id": "" },
26697    DSA,
26698    "DSA-WITH-SHA224": { "sign": "dsa", "hash": "sha224", "id": "" },
26699    "DSA-SHA224": { "sign": "dsa", "hash": "sha224", "id": "" },
26700    "DSA-WITH-SHA256": { "sign": "dsa", "hash": "sha256", "id": "" },
26701    "DSA-SHA256": { "sign": "dsa", "hash": "sha256", "id": "" },
26702    "DSA-WITH-SHA384": { "sign": "dsa", "hash": "sha384", "id": "" },
26703    "DSA-SHA384": { "sign": "dsa", "hash": "sha384", "id": "" },
26704    "DSA-WITH-SHA512": { "sign": "dsa", "hash": "sha512", "id": "" },
26705    "DSA-SHA512": { "sign": "dsa", "hash": "sha512", "id": "" },
26706    "DSA-RIPEMD160": { "sign": "dsa", "hash": "rmd160", "id": "" },
26707    ripemd160WithRSA,
26708    "RSA-RIPEMD160": { "sign": "rsa", "hash": "rmd160", "id": "3021300906052b2403020105000414" },
26709    md5WithRSAEncryption,
26710    "RSA-MD5": { "sign": "rsa", "hash": "md5", "id": "3020300c06082a864886f70d020505000410" }
26711  };
26712  var algos;
26713  var hasRequiredAlgos;
26714  function requireAlgos() {
26715    if (hasRequiredAlgos) return algos;

26716    hasRequiredAlgos = 1;
26717    algos = require$$0$2;
26718    return algos;
26719  }
26720  var pbkdf2 = {};
26721  var precondition;
26722  var hasRequiredPrecondition;
26723  function requirePrecondition() {
26724    if (hasRequiredPrecondition) return precondition;
26725    hasRequiredPrecondition = 1;
26726    var $isFinite = isFinite;
26727    var MAX_ALLOC = Math.pow(2, 30) - 1;
26728    precondition = function(iterations, keylen) {
26729      if (typeof iterations !== "number") {
26730        throw new TypeError("Iterations not a number");
26731      }
26732      if (iterations < 0 || !$isFinite(iterations)) {
26733        throw new TypeError("Bad iterations");
26734      }
26735      if (typeof keylen !== "number") {
26736        throw new TypeError("Key length not a number");
26737      }
26738      if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) {
26739        throw new TypeError("Bad key length");
26740      }
26741    };
26742    return precondition;
26743  }
26744  var defaultEncoding_1;
26745  var hasRequiredDefaultEncoding;
26746  function requireDefaultEncoding() {
26747    if (hasRequiredDefaultEncoding) return defaultEncoding_1;
26748    hasRequiredDefaultEncoding = 1;
26749    var defaultEncoding;
26750    if (commonjsGlobal.process && commonjsGlobal.process.browser) {
26751      defaultEncoding = "utf-8";
26752    } else if (commonjsGlobal.process && commonjsGlobal.process.version) {
26753      var pVersionMajor = parseInt(process$1.version.split(".")[0].slice(1), 10);
26754      defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary";
26755    } else {
26756      defaultEncoding = "utf-8";
26757    }
26758    defaultEncoding_1 = defaultEncoding;
26759    return defaultEncoding_1;
26760  }
26761  var isarray$1;
26762  var hasRequiredIsarray$1;
26763  function requireIsarray$1() {
26764    if (hasRequiredIsarray$1) return isarray$1;
26765    hasRequiredIsarray$1 = 1;
26766    var toString2 = {}.toString;
26767    isarray$1 = Array.isArray || function(arr) {
26768      return toString2.call(arr) == "[object Array]";
26769    };
26770    return isarray$1;
26771  }
26772  var typedArrayBuffer;
26773  var hasRequiredTypedArrayBuffer;
26774  function requireTypedArrayBuffer() {
26775    if (hasRequiredTypedArrayBuffer) return typedArrayBuffer;
26776    hasRequiredTypedArrayBuffer = 1;
26777    var $TypeError = /* @__PURE__ */ requireType();
26778    var callBound2 = /* @__PURE__ */ requireCallBound$1();
26779    var $typedArrayBuffer = callBound2("TypedArray.prototype.buffer", true);
26780    var isTypedArray2 = /* @__PURE__ */ requireIsTypedArray();
26781    typedArrayBuffer = $typedArrayBuffer || function typedArrayBuffer2(x) {
26782      if (!isTypedArray2(x)) {
26783        throw new $TypeError("Not a Typed Array");
26784      }
26785      return x.buffer;
26786    };
26787    return typedArrayBuffer;
26788  }
26789  var toBuffer;
26790  var hasRequiredToBuffer$2;
26791  function requireToBuffer$2() {
26792    if (hasRequiredToBuffer$2) return toBuffer;
26793    hasRequiredToBuffer$2 = 1;
26794    var Buffer2 = requireSafeBuffer$1().Buffer;
26795    var isArray2 = requireIsarray$1();
26796    var typedArrayBuffer2 = /* @__PURE__ */ requireTypedArrayBuffer();
26797    var isView = ArrayBuffer.isView || function isView2(obj) {
26798      try {
26799        typedArrayBuffer2(obj);
26800        return true;
26801      } catch (e) {
26802        return false;
26803      }
26804    };
26805    var useUint8Array = typeof Uint8Array !== "undefined";
26806    var useArrayBuffer = typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined";
26807    var useFromArrayBuffer = useArrayBuffer && (Buffer2.prototype instanceof Uint8Array || Buffer2.TYPED_ARRAY_SUPPORT);
26808    toBuffer = function toBuffer2(data, encoding) {
26809      if (Buffer2.isBuffer(data)) {
26810        if (data.constructor && !("isBuffer" in data)) {
26811          return Buffer2.from(data);
26812        }
26813        return data;
26814      }
26815      if (typeof data === "string") {
26816        return Buffer2.from(data, encoding);
26817      }
26818      if (useArrayBuffer && isView(data)) {
26819        if (data.byteLength === 0) {
26820          return Buffer2.alloc(0);
26821        }
26822        if (useFromArrayBuffer) {
26823          var res = Buffer2.from(data.buffer, data.byteOffset, data.byteLength);
26824          if (res.byteLength === data.byteLength) {
26825            return res;
26826          }
26827        }
26828        var uint8 = data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
26829        var result = Buffer2.from(uint8);
26830        if (result.length === data.byteLength) {
26831          return result;
26832        }
26833      }
26834      if (useUint8Array && data instanceof Uint8Array) {
26835        return Buffer2.from(data);
26836      }
26837      var isArr = isArray2(data);
26838      if (isArr) {
26839        for (var i2 = 0; i2 < data.length; i2 += 1) {
26840          var x = data[i2];
26841          if (typeof x !== "number" || x < 0 || x > 255 || ~~x !== x) {
26842            throw new RangeError("Array items must be numbers in the range 0-255.");
26843          }
26844        }
26845      }
26846      if (isArr || Buffer2.isBuffer(data) && data.constructor && typeof data.constructor.isBuffer === "function" && data.constructor.isBuffer(data)) {
26847        return Buffer2.from(data);
26848      }
26849      throw new TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
26850    };
26851    return toBuffer;
26852  }
26853  var toBuffer_1$1;
26854  var hasRequiredToBuffer$1;
26855  function requireToBuffer$1() {
26856    if (hasRequiredToBuffer$1) return toBuffer_1$1;
26857    hasRequiredToBuffer$1 = 1;
26858    var Buffer2 = requireSafeBuffer$1().Buffer;
26859    var toBuffer2 = /* @__PURE__ */ requireToBuffer$2();
26860    var useUint8Array = typeof Uint8Array !== "undefined";
26861    var useArrayBuffer = useUint8Array && typeof ArrayBuffer !== "undefined";
26862    var isView = useArrayBuffer && ArrayBuffer.isView;
26863    toBuffer_1$1 = function(thing, encoding, name) {
26864      if (typeof thing === "string" || Buffer2.isBuffer(thing) || useUint8Array && thing instanceof Uint8Array || isView && isView(thing)) {
26865        return toBuffer2(thing, encoding);
26866      }
26867      throw new TypeError(name + " must be a string, a Buffer, a Uint8Array, or a DataView");
26868    };
26869    return toBuffer_1$1;
26870  }
26871  var sync;
26872  var hasRequiredSync;
26873  function requireSync() {
26874    if (hasRequiredSync) return sync;
26875    hasRequiredSync = 1;
26876    var sizes = {
26877      __proto__: null,
26878      md5: 16,
26879      sha1: 20,
26880      sha224: 28,
26881      sha256: 32,
26882      sha384: 48,
26883      sha512: 64,
26884      "sha512-256": 32,
26885      rmd160: 20,
26886      ripemd160: 20
26887    };
26888    var mapping = {
26889      __proto__: null,
26890      "sha-1": "sha1",
26891      "sha-224": "sha224",
26892      "sha-256": "sha256",
26893      "sha-384": "sha384",
26894      "sha-512": "sha512",
26895      "ripemd-160": "ripemd160"
26896    };
26897    var createHmac2 = requireCreateHmac();
26898    var Buffer2 = requireSafeBuffer$1().Buffer;
26899    var checkParameters = requirePrecondition();
26900    var defaultEncoding = requireDefaultEncoding();
26901    var toBuffer2 = requireToBuffer$1();
26902    function pbkdf22(password, salt, iterations, keylen, digest) {
26903      checkParameters(iterations, keylen);
26904      password = toBuffer2(password, defaultEncoding, "Password");
26905      salt = toBuffer2(salt, defaultEncoding, "Salt");
26906      var lowerDigest = (digest || "sha1").toLowerCase();
26907      var mappedDigest = mapping[lowerDigest] || lowerDigest;
26908      var size = sizes[mappedDigest];

26909      if (typeof size !== "number" || !size) {
26910        throw new TypeError("Digest algorithm not supported: " + digest);
26911      }
26912      var DK = Buffer2.allocUnsafe(keylen);
26913      var block1 = Buffer2.allocUnsafe(salt.length + 4);
26914      salt.copy(block1, 0, 0, salt.length);
26915      var destPos = 0;
26916      var hLen = size;
26917      var l = Math.ceil(keylen / hLen);
26918      for (var i2 = 1; i2 <= l; i2++) {
26919        block1.writeUInt32BE(i2, salt.length);
26920        var T = createHmac2(mappedDigest, password).update(block1).digest();
26921        var U = T;
26922        for (var j = 1; j < iterations; j++) {
26923          U = createHmac2(mappedDigest, password).update(U).digest();
26924          for (var k = 0; k < hLen; k++) {
26925            T[k] ^= U[k];
26926          }
26927        }
26928        T.copy(DK, destPos);
26929        destPos += hLen;
26930      }
26931      return DK;
26932    }
26933    sync = pbkdf22;
26934    return sync;
26935  }
26936  var async;
26937  var hasRequiredAsync$1;
26938  function requireAsync$1() {
26939    if (hasRequiredAsync$1) return async;
26940    hasRequiredAsync$1 = 1;
26941    var Buffer2 = requireSafeBuffer$1().Buffer;
26942    var checkParameters = requirePrecondition();
26943    var defaultEncoding = requireDefaultEncoding();
26944    var sync2 = requireSync();
26945    var toBuffer2 = requireToBuffer$1();
26946    var ZERO_BUF;
26947    var subtle = commonjsGlobal.crypto && commonjsGlobal.crypto.subtle;
26948    var toBrowser = {
26949      sha: "SHA-1",
26950      "sha-1": "SHA-1",
26951      sha1: "SHA-1",
26952      sha256: "SHA-256",
26953      "sha-256": "SHA-256",
26954      sha384: "SHA-384",
26955      "sha-384": "SHA-384",
26956      "sha-512": "SHA-512",
26957      sha512: "SHA-512"
26958    };
26959    var checks = [];
26960    var nextTick;
26961    function getNextTick() {
26962      if (nextTick) {
26963        return nextTick;
26964      }
26965      if (commonjsGlobal.process && commonjsGlobal.process.nextTick) {
26966        nextTick = commonjsGlobal.process.nextTick;
26967      } else if (commonjsGlobal.queueMicrotask) {
26968        nextTick = commonjsGlobal.queueMicrotask;
26969      } else if (commonjsGlobal.setImmediate) {
26970        nextTick = commonjsGlobal.setImmediate;
26971      } else {
26972        nextTick = commonjsGlobal.setTimeout;
26973      }
26974      return nextTick;
26975    }
26976    function browserPbkdf2(password, salt, iterations, length, algo) {
26977      return subtle.importKey("raw", password, { name: "PBKDF2" }, false, ["deriveBits"]).then(function(key2) {
26978        return subtle.deriveBits({
26979          name: "PBKDF2",
26980          salt,
26981          iterations,
26982          hash: {
26983            name: algo
26984          }
26985        }, key2, length << 3);
26986      }).then(function(res) {
26987        return Buffer2.from(res);
26988      });
26989    }
26990    function checkNative(algo) {
26991      if (commonjsGlobal.process && !commonjsGlobal.process.browser) {
26992        return Promise.resolve(false);
26993      }
26994      if (!subtle || !subtle.importKey || !subtle.deriveBits) {
26995        return Promise.resolve(false);
26996      }
26997      if (checks[algo] !== void 0) {
26998        return checks[algo];
26999      }
27000      ZERO_BUF = ZERO_BUF || Buffer2.alloc(8);
27001      var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo).then(
27002        function() {
27003          return true;
27004        },
27005        function() {
27006          return false;
27007        }
27008      );
27009      checks[algo] = prom;
27010      return prom;
27011    }
27012    function resolvePromise(promise, callback) {
27013      promise.then(function(out) {
27014        getNextTick()(function() {
27015          callback(null, out);
27016        });
27017      }, function(e) {
27018        getNextTick()(function() {
27019          callback(e);
27020        });
27021      });
27022    }
27023    async = function(password, salt, iterations, keylen, digest, callback) {
27024      if (typeof digest === "function") {
27025        callback = digest;
27026        digest = void 0;
27027      }
27028      checkParameters(iterations, keylen);
27029      password = toBuffer2(password, defaultEncoding, "Password");
27030      salt = toBuffer2(salt, defaultEncoding, "Salt");
27031      if (typeof callback !== "function") {
27032        throw new Error("No callback provided to pbkdf2");
27033      }
27034      digest = digest || "sha1";
27035      var algo = toBrowser[digest.toLowerCase()];
27036      if (!algo || typeof commonjsGlobal.Promise !== "function") {
27037        getNextTick()(function() {
27038          var out;
27039          try {
27040            out = sync2(password, salt, iterations, keylen, digest);
27041          } catch (e) {
27042            callback(e);
27043            return;
27044          }
27045          callback(null, out);
27046        });
27047        return;
27048      }
27049      resolvePromise(checkNative(algo).then(function(resp) {
27050        if (resp) {
27051          return browserPbkdf2(password, salt, iterations, keylen, algo);
27052        }
27053        return sync2(password, salt, iterations, keylen, digest);
27054      }), callback);
27055    };
27056    return async;
27057  }
27058  var hasRequiredPbkdf2;
27059  function requirePbkdf2() {

27060    if (hasRequiredPbkdf2) return pbkdf2;
27061    hasRequiredPbkdf2 = 1;
27062    var nativeImpl = requireCryptoBrowserify();
27063    var checkParameters = requirePrecondition();
27064    var defaultEncoding = requireDefaultEncoding();
27065    var toBuffer2 = requireToBuffer$1();
27066    function nativePBKDF2(password, salt, iterations, keylen, digest, callback) {
27067      checkParameters(iterations, keylen);
27068      password = toBuffer2(password, defaultEncoding, "Password");
27069      salt = toBuffer2(salt, defaultEncoding, "Salt");
27070      if (typeof digest === "function") {
27071        callback = digest;
27072        digest = "sha1";
27073      }
27074      if (typeof callback !== "function") {
27075        throw new Error("No callback provided to pbkdf2");
27076      }
27077      return nativeImpl.pbkdf2(password, salt, iterations, keylen, digest, callback);
27078    }
27079    function nativePBKDF2Sync(password, salt, iterations, keylen, digest) {
27080      checkParameters(iterations, keylen);
27081      password = toBuffer2(password, defaultEncoding, "Password");
27082      salt = toBuffer2(salt, defaultEncoding, "Salt");
27083      digest = digest || "sha1";
27084      return nativeImpl.pbkdf2Sync(password, salt, iterations, keylen, digest);
27085    }
27086    if (!nativeImpl.pbkdf2Sync || nativeImpl.pbkdf2Sync.toString().indexOf("keylen, digest") === -1) {
27087      pbkdf2.pbkdf2Sync = requireSync();
27088      pbkdf2.pbkdf2 = requireAsync$1();
27089    } else {
27090      pbkdf2.pbkdf2Sync = nativePBKDF2Sync;
27091      pbkdf2.pbkdf2 = nativePBKDF2;
27092    }
27093    return pbkdf2;
27094  }
27095  var browserifyCipher = {};
27096  var hasRequiredBrowserifyCipher;
27097  function requireBrowserifyCipher() {
27098    if (hasRequiredBrowserifyCipher) return browserifyCipher;
27099    hasRequiredBrowserifyCipher = 1;
27100    var crypto2 = requireCryptoBrowserify();
27101    browserifyCipher.createCipher = browserifyCipher.Cipher = crypto2.createCipher;
27102    browserifyCipher.createCipheriv = browserifyCipher.Cipheriv = crypto2.createCipheriv;
27103    browserifyCipher.createDecipher = browserifyCipher.Decipher = crypto2.createDecipher;
27104    browserifyCipher.createDecipheriv = browserifyCipher.Decipheriv = crypto2.createDecipheriv;
27105    browserifyCipher.listCiphers = browserifyCipher.getCiphers = crypto2.getCiphers;
27106    return browserifyCipher;
27107  }
27108  var diffieHellman = {};
27109  var hasRequiredDiffieHellman;
27110  function requireDiffieHellman() {
27111    if (hasRequiredDiffieHellman) return diffieHellman;
27112    hasRequiredDiffieHellman = 1;
27113    var crypto2 = requireCryptoBrowserify();
27114    diffieHellman.DiffieHellmanGroup = crypto2.DiffieHellmanGroup;
27115    diffieHellman.createDiffieHellmanGroup = crypto2.createDiffieHellmanGroup;
27116    diffieHellman.getDiffieHellman = crypto2.getDiffieHellman;
27117    diffieHellman.createDiffieHellman = crypto2.createDiffieHellman;
27118    diffieHellman.DiffieHellman = crypto2.DiffieHellman;
27119    return diffieHellman;
27120  }
27121  var browserifySign = {};
27122  var hasRequiredBrowserifySign;
27123  function requireBrowserifySign() {
27124    if (hasRequiredBrowserifySign) return browserifySign;
27125    hasRequiredBrowserifySign = 1;
27126    var crypto2 = requireCryptoBrowserify();
27127    browserifySign.createSign = crypto2.createSign;
27128    browserifySign.Sign = crypto2.Sign;
27129    browserifySign.createVerify = crypto2.createVerify;
27130    browserifySign.Verify = crypto2.Verify;
27131    return browserifySign;
27132  }
27133  var elliptic = {};
27134  const version = "6.6.1";
27135  const require$$0$1 = {
27136    version
27137  };
27138  var utils$3 = {};
27139  var bn$3 = { exports: {} };
27140  var bn$2 = bn$3.exports;
27141  var hasRequiredBn$1;
27142  function requireBn$1() {

vendor: 53,620 bytes, lines 27143-28652

27143    if (hasRequiredBn$1) return bn$3.exports;
27144    hasRequiredBn$1 = 1;
27145    (function(module) {
27146      (function(module2, exports$12) {
27147        function assert2(val, msg) {
27148          if (!val) throw new Error(msg || "Assertion failed");
27149        }
27150        function inherits2(ctor, superCtor) {
27151          ctor.super_ = superCtor;
27152          var TempCtor = function() {
27153          };
27154          TempCtor.prototype = superCtor.prototype;
27155          ctor.prototype = new TempCtor();
27156          ctor.prototype.constructor = ctor;
27157        }
27158        function BN(number, base2, endian) {
27159          if (BN.isBN(number)) {
27160            return number;
27161          }
27162          this.negative = 0;
27163          this.words = null;
27164          this.length = 0;
27165          this.red = null;
27166          if (number !== null) {
27167            if (base2 === "le" || base2 === "be") {
27168              endian = base2;
27169              base2 = 10;
27170            }
27171            this._init(number || 0, base2 || 10, endian || "be");
27172          }
27173        }
27174        if (typeof module2 === "object") {
27175          module2.exports = BN;
27176        } else {
27177          exports$12.BN = BN;
27178        }
27179        BN.BN = BN;
27180        BN.wordSize = 26;
27181        var Buffer2;
27182        try {
27183          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
27184            Buffer2 = window.Buffer;
27185          } else {
27186            Buffer2 = requireDist().Buffer;
27187          }
27188        } catch (e) {
27189        }
27190        BN.isBN = function isBN(num) {
27191          if (num instanceof BN) {
27192            return true;
27193          }
27194          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
27195        };
27196        BN.max = function max2(left, right) {
27197          if (left.cmp(right) > 0) return left;
27198          return right;
27199        };
27200        BN.min = function min2(left, right) {
27201          if (left.cmp(right) < 0) return left;
27202          return right;
27203        };
27204        BN.prototype._init = function init(number, base2, endian) {
27205          if (typeof number === "number") {
27206            return this._initNumber(number, base2, endian);
27207          }
27208          if (typeof number === "object") {
27209            return this._initArray(number, base2, endian);
27210          }
27211          if (base2 === "hex") {
27212            base2 = 16;
27213          }
27214          assert2(base2 === (base2 | 0) && base2 >= 2 && base2 <= 36);
27215          number = number.toString().replace(/\s+/g, "");
27216          var start = 0;
27217          if (number[0] === "-") {
27218            start++;
27219            this.negative = 1;
27220          }
27221          if (start < number.length) {
27222            if (base2 === 16) {
27223              this._parseHex(number, start, endian);
27224            } else {
27225              this._parseBase(number, base2, start);
27226              if (endian === "le") {
27227                this._initArray(this.toArray(), base2, endian);
27228              }
27229            }
27230          }
27231        };
27232        BN.prototype._initNumber = function _initNumber(number, base2, endian) {
27233          if (number < 0) {
27234            this.negative = 1;
27235            number = -number;
27236          }
27237          if (number < 67108864) {
27238            this.words = [number & 67108863];
27239            this.length = 1;
27240          } else if (number < 4503599627370496) {
27241            this.words = [
27242              number & 67108863,
27243              number / 67108864 & 67108863
27244            ];
27245            this.length = 2;
27246          } else {
27247            assert2(number < 9007199254740992);
27248            this.words = [
27249              number & 67108863,
27250              number / 67108864 & 67108863,
27251              1
27252            ];
27253            this.length = 3;
27254          }
27255          if (endian !== "le") return;
27256          this._initArray(this.toArray(), base2, endian);
27257        };
27258        BN.prototype._initArray = function _initArray(number, base2, endian) {
27259          assert2(typeof number.length === "number");
27260          if (number.length <= 0) {
27261            this.words = [0];
27262            this.length = 1;
27263            return this;
27264          }
27265          this.length = Math.ceil(number.length / 3);
27266          this.words = new Array(this.length);
27267          for (var i2 = 0; i2 < this.length; i2++) {
27268            this.words[i2] = 0;
27269          }
27270          var j, w;
27271          var off = 0;
27272          if (endian === "be") {
27273            for (i2 = number.length - 1, j = 0; i2 >= 0; i2 -= 3) {
27274              w = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16;
27275              this.words[j] |= w << off & 67108863;
27276              this.words[j + 1] = w >>> 26 - off & 67108863;
27277              off += 24;
27278              if (off >= 26) {
27279                off -= 26;
27280                j++;
27281              }
27282            }
27283          } else if (endian === "le") {
27284            for (i2 = 0, j = 0; i2 < number.length; i2 += 3) {
27285              w = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16;
27286              this.words[j] |= w << off & 67108863;
27287              this.words[j + 1] = w >>> 26 - off & 67108863;
27288              off += 24;
27289              if (off >= 26) {
27290                off -= 26;
27291                j++;
27292              }
27293            }
27294          }
27295          return this.strip();
27296        };
27297        function parseHex4Bits(string, index) {
27298          var c = string.charCodeAt(index);
27299          if (c >= 65 && c <= 70) {
27300            return c - 55;
27301          } else if (c >= 97 && c <= 102) {
27302            return c - 87;
27303          } else {
27304            return c - 48 & 15;
27305          }
27306        }
27307        function parseHexByte(string, lowerBound, index) {
27308          var r = parseHex4Bits(string, index);
27309          if (index - 1 >= lowerBound) {
27310            r |= parseHex4Bits(string, index - 1) << 4;
27311          }
27312          return r;
27313        }
27314        BN.prototype._parseHex = function _parseHex(number, start, endian) {
27315          this.length = Math.ceil((number.length - start) / 6);
27316          this.words = new Array(this.length);
27317          for (var i2 = 0; i2 < this.length; i2++) {
27318            this.words[i2] = 0;
27319          }
27320          var off = 0;
27321          var j = 0;
27322          var w;
27323          if (endian === "be") {
27324            for (i2 = number.length - 1; i2 >= start; i2 -= 2) {
27325              w = parseHexByte(number, start, i2) << off;
27326              this.words[j] |= w & 67108863;
27327              if (off >= 18) {
27328                off -= 18;
27329                j += 1;
27330                this.words[j] |= w >>> 26;
27331              } else {
27332                off += 8;
27333              }
27334            }
27335          } else {
27336            var parseLength = number.length - start;
27337            for (i2 = parseLength % 2 === 0 ? start + 1 : start; i2 < number.length; i2 += 2) {
27338              w = parseHexByte(number, start, i2) << off;
27339              this.words[j] |= w & 67108863;
27340              if (off >= 18) {
27341                off -= 18;
27342                j += 1;
27343                this.words[j] |= w >>> 26;
27344              } else {
27345                off += 8;
27346              }
27347            }
27348          }
27349          this.strip();
27350        };
27351        function parseBase(str, start, end, mul) {
27352          var r = 0;
27353          var len2 = Math.min(str.length, end);
27354          for (var i2 = start; i2 < len2; i2++) {
27355            var c = str.charCodeAt(i2) - 48;
27356            r *= mul;
27357            if (c >= 49) {
27358              r += c - 49 + 10;
27359            } else if (c >= 17) {
27360              r += c - 17 + 10;
27361            } else {
27362              r += c;
27363            }
27364          }
27365          return r;
27366        }
27367        BN.prototype._parseBase = function _parseBase(number, base2, start) {
27368          this.words = [0];
27369          this.length = 1;
27370          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base2) {
27371            limbLen++;
27372          }
27373          limbLen--;
27374          limbPow = limbPow / base2 | 0;
27375          var total = number.length - start;
27376          var mod = total % limbLen;
27377          var end = Math.min(total, total - mod) + start;
27378          var word = 0;
27379          for (var i2 = start; i2 < end; i2 += limbLen) {
27380            word = parseBase(number, i2, i2 + limbLen, base2);
27381            this.imuln(limbPow);
27382            if (this.words[0] + word < 67108864) {
27383              this.words[0] += word;
27384            } else {
27385              this._iaddn(word);
27386            }
27387          }
27388          if (mod !== 0) {
27389            var pow2 = 1;
27390            word = parseBase(number, i2, number.length, base2);
27391            for (i2 = 0; i2 < mod; i2++) {
27392              pow2 *= base2;
27393            }
27394            this.imuln(pow2);
27395            if (this.words[0] + word < 67108864) {
27396              this.words[0] += word;
27397            } else {
27398              this._iaddn(word);
27399            }
27400          }
27401          this.strip();
27402        };
27403        BN.prototype.copy = function copy(dest) {
27404          dest.words = new Array(this.length);
27405          for (var i2 = 0; i2 < this.length; i2++) {
27406            dest.words[i2] = this.words[i2];
27407          }
27408          dest.length = this.length;
27409          dest.negative = this.negative;
27410          dest.red = this.red;
27411        };
27412        BN.prototype.clone = function clone() {
27413          var r = new BN(null);
27414          this.copy(r);
27415          return r;
27416        };
27417        BN.prototype._expand = function _expand(size) {
27418          while (this.length < size) {
27419            this.words[this.length++] = 0;
27420          }
27421          return this;
27422        };
27423        BN.prototype.strip = function strip() {
27424          while (this.length > 1 && this.words[this.length - 1] === 0) {
27425            this.length--;
27426          }
27427          return this._normSign();
27428        };
27429        BN.prototype._normSign = function _normSign() {
27430          if (this.length === 1 && this.words[0] === 0) {
27431            this.negative = 0;
27432          }
27433          return this;
27434        };
27435        BN.prototype.inspect = function inspect() {
27436          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
27437        };
27438        var zeros = [
27439          "",
27440          "0",
27441          "00",
27442          "000",
27443          "0000",
27444          "00000",
27445          "000000",
27446          "0000000",
27447          "00000000",
27448          "000000000",
27449          "0000000000",
27450          "00000000000",
27451          "000000000000",
27452          "0000000000000",
27453          "00000000000000",
27454          "000000000000000",
27455          "0000000000000000",
27456          "00000000000000000",
27457          "000000000000000000",
27458          "0000000000000000000",
27459          "00000000000000000000",
27460          "000000000000000000000",
27461          "0000000000000000000000",
27462          "00000000000000000000000",
27463          "000000000000000000000000",
27464          "0000000000000000000000000"
27465        ];
27466        var groupSizes = [
27467          0,
27468          0,
27469          25,
27470          16,
27471          12,
27472          11,
27473          10,
27474          9,
27475          8,
27476          8,
27477          7,
27478          7,
27479          7,
27480          7,
27481          6,
27482          6,
27483          6,
27484          6,
27485          6,
27486          6,
27487          6,
27488          5,
27489          5,
27490          5,
27491          5,
27492          5,
27493          5,
27494          5,
27495          5,
27496          5,
27497          5,
27498          5,
27499          5,
27500          5,
27501          5,
27502          5,
27503          5
27504        ];
27505        var groupBases = [
27506          0,
27507          0,
27508          33554432,
27509          43046721,
27510          16777216,
27511          48828125,
27512          60466176,
27513          40353607,
27514          16777216,
27515          43046721,
27516          1e7,
27517          19487171,
27518          35831808,
27519          62748517,
27520          7529536,
27521          11390625,
27522          16777216,
27523          24137569,
27524          34012224,
27525          47045881,
27526          64e6,
27527          4084101,
27528          5153632,
27529          6436343,
27530          7962624,
27531          9765625,
27532          11881376,
27533          14348907,
27534          17210368,
27535          20511149,
27536          243e5,
27537          28629151,
27538          33554432,
27539          39135393,
27540          45435424,
27541          52521875,
27542          60466176
27543        ];
27544        BN.prototype.toString = function toString2(base2, padding) {
27545          base2 = base2 || 10;
27546          padding = padding | 0 || 1;
27547          var out;
27548          if (base2 === 16 || base2 === "hex") {
27549            out = "";
27550            var off = 0;
27551            var carry = 0;
27552            for (var i2 = 0; i2 < this.length; i2++) {
27553              var w = this.words[i2];
27554              var word = ((w << off | carry) & 16777215).toString(16);
27555              carry = w >>> 24 - off & 16777215;
27556              off += 2;
27557              if (off >= 26) {
27558                off -= 26;
27559                i2--;
27560              }
27561              if (carry !== 0 || i2 !== this.length - 1) {
27562                out = zeros[6 - word.length] + word + out;
27563              } else {
27564                out = word + out;
27565              }
27566            }
27567            if (carry !== 0) {
27568              out = carry.toString(16) + out;
27569            }
27570            while (out.length % padding !== 0) {
27571              out = "0" + out;
27572            }
27573            if (this.negative !== 0) {
27574              out = "-" + out;
27575            }
27576            return out;
27577          }
27578          if (base2 === (base2 | 0) && base2 >= 2 && base2 <= 36) {
27579            var groupSize = groupSizes[base2];
27580            var groupBase = groupBases[base2];
27581            out = "";
27582            var c = this.clone();
27583            c.negative = 0;
27584            while (!c.isZero()) {
27585              var r = c.modn(groupBase).toString(base2);
27586              c = c.idivn(groupBase);
27587              if (!c.isZero()) {
27588                out = zeros[groupSize - r.length] + r + out;
27589              } else {
27590                out = r + out;
27591              }
27592            }
27593            if (this.isZero()) {
27594              out = "0" + out;
27595            }
27596            while (out.length % padding !== 0) {
27597              out = "0" + out;
27598            }
27599            if (this.negative !== 0) {
27600              out = "-" + out;
27601            }
27602            return out;
27603          }
27604          assert2(false, "Base should be between 2 and 36");
27605        };
27606        BN.prototype.toNumber = function toNumber() {
27607          var ret = this.words[0];
27608          if (this.length === 2) {
27609            ret += this.words[1] * 67108864;
27610          } else if (this.length === 3 && this.words[2] === 1) {
27611            ret += 4503599627370496 + this.words[1] * 67108864;
27612          } else if (this.length > 2) {
27613            assert2(false, "Number can only safely store up to 53 bits");
27614          }
27615          return this.negative !== 0 ? -ret : ret;
27616        };
27617        BN.prototype.toJSON = function toJSON() {
27618          return this.toString(16);
27619        };
27620        BN.prototype.toBuffer = function toBuffer2(endian, length) {
27621          assert2(typeof Buffer2 !== "undefined");
27622          return this.toArrayLike(Buffer2, endian, length);
27623        };
27624        BN.prototype.toArray = function toArray2(endian, length) {
27625          return this.toArrayLike(Array, endian, length);
27626        };
27627        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
27628          var byteLength2 = this.byteLength();
27629          var reqLength = length || Math.max(1, byteLength2);
27630          assert2(byteLength2 <= reqLength, "byte array longer than desired length");
27631          assert2(reqLength > 0, "Requested array length <= 0");
27632          this.strip();
27633          var littleEndian = endian === "le";
27634          var res = new ArrayType(reqLength);
27635          var b, i2;
27636          var q = this.clone();
27637          if (!littleEndian) {
27638            for (i2 = 0; i2 < reqLength - byteLength2; i2++) {
27639              res[i2] = 0;
27640            }
27641            for (i2 = 0; !q.isZero(); i2++) {
27642              b = q.andln(255);
27643              q.iushrn(8);
27644              res[reqLength - i2 - 1] = b;
27645            }
27646          } else {
27647            for (i2 = 0; !q.isZero(); i2++) {
27648              b = q.andln(255);
27649              q.iushrn(8);
27650              res[i2] = b;
27651            }
27652            for (; i2 < reqLength; i2++) {
27653              res[i2] = 0;
27654            }
27655          }
27656          return res;
27657        };
27658        if (Math.clz32) {
27659          BN.prototype._countBits = function _countBits(w) {
27660            return 32 - Math.clz32(w);
27661          };
27662        } else {
27663          BN.prototype._countBits = function _countBits(w) {
27664            var t = w;
27665            var r = 0;
27666            if (t >= 4096) {
27667              r += 13;
27668              t >>>= 13;
27669            }
27670            if (t >= 64) {
27671              r += 7;
27672              t >>>= 7;
27673            }
27674            if (t >= 8) {
27675              r += 4;
27676              t >>>= 4;
27677            }
27678            if (t >= 2) {
27679              r += 2;
27680              t >>>= 2;
27681            }
27682            return r + t;
27683          };
27684        }
27685        BN.prototype._zeroBits = function _zeroBits(w) {
27686          if (w === 0) return 26;
27687          var t = w;
27688          var r = 0;
27689          if ((t & 8191) === 0) {
27690            r += 13;
27691            t >>>= 13;
27692          }
27693          if ((t & 127) === 0) {
27694            r += 7;
27695            t >>>= 7;
27696          }
27697          if ((t & 15) === 0) {
27698            r += 4;
27699            t >>>= 4;
27700          }
27701          if ((t & 3) === 0) {
27702            r += 2;
27703            t >>>= 2;
27704          }
27705          if ((t & 1) === 0) {
27706            r++;
27707          }
27708          return r;
27709        };
27710        BN.prototype.bitLength = function bitLength() {
27711          var w = this.words[this.length - 1];
27712          var hi = this._countBits(w);
27713          return (this.length - 1) * 26 + hi;
27714        };
27715        function toBitArray(num) {
27716          var w = new Array(num.bitLength());
27717          for (var bit = 0; bit < w.length; bit++) {
27718            var off = bit / 26 | 0;
27719            var wbit = bit % 26;
27720            w[bit] = (num.words[off] & 1 << wbit) >>> wbit;
27721          }
27722          return w;
27723        }
27724        BN.prototype.zeroBits = function zeroBits() {
27725          if (this.isZero()) return 0;
27726          var r = 0;
27727          for (var i2 = 0; i2 < this.length; i2++) {
27728            var b = this._zeroBits(this.words[i2]);
27729            r += b;
27730            if (b !== 26) break;
27731          }
27732          return r;
27733        };
27734        BN.prototype.byteLength = function byteLength2() {
27735          return Math.ceil(this.bitLength() / 8);
27736        };
27737        BN.prototype.toTwos = function toTwos(width) {
27738          if (this.negative !== 0) {
27739            return this.abs().inotn(width).iaddn(1);
27740          }
27741          return this.clone();
27742        };
27743        BN.prototype.fromTwos = function fromTwos(width) {
27744          if (this.testn(width - 1)) {
27745            return this.notn(width).iaddn(1).ineg();
27746          }
27747          return this.clone();
27748        };
27749        BN.prototype.isNeg = function isNeg() {
27750          return this.negative !== 0;
27751        };
27752        BN.prototype.neg = function neg() {
27753          return this.clone().ineg();
27754        };
27755        BN.prototype.ineg = function ineg() {
27756          if (!this.isZero()) {
27757            this.negative ^= 1;
27758          }
27759          return this;
27760        };
27761        BN.prototype.iuor = function iuor(num) {
27762          while (this.length < num.length) {
27763            this.words[this.length++] = 0;
27764          }
27765          for (var i2 = 0; i2 < num.length; i2++) {
27766            this.words[i2] = this.words[i2] | num.words[i2];
27767          }
27768          return this.strip();
27769        };
27770        BN.prototype.ior = function ior(num) {
27771          assert2((this.negative | num.negative) === 0);
27772          return this.iuor(num);
27773        };
27774        BN.prototype.or = function or(num) {
27775          if (this.length > num.length) return this.clone().ior(num);
27776          return num.clone().ior(this);
27777        };
27778        BN.prototype.uor = function uor(num) {
27779          if (this.length > num.length) return this.clone().iuor(num);
27780          return num.clone().iuor(this);
27781        };
27782        BN.prototype.iuand = function iuand(num) {
27783          var b;
27784          if (this.length > num.length) {
27785            b = num;
27786          } else {
27787            b = this;
27788          }
27789          for (var i2 = 0; i2 < b.length; i2++) {
27790            this.words[i2] = this.words[i2] & num.words[i2];
27791          }
27792          this.length = b.length;
27793          return this.strip();
27794        };
27795        BN.prototype.iand = function iand(num) {
27796          assert2((this.negative | num.negative) === 0);
27797          return this.iuand(num);
27798        };
27799        BN.prototype.and = function and(num) {
27800          if (this.length > num.length) return this.clone().iand(num);
27801          return num.clone().iand(this);
27802        };
27803        BN.prototype.uand = function uand(num) {
27804          if (this.length > num.length) return this.clone().iuand(num);
27805          return num.clone().iuand(this);
27806        };
27807        BN.prototype.iuxor = function iuxor(num) {
27808          var a;
27809          var b;
27810          if (this.length > num.length) {
27811            a = this;
27812            b = num;
27813          } else {
27814            a = num;
27815            b = this;
27816          }
27817          for (var i2 = 0; i2 < b.length; i2++) {
27818            this.words[i2] = a.words[i2] ^ b.words[i2];
27819          }
27820          if (this !== a) {
27821            for (; i2 < a.length; i2++) {
27822              this.words[i2] = a.words[i2];
27823            }
27824          }
27825          this.length = a.length;
27826          return this.strip();
27827        };
27828        BN.prototype.ixor = function ixor(num) {
27829          assert2((this.negative | num.negative) === 0);
27830          return this.iuxor(num);
27831        };
27832        BN.prototype.xor = function xor2(num) {
27833          if (this.length > num.length) return this.clone().ixor(num);
27834          return num.clone().ixor(this);
27835        };
27836        BN.prototype.uxor = function uxor(num) {
27837          if (this.length > num.length) return this.clone().iuxor(num);
27838          return num.clone().iuxor(this);
27839        };
27840        BN.prototype.inotn = function inotn(width) {
27841          assert2(typeof width === "number" && width >= 0);
27842          var bytesNeeded = Math.ceil(width / 26) | 0;
27843          var bitsLeft = width % 26;
27844          this._expand(bytesNeeded);
27845          if (bitsLeft > 0) {
27846            bytesNeeded--;
27847          }
27848          for (var i2 = 0; i2 < bytesNeeded; i2++) {
27849            this.words[i2] = ~this.words[i2] & 67108863;
27850          }
27851          if (bitsLeft > 0) {
27852            this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft;
27853          }
27854          return this.strip();
27855        };
27856        BN.prototype.notn = function notn(width) {
27857          return this.clone().inotn(width);
27858        };
27859        BN.prototype.setn = function setn(bit, val) {
27860          assert2(typeof bit === "number" && bit >= 0);
27861          var off = bit / 26 | 0;
27862          var wbit = bit % 26;
27863          this._expand(off + 1);
27864          if (val) {
27865            this.words[off] = this.words[off] | 1 << wbit;
27866          } else {
27867            this.words[off] = this.words[off] & ~(1 << wbit);
27868          }
27869          return this.strip();
27870        };
27871        BN.prototype.iadd = function iadd(num) {
27872          var r;
27873          if (this.negative !== 0 && num.negative === 0) {
27874            this.negative = 0;
27875            r = this.isub(num);
27876            this.negative ^= 1;
27877            return this._normSign();
27878          } else if (this.negative === 0 && num.negative !== 0) {
27879            num.negative = 0;
27880            r = this.isub(num);
27881            num.negative = 1;
27882            return r._normSign();
27883          }
27884          var a, b;
27885          if (this.length > num.length) {
27886            a = this;
27887            b = num;
27888          } else {
27889            a = num;
27890            b = this;
27891          }
27892          var carry = 0;
27893          for (var i2 = 0; i2 < b.length; i2++) {
27894            r = (a.words[i2] | 0) + (b.words[i2] | 0) + carry;
27895            this.words[i2] = r & 67108863;
27896            carry = r >>> 26;
27897          }
27898          for (; carry !== 0 && i2 < a.length; i2++) {
27899            r = (a.words[i2] | 0) + carry;
27900            this.words[i2] = r & 67108863;
27901            carry = r >>> 26;
27902          }
27903          this.length = a.length;
27904          if (carry !== 0) {
27905            this.words[this.length] = carry;
27906            this.length++;
27907          } else if (a !== this) {
27908            for (; i2 < a.length; i2++) {
27909              this.words[i2] = a.words[i2];
27910            }
27911          }
27912          return this;
27913        };
27914        BN.prototype.add = function add(num) {
27915          var res;
27916          if (num.negative !== 0 && this.negative === 0) {
27917            num.negative = 0;
27918            res = this.sub(num);
27919            num.negative ^= 1;
27920            return res;
27921          } else if (num.negative === 0 && this.negative !== 0) {
27922            this.negative = 0;
27923            res = num.sub(this);
27924            this.negative = 1;
27925            return res;
27926          }
27927          if (this.length > num.length) return this.clone().iadd(num);
27928          return num.clone().iadd(this);
27929        };
27930        BN.prototype.isub = function isub(num) {
27931          if (num.negative !== 0) {
27932            num.negative = 0;
27933            var r = this.iadd(num);
27934            num.negative = 1;
27935            return r._normSign();
27936          } else if (this.negative !== 0) {
27937            this.negative = 0;
27938            this.iadd(num);
27939            this.negative = 1;
27940            return this._normSign();
27941          }
27942          var cmp = this.cmp(num);
27943          if (cmp === 0) {
27944            this.negative = 0;
27945            this.length = 1;
27946            this.words[0] = 0;
27947            return this;
27948          }
27949          var a, b;
27950          if (cmp > 0) {
27951            a = this;
27952            b = num;
27953          } else {
27954            a = num;
27955            b = this;
27956          }
27957          var carry = 0;
27958          for (var i2 = 0; i2 < b.length; i2++) {
27959            r = (a.words[i2] | 0) - (b.words[i2] | 0) + carry;
27960            carry = r >> 26;
27961            this.words[i2] = r & 67108863;
27962          }
27963          for (; carry !== 0 && i2 < a.length; i2++) {
27964            r = (a.words[i2] | 0) + carry;
27965            carry = r >> 26;
27966            this.words[i2] = r & 67108863;
27967          }
27968          if (carry === 0 && i2 < a.length && a !== this) {
27969            for (; i2 < a.length; i2++) {
27970              this.words[i2] = a.words[i2];
27971            }
27972          }
27973          this.length = Math.max(this.length, i2);
27974          if (a !== this) {
27975            this.negative = 1;
27976          }
27977          return this.strip();
27978        };
27979        BN.prototype.sub = function sub(num) {
27980          return this.clone().isub(num);
27981        };
27982        function smallMulTo(self2, num, out) {
27983          out.negative = num.negative ^ self2.negative;
27984          var len2 = self2.length + num.length | 0;
27985          out.length = len2;
27986          len2 = len2 - 1 | 0;
27987          var a = self2.words[0] | 0;
27988          var b = num.words[0] | 0;
27989          var r = a * b;
27990          var lo = r & 67108863;
27991          var carry = r / 67108864 | 0;
27992          out.words[0] = lo;
27993          for (var k = 1; k < len2; k++) {
27994            var ncarry = carry >>> 26;
27995            var rword = carry & 67108863;
27996            var maxJ = Math.min(k, num.length - 1);
27997            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
27998              var i2 = k - j | 0;
27999              a = self2.words[i2] | 0;
28000              b = num.words[j] | 0;
28001              r = a * b + rword;
28002              ncarry += r / 67108864 | 0;
28003              rword = r & 67108863;
28004            }
28005            out.words[k] = rword | 0;
28006            carry = ncarry | 0;
28007          }
28008          if (carry !== 0) {
28009            out.words[k] = carry | 0;
28010          } else {
28011            out.length--;
28012          }
28013          return out.strip();
28014        }
28015        var comb10MulTo = function comb10MulTo2(self2, num, out) {
28016          var a = self2.words;
28017          var b = num.words;
28018          var o = out.words;
28019          var c = 0;
28020          var lo;
28021          var mid;
28022          var hi;
28023          var a0 = a[0] | 0;
28024          var al0 = a0 & 8191;
28025          var ah0 = a0 >>> 13;
28026          var a1 = a[1] | 0;
28027          var al1 = a1 & 8191;
28028          var ah1 = a1 >>> 13;
28029          var a2 = a[2] | 0;
28030          var al2 = a2 & 8191;
28031          var ah2 = a2 >>> 13;
28032          var a3 = a[3] | 0;
28033          var al3 = a3 & 8191;
28034          var ah3 = a3 >>> 13;
28035          var a4 = a[4] | 0;
28036          var al4 = a4 & 8191;
28037          var ah4 = a4 >>> 13;
28038          var a5 = a[5] | 0;
28039          var al5 = a5 & 8191;
28040          var ah5 = a5 >>> 13;
28041          var a6 = a[6] | 0;
28042          var al6 = a6 & 8191;
28043          var ah6 = a6 >>> 13;
28044          var a7 = a[7] | 0;
28045          var al7 = a7 & 8191;
28046          var ah7 = a7 >>> 13;
28047          var a8 = a[8] | 0;
28048          var al8 = a8 & 8191;
28049          var ah8 = a8 >>> 13;
28050          var a9 = a[9] | 0;
28051          var al9 = a9 & 8191;
28052          var ah9 = a9 >>> 13;
28053          var b0 = b[0] | 0;
28054          var bl0 = b0 & 8191;
28055          var bh0 = b0 >>> 13;
28056          var b1 = b[1] | 0;
28057          var bl1 = b1 & 8191;
28058          var bh1 = b1 >>> 13;
28059          var b2 = b[2] | 0;
28060          var bl2 = b2 & 8191;
28061          var bh2 = b2 >>> 13;
28062          var b3 = b[3] | 0;
28063          var bl3 = b3 & 8191;
28064          var bh3 = b3 >>> 13;
28065          var b4 = b[4] | 0;
28066          var bl4 = b4 & 8191;
28067          var bh4 = b4 >>> 13;
28068          var b5 = b[5] | 0;
28069          var bl5 = b5 & 8191;
28070          var bh5 = b5 >>> 13;
28071          var b6 = b[6] | 0;
28072          var bl6 = b6 & 8191;
28073          var bh6 = b6 >>> 13;
28074          var b7 = b[7] | 0;
28075          var bl7 = b7 & 8191;
28076          var bh7 = b7 >>> 13;
28077          var b8 = b[8] | 0;
28078          var bl8 = b8 & 8191;
28079          var bh8 = b8 >>> 13;
28080          var b9 = b[9] | 0;
28081          var bl9 = b9 & 8191;
28082          var bh9 = b9 >>> 13;
28083          out.negative = self2.negative ^ num.negative;
28084          out.length = 19;
28085          lo = Math.imul(al0, bl0);
28086          mid = Math.imul(al0, bh0);
28087          mid = mid + Math.imul(ah0, bl0) | 0;
28088          hi = Math.imul(ah0, bh0);
28089          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28090          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
28091          w0 &= 67108863;
28092          lo = Math.imul(al1, bl0);
28093          mid = Math.imul(al1, bh0);
28094          mid = mid + Math.imul(ah1, bl0) | 0;
28095          hi = Math.imul(ah1, bh0);
28096          lo = lo + Math.imul(al0, bl1) | 0;
28097          mid = mid + Math.imul(al0, bh1) | 0;
28098          mid = mid + Math.imul(ah0, bl1) | 0;
28099          hi = hi + Math.imul(ah0, bh1) | 0;
28100          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28101          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
28102          w1 &= 67108863;
28103          lo = Math.imul(al2, bl0);
28104          mid = Math.imul(al2, bh0);
28105          mid = mid + Math.imul(ah2, bl0) | 0;
28106          hi = Math.imul(ah2, bh0);
28107          lo = lo + Math.imul(al1, bl1) | 0;
28108          mid = mid + Math.imul(al1, bh1) | 0;
28109          mid = mid + Math.imul(ah1, bl1) | 0;
28110          hi = hi + Math.imul(ah1, bh1) | 0;
28111          lo = lo + Math.imul(al0, bl2) | 0;
28112          mid = mid + Math.imul(al0, bh2) | 0;
28113          mid = mid + Math.imul(ah0, bl2) | 0;
28114          hi = hi + Math.imul(ah0, bh2) | 0;
28115          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28116          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
28117          w2 &= 67108863;
28118          lo = Math.imul(al3, bl0);
28119          mid = Math.imul(al3, bh0);
28120          mid = mid + Math.imul(ah3, bl0) | 0;
28121          hi = Math.imul(ah3, bh0);
28122          lo = lo + Math.imul(al2, bl1) | 0;
28123          mid = mid + Math.imul(al2, bh1) | 0;
28124          mid = mid + Math.imul(ah2, bl1) | 0;
28125          hi = hi + Math.imul(ah2, bh1) | 0;
28126          lo = lo + Math.imul(al1, bl2) | 0;
28127          mid = mid + Math.imul(al1, bh2) | 0;
28128          mid = mid + Math.imul(ah1, bl2) | 0;
28129          hi = hi + Math.imul(ah1, bh2) | 0;
28130          lo = lo + Math.imul(al0, bl3) | 0;
28131          mid = mid + Math.imul(al0, bh3) | 0;
28132          mid = mid + Math.imul(ah0, bl3) | 0;
28133          hi = hi + Math.imul(ah0, bh3) | 0;
28134          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28135          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
28136          w3 &= 67108863;
28137          lo = Math.imul(al4, bl0);
28138          mid = Math.imul(al4, bh0);
28139          mid = mid + Math.imul(ah4, bl0) | 0;
28140          hi = Math.imul(ah4, bh0);
28141          lo = lo + Math.imul(al3, bl1) | 0;
28142          mid = mid + Math.imul(al3, bh1) | 0;
28143          mid = mid + Math.imul(ah3, bl1) | 0;
28144          hi = hi + Math.imul(ah3, bh1) | 0;
28145          lo = lo + Math.imul(al2, bl2) | 0;
28146          mid = mid + Math.imul(al2, bh2) | 0;
28147          mid = mid + Math.imul(ah2, bl2) | 0;
28148          hi = hi + Math.imul(ah2, bh2) | 0;
28149          lo = lo + Math.imul(al1, bl3) | 0;
28150          mid = mid + Math.imul(al1, bh3) | 0;
28151          mid = mid + Math.imul(ah1, bl3) | 0;
28152          hi = hi + Math.imul(ah1, bh3) | 0;
28153          lo = lo + Math.imul(al0, bl4) | 0;
28154          mid = mid + Math.imul(al0, bh4) | 0;
28155          mid = mid + Math.imul(ah0, bl4) | 0;
28156          hi = hi + Math.imul(ah0, bh4) | 0;
28157          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28158          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
28159          w4 &= 67108863;
28160          lo = Math.imul(al5, bl0);
28161          mid = Math.imul(al5, bh0);
28162          mid = mid + Math.imul(ah5, bl0) | 0;
28163          hi = Math.imul(ah5, bh0);
28164          lo = lo + Math.imul(al4, bl1) | 0;
28165          mid = mid + Math.imul(al4, bh1) | 0;
28166          mid = mid + Math.imul(ah4, bl1) | 0;
28167          hi = hi + Math.imul(ah4, bh1) | 0;
28168          lo = lo + Math.imul(al3, bl2) | 0;
28169          mid = mid + Math.imul(al3, bh2) | 0;
28170          mid = mid + Math.imul(ah3, bl2) | 0;
28171          hi = hi + Math.imul(ah3, bh2) | 0;
28172          lo = lo + Math.imul(al2, bl3) | 0;
28173          mid = mid + Math.imul(al2, bh3) | 0;
28174          mid = mid + Math.imul(ah2, bl3) | 0;
28175          hi = hi + Math.imul(ah2, bh3) | 0;
28176          lo = lo + Math.imul(al1, bl4) | 0;
28177          mid = mid + Math.imul(al1, bh4) | 0;
28178          mid = mid + Math.imul(ah1, bl4) | 0;
28179          hi = hi + Math.imul(ah1, bh4) | 0;
28180          lo = lo + Math.imul(al0, bl5) | 0;
28181          mid = mid + Math.imul(al0, bh5) | 0;
28182          mid = mid + Math.imul(ah0, bl5) | 0;
28183          hi = hi + Math.imul(ah0, bh5) | 0;
28184          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28185          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
28186          w5 &= 67108863;
28187          lo = Math.imul(al6, bl0);
28188          mid = Math.imul(al6, bh0);
28189          mid = mid + Math.imul(ah6, bl0) | 0;
28190          hi = Math.imul(ah6, bh0);
28191          lo = lo + Math.imul(al5, bl1) | 0;
28192          mid = mid + Math.imul(al5, bh1) | 0;
28193          mid = mid + Math.imul(ah5, bl1) | 0;
28194          hi = hi + Math.imul(ah5, bh1) | 0;
28195          lo = lo + Math.imul(al4, bl2) | 0;
28196          mid = mid + Math.imul(al4, bh2) | 0;
28197          mid = mid + Math.imul(ah4, bl2) | 0;
28198          hi = hi + Math.imul(ah4, bh2) | 0;
28199          lo = lo + Math.imul(al3, bl3) | 0;
28200          mid = mid + Math.imul(al3, bh3) | 0;
28201          mid = mid + Math.imul(ah3, bl3) | 0;
28202          hi = hi + Math.imul(ah3, bh3) | 0;
28203          lo = lo + Math.imul(al2, bl4) | 0;
28204          mid = mid + Math.imul(al2, bh4) | 0;
28205          mid = mid + Math.imul(ah2, bl4) | 0;
28206          hi = hi + Math.imul(ah2, bh4) | 0;
28207          lo = lo + Math.imul(al1, bl5) | 0;
28208          mid = mid + Math.imul(al1, bh5) | 0;
28209          mid = mid + Math.imul(ah1, bl5) | 0;
28210          hi = hi + Math.imul(ah1, bh5) | 0;
28211          lo = lo + Math.imul(al0, bl6) | 0;
28212          mid = mid + Math.imul(al0, bh6) | 0;
28213          mid = mid + Math.imul(ah0, bl6) | 0;
28214          hi = hi + Math.imul(ah0, bh6) | 0;
28215          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28216          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
28217          w6 &= 67108863;
28218          lo = Math.imul(al7, bl0);
28219          mid = Math.imul(al7, bh0);
28220          mid = mid + Math.imul(ah7, bl0) | 0;
28221          hi = Math.imul(ah7, bh0);
28222          lo = lo + Math.imul(al6, bl1) | 0;
28223          mid = mid + Math.imul(al6, bh1) | 0;
28224          mid = mid + Math.imul(ah6, bl1) | 0;
28225          hi = hi + Math.imul(ah6, bh1) | 0;
28226          lo = lo + Math.imul(al5, bl2) | 0;
28227          mid = mid + Math.imul(al5, bh2) | 0;
28228          mid = mid + Math.imul(ah5, bl2) | 0;
28229          hi = hi + Math.imul(ah5, bh2) | 0;
28230          lo = lo + Math.imul(al4, bl3) | 0;
28231          mid = mid + Math.imul(al4, bh3) | 0;
28232          mid = mid + Math.imul(ah4, bl3) | 0;
28233          hi = hi + Math.imul(ah4, bh3) | 0;
28234          lo = lo + Math.imul(al3, bl4) | 0;
28235          mid = mid + Math.imul(al3, bh4) | 0;
28236          mid = mid + Math.imul(ah3, bl4) | 0;
28237          hi = hi + Math.imul(ah3, bh4) | 0;
28238          lo = lo + Math.imul(al2, bl5) | 0;
28239          mid = mid + Math.imul(al2, bh5) | 0;
28240          mid = mid + Math.imul(ah2, bl5) | 0;
28241          hi = hi + Math.imul(ah2, bh5) | 0;
28242          lo = lo + Math.imul(al1, bl6) | 0;
28243          mid = mid + Math.imul(al1, bh6) | 0;
28244          mid = mid + Math.imul(ah1, bl6) | 0;
28245          hi = hi + Math.imul(ah1, bh6) | 0;
28246          lo = lo + Math.imul(al0, bl7) | 0;
28247          mid = mid + Math.imul(al0, bh7) | 0;
28248          mid = mid + Math.imul(ah0, bl7) | 0;
28249          hi = hi + Math.imul(ah0, bh7) | 0;
28250          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28251          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
28252          w7 &= 67108863;
28253          lo = Math.imul(al8, bl0);
28254          mid = Math.imul(al8, bh0);
28255          mid = mid + Math.imul(ah8, bl0) | 0;
28256          hi = Math.imul(ah8, bh0);
28257          lo = lo + Math.imul(al7, bl1) | 0;
28258          mid = mid + Math.imul(al7, bh1) | 0;
28259          mid = mid + Math.imul(ah7, bl1) | 0;
28260          hi = hi + Math.imul(ah7, bh1) | 0;
28261          lo = lo + Math.imul(al6, bl2) | 0;
28262          mid = mid + Math.imul(al6, bh2) | 0;
28263          mid = mid + Math.imul(ah6, bl2) | 0;
28264          hi = hi + Math.imul(ah6, bh2) | 0;
28265          lo = lo + Math.imul(al5, bl3) | 0;
28266          mid = mid + Math.imul(al5, bh3) | 0;
28267          mid = mid + Math.imul(ah5, bl3) | 0;
28268          hi = hi + Math.imul(ah5, bh3) | 0;
28269          lo = lo + Math.imul(al4, bl4) | 0;
28270          mid = mid + Math.imul(al4, bh4) | 0;
28271          mid = mid + Math.imul(ah4, bl4) | 0;
28272          hi = hi + Math.imul(ah4, bh4) | 0;
28273          lo = lo + Math.imul(al3, bl5) | 0;
28274          mid = mid + Math.imul(al3, bh5) | 0;
28275          mid = mid + Math.imul(ah3, bl5) | 0;
28276          hi = hi + Math.imul(ah3, bh5) | 0;
28277          lo = lo + Math.imul(al2, bl6) | 0;
28278          mid = mid + Math.imul(al2, bh6) | 0;
28279          mid = mid + Math.imul(ah2, bl6) | 0;
28280          hi = hi + Math.imul(ah2, bh6) | 0;
28281          lo = lo + Math.imul(al1, bl7) | 0;
28282          mid = mid + Math.imul(al1, bh7) | 0;
28283          mid = mid + Math.imul(ah1, bl7) | 0;
28284          hi = hi + Math.imul(ah1, bh7) | 0;
28285          lo = lo + Math.imul(al0, bl8) | 0;
28286          mid = mid + Math.imul(al0, bh8) | 0;
28287          mid = mid + Math.imul(ah0, bl8) | 0;
28288          hi = hi + Math.imul(ah0, bh8) | 0;
28289          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28290          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
28291          w8 &= 67108863;
28292          lo = Math.imul(al9, bl0);
28293          mid = Math.imul(al9, bh0);
28294          mid = mid + Math.imul(ah9, bl0) | 0;
28295          hi = Math.imul(ah9, bh0);
28296          lo = lo + Math.imul(al8, bl1) | 0;
28297          mid = mid + Math.imul(al8, bh1) | 0;
28298          mid = mid + Math.imul(ah8, bl1) | 0;
28299          hi = hi + Math.imul(ah8, bh1) | 0;
28300          lo = lo + Math.imul(al7, bl2) | 0;
28301          mid = mid + Math.imul(al7, bh2) | 0;
28302          mid = mid + Math.imul(ah7, bl2) | 0;
28303          hi = hi + Math.imul(ah7, bh2) | 0;
28304          lo = lo + Math.imul(al6, bl3) | 0;
28305          mid = mid + Math.imul(al6, bh3) | 0;
28306          mid = mid + Math.imul(ah6, bl3) | 0;
28307          hi = hi + Math.imul(ah6, bh3) | 0;
28308          lo = lo + Math.imul(al5, bl4) | 0;
28309          mid = mid + Math.imul(al5, bh4) | 0;
28310          mid = mid + Math.imul(ah5, bl4) | 0;
28311          hi = hi + Math.imul(ah5, bh4) | 0;
28312          lo = lo + Math.imul(al4, bl5) | 0;
28313          mid = mid + Math.imul(al4, bh5) | 0;
28314          mid = mid + Math.imul(ah4, bl5) | 0;
28315          hi = hi + Math.imul(ah4, bh5) | 0;
28316          lo = lo + Math.imul(al3, bl6) | 0;
28317          mid = mid + Math.imul(al3, bh6) | 0;
28318          mid = mid + Math.imul(ah3, bl6) | 0;
28319          hi = hi + Math.imul(ah3, bh6) | 0;
28320          lo = lo + Math.imul(al2, bl7) | 0;
28321          mid = mid + Math.imul(al2, bh7) | 0;
28322          mid = mid + Math.imul(ah2, bl7) | 0;
28323          hi = hi + Math.imul(ah2, bh7) | 0;
28324          lo = lo + Math.imul(al1, bl8) | 0;
28325          mid = mid + Math.imul(al1, bh8) | 0;
28326          mid = mid + Math.imul(ah1, bl8) | 0;
28327          hi = hi + Math.imul(ah1, bh8) | 0;
28328          lo = lo + Math.imul(al0, bl9) | 0;
28329          mid = mid + Math.imul(al0, bh9) | 0;
28330          mid = mid + Math.imul(ah0, bl9) | 0;
28331          hi = hi + Math.imul(ah0, bh9) | 0;
28332          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28333          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
28334          w9 &= 67108863;
28335          lo = Math.imul(al9, bl1);
28336          mid = Math.imul(al9, bh1);
28337          mid = mid + Math.imul(ah9, bl1) | 0;
28338          hi = Math.imul(ah9, bh1);
28339          lo = lo + Math.imul(al8, bl2) | 0;
28340          mid = mid + Math.imul(al8, bh2) | 0;
28341          mid = mid + Math.imul(ah8, bl2) | 0;
28342          hi = hi + Math.imul(ah8, bh2) | 0;
28343          lo = lo + Math.imul(al7, bl3) | 0;
28344          mid = mid + Math.imul(al7, bh3) | 0;
28345          mid = mid + Math.imul(ah7, bl3) | 0;
28346          hi = hi + Math.imul(ah7, bh3) | 0;
28347          lo = lo + Math.imul(al6, bl4) | 0;
28348          mid = mid + Math.imul(al6, bh4) | 0;
28349          mid = mid + Math.imul(ah6, bl4) | 0;
28350          hi = hi + Math.imul(ah6, bh4) | 0;
28351          lo = lo + Math.imul(al5, bl5) | 0;
28352          mid = mid + Math.imul(al5, bh5) | 0;
28353          mid = mid + Math.imul(ah5, bl5) | 0;
28354          hi = hi + Math.imul(ah5, bh5) | 0;
28355          lo = lo + Math.imul(al4, bl6) | 0;
28356          mid = mid + Math.imul(al4, bh6) | 0;
28357          mid = mid + Math.imul(ah4, bl6) | 0;
28358          hi = hi + Math.imul(ah4, bh6) | 0;
28359          lo = lo + Math.imul(al3, bl7) | 0;
28360          mid = mid + Math.imul(al3, bh7) | 0;
28361          mid = mid + Math.imul(ah3, bl7) | 0;
28362          hi = hi + Math.imul(ah3, bh7) | 0;
28363          lo = lo + Math.imul(al2, bl8) | 0;
28364          mid = mid + Math.imul(al2, bh8) | 0;
28365          mid = mid + Math.imul(ah2, bl8) | 0;
28366          hi = hi + Math.imul(ah2, bh8) | 0;
28367          lo = lo + Math.imul(al1, bl9) | 0;
28368          mid = mid + Math.imul(al1, bh9) | 0;
28369          mid = mid + Math.imul(ah1, bl9) | 0;
28370          hi = hi + Math.imul(ah1, bh9) | 0;
28371          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28372          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
28373          w10 &= 67108863;
28374          lo = Math.imul(al9, bl2);
28375          mid = Math.imul(al9, bh2);
28376          mid = mid + Math.imul(ah9, bl2) | 0;
28377          hi = Math.imul(ah9, bh2);
28378          lo = lo + Math.imul(al8, bl3) | 0;
28379          mid = mid + Math.imul(al8, bh3) | 0;
28380          mid = mid + Math.imul(ah8, bl3) | 0;
28381          hi = hi + Math.imul(ah8, bh3) | 0;
28382          lo = lo + Math.imul(al7, bl4) | 0;
28383          mid = mid + Math.imul(al7, bh4) | 0;
28384          mid = mid + Math.imul(ah7, bl4) | 0;
28385          hi = hi + Math.imul(ah7, bh4) | 0;
28386          lo = lo + Math.imul(al6, bl5) | 0;
28387          mid = mid + Math.imul(al6, bh5) | 0;
28388          mid = mid + Math.imul(ah6, bl5) | 0;
28389          hi = hi + Math.imul(ah6, bh5) | 0;
28390          lo = lo + Math.imul(al5, bl6) | 0;
28391          mid = mid + Math.imul(al5, bh6) | 0;
28392          mid = mid + Math.imul(ah5, bl6) | 0;
28393          hi = hi + Math.imul(ah5, bh6) | 0;
28394          lo = lo + Math.imul(al4, bl7) | 0;
28395          mid = mid + Math.imul(al4, bh7) | 0;
28396          mid = mid + Math.imul(ah4, bl7) | 0;
28397          hi = hi + Math.imul(ah4, bh7) | 0;
28398          lo = lo + Math.imul(al3, bl8) | 0;
28399          mid = mid + Math.imul(al3, bh8) | 0;
28400          mid = mid + Math.imul(ah3, bl8) | 0;
28401          hi = hi + Math.imul(ah3, bh8) | 0;
28402          lo = lo + Math.imul(al2, bl9) | 0;
28403          mid = mid + Math.imul(al2, bh9) | 0;
28404          mid = mid + Math.imul(ah2, bl9) | 0;
28405          hi = hi + Math.imul(ah2, bh9) | 0;
28406          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28407          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
28408          w11 &= 67108863;
28409          lo = Math.imul(al9, bl3);
28410          mid = Math.imul(al9, bh3);
28411          mid = mid + Math.imul(ah9, bl3) | 0;
28412          hi = Math.imul(ah9, bh3);
28413          lo = lo + Math.imul(al8, bl4) | 0;
28414          mid = mid + Math.imul(al8, bh4) | 0;
28415          mid = mid + Math.imul(ah8, bl4) | 0;
28416          hi = hi + Math.imul(ah8, bh4) | 0;
28417          lo = lo + Math.imul(al7, bl5) | 0;
28418          mid = mid + Math.imul(al7, bh5) | 0;
28419          mid = mid + Math.imul(ah7, bl5) | 0;
28420          hi = hi + Math.imul(ah7, bh5) | 0;
28421          lo = lo + Math.imul(al6, bl6) | 0;
28422          mid = mid + Math.imul(al6, bh6) | 0;
28423          mid = mid + Math.imul(ah6, bl6) | 0;
28424          hi = hi + Math.imul(ah6, bh6) | 0;
28425          lo = lo + Math.imul(al5, bl7) | 0;
28426          mid = mid + Math.imul(al5, bh7) | 0;
28427          mid = mid + Math.imul(ah5, bl7) | 0;
28428          hi = hi + Math.imul(ah5, bh7) | 0;
28429          lo = lo + Math.imul(al4, bl8) | 0;
28430          mid = mid + Math.imul(al4, bh8) | 0;
28431          mid = mid + Math.imul(ah4, bl8) | 0;
28432          hi = hi + Math.imul(ah4, bh8) | 0;
28433          lo = lo + Math.imul(al3, bl9) | 0;
28434          mid = mid + Math.imul(al3, bh9) | 0;
28435          mid = mid + Math.imul(ah3, bl9) | 0;
28436          hi = hi + Math.imul(ah3, bh9) | 0;
28437          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28438          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
28439          w12 &= 67108863;
28440          lo = Math.imul(al9, bl4);
28441          mid = Math.imul(al9, bh4);
28442          mid = mid + Math.imul(ah9, bl4) | 0;
28443          hi = Math.imul(ah9, bh4);
28444          lo = lo + Math.imul(al8, bl5) | 0;
28445          mid = mid + Math.imul(al8, bh5) | 0;
28446          mid = mid + Math.imul(ah8, bl5) | 0;
28447          hi = hi + Math.imul(ah8, bh5) | 0;
28448          lo = lo + Math.imul(al7, bl6) | 0;
28449          mid = mid + Math.imul(al7, bh6) | 0;
28450          mid = mid + Math.imul(ah7, bl6) | 0;
28451          hi = hi + Math.imul(ah7, bh6) | 0;
28452          lo = lo + Math.imul(al6, bl7) | 0;
28453          mid = mid + Math.imul(al6, bh7) | 0;
28454          mid = mid + Math.imul(ah6, bl7) | 0;
28455          hi = hi + Math.imul(ah6, bh7) | 0;
28456          lo = lo + Math.imul(al5, bl8) | 0;
28457          mid = mid + Math.imul(al5, bh8) | 0;
28458          mid = mid + Math.imul(ah5, bl8) | 0;
28459          hi = hi + Math.imul(ah5, bh8) | 0;
28460          lo = lo + Math.imul(al4, bl9) | 0;
28461          mid = mid + Math.imul(al4, bh9) | 0;
28462          mid = mid + Math.imul(ah4, bl9) | 0;
28463          hi = hi + Math.imul(ah4, bh9) | 0;
28464          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28465          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
28466          w13 &= 67108863;
28467          lo = Math.imul(al9, bl5);
28468          mid = Math.imul(al9, bh5);
28469          mid = mid + Math.imul(ah9, bl5) | 0;
28470          hi = Math.imul(ah9, bh5);
28471          lo = lo + Math.imul(al8, bl6) | 0;
28472          mid = mid + Math.imul(al8, bh6) | 0;
28473          mid = mid + Math.imul(ah8, bl6) | 0;
28474          hi = hi + Math.imul(ah8, bh6) | 0;
28475          lo = lo + Math.imul(al7, bl7) | 0;
28476          mid = mid + Math.imul(al7, bh7) | 0;
28477          mid = mid + Math.imul(ah7, bl7) | 0;
28478          hi = hi + Math.imul(ah7, bh7) | 0;
28479          lo = lo + Math.imul(al6, bl8) | 0;
28480          mid = mid + Math.imul(al6, bh8) | 0;
28481          mid = mid + Math.imul(ah6, bl8) | 0;
28482          hi = hi + Math.imul(ah6, bh8) | 0;
28483          lo = lo + Math.imul(al5, bl9) | 0;
28484          mid = mid + Math.imul(al5, bh9) | 0;
28485          mid = mid + Math.imul(ah5, bl9) | 0;
28486          hi = hi + Math.imul(ah5, bh9) | 0;
28487          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28488          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
28489          w14 &= 67108863;
28490          lo = Math.imul(al9, bl6);
28491          mid = Math.imul(al9, bh6);
28492          mid = mid + Math.imul(ah9, bl6) | 0;
28493          hi = Math.imul(ah9, bh6);
28494          lo = lo + Math.imul(al8, bl7) | 0;
28495          mid = mid + Math.imul(al8, bh7) | 0;
28496          mid = mid + Math.imul(ah8, bl7) | 0;
28497          hi = hi + Math.imul(ah8, bh7) | 0;
28498          lo = lo + Math.imul(al7, bl8) | 0;
28499          mid = mid + Math.imul(al7, bh8) | 0;
28500          mid = mid + Math.imul(ah7, bl8) | 0;
28501          hi = hi + Math.imul(ah7, bh8) | 0;
28502          lo = lo + Math.imul(al6, bl9) | 0;
28503          mid = mid + Math.imul(al6, bh9) | 0;
28504          mid = mid + Math.imul(ah6, bl9) | 0;
28505          hi = hi + Math.imul(ah6, bh9) | 0;
28506          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28507          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
28508          w15 &= 67108863;
28509          lo = Math.imul(al9, bl7);
28510          mid = Math.imul(al9, bh7);
28511          mid = mid + Math.imul(ah9, bl7) | 0;
28512          hi = Math.imul(ah9, bh7);
28513          lo = lo + Math.imul(al8, bl8) | 0;
28514          mid = mid + Math.imul(al8, bh8) | 0;
28515          mid = mid + Math.imul(ah8, bl8) | 0;
28516          hi = hi + Math.imul(ah8, bh8) | 0;
28517          lo = lo + Math.imul(al7, bl9) | 0;
28518          mid = mid + Math.imul(al7, bh9) | 0;
28519          mid = mid + Math.imul(ah7, bl9) | 0;
28520          hi = hi + Math.imul(ah7, bh9) | 0;
28521          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28522          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
28523          w16 &= 67108863;
28524          lo = Math.imul(al9, bl8);
28525          mid = Math.imul(al9, bh8);
28526          mid = mid + Math.imul(ah9, bl8) | 0;
28527          hi = Math.imul(ah9, bh8);
28528          lo = lo + Math.imul(al8, bl9) | 0;
28529          mid = mid + Math.imul(al8, bh9) | 0;
28530          mid = mid + Math.imul(ah8, bl9) | 0;
28531          hi = hi + Math.imul(ah8, bh9) | 0;
28532          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28533          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
28534          w17 &= 67108863;
28535          lo = Math.imul(al9, bl9);
28536          mid = Math.imul(al9, bh9);
28537          mid = mid + Math.imul(ah9, bl9) | 0;
28538          hi = Math.imul(ah9, bh9);
28539          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
28540          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
28541          w18 &= 67108863;
28542          o[0] = w0;
28543          o[1] = w1;
28544          o[2] = w2;
28545          o[3] = w3;
28546          o[4] = w4;
28547          o[5] = w5;
28548          o[6] = w6;
28549          o[7] = w7;
28550          o[8] = w8;
28551          o[9] = w9;
28552          o[10] = w10;
28553          o[11] = w11;
28554          o[12] = w12;
28555          o[13] = w13;
28556          o[14] = w14;
28557          o[15] = w15;
28558          o[16] = w16;
28559          o[17] = w17;
28560          o[18] = w18;
28561          if (c !== 0) {
28562            o[19] = c;
28563            out.length++;
28564          }
28565          return out;
28566        };
28567        if (!Math.imul) {
28568          comb10MulTo = smallMulTo;
28569        }
28570        function bigMulTo(self2, num, out) {
28571          out.negative = num.negative ^ self2.negative;
28572          out.length = self2.length + num.length;
28573          var carry = 0;
28574          var hncarry = 0;
28575          for (var k = 0; k < out.length - 1; k++) {
28576            var ncarry = hncarry;
28577            hncarry = 0;
28578            var rword = carry & 67108863;
28579            var maxJ = Math.min(k, num.length - 1);
28580            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
28581              var i2 = k - j;
28582              var a = self2.words[i2] | 0;
28583              var b = num.words[j] | 0;
28584              var r = a * b;
28585              var lo = r & 67108863;
28586              ncarry = ncarry + (r / 67108864 | 0) | 0;
28587              lo = lo + rword | 0;
28588              rword = lo & 67108863;
28589              ncarry = ncarry + (lo >>> 26) | 0;
28590              hncarry += ncarry >>> 26;
28591              ncarry &= 67108863;
28592            }
28593            out.words[k] = rword;
28594            carry = ncarry;
28595            ncarry = hncarry;
28596          }
28597          if (carry !== 0) {
28598            out.words[k] = carry;
28599          } else {
28600            out.length--;
28601          }
28602          return out.strip();
28603        }
28604        function jumboMulTo(self2, num, out) {
28605          var fftm = new FFTM();
28606          return fftm.mulp(self2, num, out);
28607        }
28608        BN.prototype.mulTo = function mulTo(num, out) {
28609          var res;
28610          var len2 = this.length + num.length;
28611          if (this.length === 10 && num.length === 10) {
28612            res = comb10MulTo(this, num, out);
28613          } else if (len2 < 63) {
28614            res = smallMulTo(this, num, out);
28615          } else if (len2 < 1024) {
28616            res = bigMulTo(this, num, out);
28617          } else {
28618            res = jumboMulTo(this, num, out);
28619          }
28620          return res;
28621        };
28622        function FFTM(x, y) {
28623          this.x = x;
28624          this.y = y;
28625        }
28626        FFTM.prototype.makeRBT = function makeRBT(N) {
28627          var t = new Array(N);
28628          var l = BN.prototype._countBits(N) - 1;
28629          for (var i2 = 0; i2 < N; i2++) {
28630            t[i2] = this.revBin(i2, l, N);
28631          }
28632          return t;
28633        };
28634        FFTM.prototype.revBin = function revBin(x, l, N) {
28635          if (x === 0 || x === N - 1) return x;
28636          var rb = 0;
28637          for (var i2 = 0; i2 < l; i2++) {
28638            rb |= (x & 1) << l - i2 - 1;
28639            x >>= 1;
28640          }
28641          return rb;
28642        };
28643        FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
28644          for (var i2 = 0; i2 < N; i2++) {
28645            rtws[i2] = rws[rbt[i2]];
28646            itws[i2] = iws[rbt[i2]];
28647          }
28648        };
28649        FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
28650          this.permute(rbt, rws, iws, rtws, itws, N);
28651          for (var s = 1; s < N; s <<= 1) {
28652            var l = s << 1;

vendor: 13,888 bytes, lines 28653-29049

28653            var rtwdf = Math.cos(2 * Math.PI / l);
28654            var itwdf = Math.sin(2 * Math.PI / l);
28655            for (var p = 0; p < N; p += l) {
28656              var rtwdf_ = rtwdf;
28657              var itwdf_ = itwdf;
28658              for (var j = 0; j < s; j++) {
28659                var re = rtws[p + j];
28660                var ie = itws[p + j];
28661                var ro = rtws[p + j + s];
28662                var io = itws[p + j + s];
28663                var rx = rtwdf_ * ro - itwdf_ * io;
28664                io = rtwdf_ * io + itwdf_ * ro;
28665                ro = rx;
28666                rtws[p + j] = re + ro;
28667                itws[p + j] = ie + io;
28668                rtws[p + j + s] = re - ro;
28669                itws[p + j + s] = ie - io;
28670                if (j !== l) {
28671                  rx = rtwdf * rtwdf_ - itwdf * itwdf_;
28672                  itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
28673                  rtwdf_ = rx;
28674                }
28675              }
28676            }
28677          }
28678        };
28679        FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
28680          var N = Math.max(m, n) | 1;
28681          var odd = N & 1;
28682          var i2 = 0;
28683          for (N = N / 2 | 0; N; N = N >>> 1) {
28684            i2++;
28685          }
28686          return 1 << i2 + 1 + odd;
28687        };
28688        FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
28689          if (N <= 1) return;
28690          for (var i2 = 0; i2 < N / 2; i2++) {
28691            var t = rws[i2];
28692            rws[i2] = rws[N - i2 - 1];
28693            rws[N - i2 - 1] = t;
28694            t = iws[i2];
28695            iws[i2] = -iws[N - i2 - 1];
28696            iws[N - i2 - 1] = -t;
28697          }
28698        };
28699        FFTM.prototype.normalize13b = function normalize13b(ws, N) {
28700          var carry = 0;
28701          for (var i2 = 0; i2 < N / 2; i2++) {
28702            var w = Math.round(ws[2 * i2 + 1] / N) * 8192 + Math.round(ws[2 * i2] / N) + carry;
28703            ws[i2] = w & 67108863;
28704            if (w < 67108864) {
28705              carry = 0;
28706            } else {
28707              carry = w / 67108864 | 0;
28708            }
28709          }
28710          return ws;
28711        };
28712        FFTM.prototype.convert13b = function convert13b(ws, len2, rws, N) {
28713          var carry = 0;
28714          for (var i2 = 0; i2 < len2; i2++) {
28715            carry = carry + (ws[i2] | 0);
28716            rws[2 * i2] = carry & 8191;
28717            carry = carry >>> 13;
28718            rws[2 * i2 + 1] = carry & 8191;
28719            carry = carry >>> 13;
28720          }
28721          for (i2 = 2 * len2; i2 < N; ++i2) {
28722            rws[i2] = 0;
28723          }
28724          assert2(carry === 0);
28725          assert2((carry & -8192) === 0);
28726        };
28727        FFTM.prototype.stub = function stub(N) {
28728          var ph = new Array(N);
28729          for (var i2 = 0; i2 < N; i2++) {
28730            ph[i2] = 0;
28731          }
28732          return ph;
28733        };
28734        FFTM.prototype.mulp = function mulp(x, y, out) {
28735          var N = 2 * this.guessLen13b(x.length, y.length);
28736          var rbt = this.makeRBT(N);
28737          var _2 = this.stub(N);
28738          var rws = new Array(N);
28739          var rwst = new Array(N);
28740          var iwst = new Array(N);
28741          var nrws = new Array(N);
28742          var nrwst = new Array(N);
28743          var niwst = new Array(N);
28744          var rmws = out.words;
28745          rmws.length = N;
28746          this.convert13b(x.words, x.length, rws, N);
28747          this.convert13b(y.words, y.length, nrws, N);
28748          this.transform(rws, _2, rwst, iwst, N, rbt);
28749          this.transform(nrws, _2, nrwst, niwst, N, rbt);
28750          for (var i2 = 0; i2 < N; i2++) {
28751            var rx = rwst[i2] * nrwst[i2] - iwst[i2] * niwst[i2];
28752            iwst[i2] = rwst[i2] * niwst[i2] + iwst[i2] * nrwst[i2];
28753            rwst[i2] = rx;
28754          }
28755          this.conjugate(rwst, iwst, N);
28756          this.transform(rwst, iwst, rmws, _2, N, rbt);
28757          this.conjugate(rmws, _2, N);
28758          this.normalize13b(rmws, N);
28759          out.negative = x.negative ^ y.negative;
28760          out.length = x.length + y.length;
28761          return out.strip();
28762        };
28763        BN.prototype.mul = function mul(num) {
28764          var out = new BN(null);
28765          out.words = new Array(this.length + num.length);
28766          return this.mulTo(num, out);
28767        };
28768        BN.prototype.mulf = function mulf(num) {
28769          var out = new BN(null);
28770          out.words = new Array(this.length + num.length);
28771          return jumboMulTo(this, num, out);
28772        };
28773        BN.prototype.imul = function imul(num) {
28774          return this.clone().mulTo(num, this);
28775        };
28776        BN.prototype.imuln = function imuln(num) {
28777          assert2(typeof num === "number");
28778          assert2(num < 67108864);
28779          var carry = 0;
28780          for (var i2 = 0; i2 < this.length; i2++) {
28781            var w = (this.words[i2] | 0) * num;
28782            var lo = (w & 67108863) + (carry & 67108863);
28783            carry >>= 26;
28784            carry += w / 67108864 | 0;
28785            carry += lo >>> 26;
28786            this.words[i2] = lo & 67108863;
28787          }
28788          if (carry !== 0) {
28789            this.words[i2] = carry;
28790            this.length++;
28791          }
28792          this.length = num === 0 ? 1 : this.length;
28793          return this;
28794        };
28795        BN.prototype.muln = function muln(num) {
28796          return this.clone().imuln(num);
28797        };
28798        BN.prototype.sqr = function sqr() {
28799          return this.mul(this);
28800        };
28801        BN.prototype.isqr = function isqr() {
28802          return this.imul(this.clone());
28803        };
28804        BN.prototype.pow = function pow2(num) {
28805          var w = toBitArray(num);
28806          if (w.length === 0) return new BN(1);
28807          var res = this;
28808          for (var i2 = 0; i2 < w.length; i2++, res = res.sqr()) {
28809            if (w[i2] !== 0) break;
28810          }
28811          if (++i2 < w.length) {
28812            for (var q = res.sqr(); i2 < w.length; i2++, q = q.sqr()) {
28813              if (w[i2] === 0) continue;
28814              res = res.mul(q);
28815            }
28816          }
28817          return res;
28818        };
28819        BN.prototype.iushln = function iushln(bits) {
28820          assert2(typeof bits === "number" && bits >= 0);
28821          var r = bits % 26;
28822          var s = (bits - r) / 26;
28823          var carryMask = 67108863 >>> 26 - r << 26 - r;
28824          var i2;
28825          if (r !== 0) {
28826            var carry = 0;
28827            for (i2 = 0; i2 < this.length; i2++) {
28828              var newCarry = this.words[i2] & carryMask;
28829              var c = (this.words[i2] | 0) - newCarry << r;
28830              this.words[i2] = c | carry;
28831              carry = newCarry >>> 26 - r;
28832            }
28833            if (carry) {
28834              this.words[i2] = carry;
28835              this.length++;
28836            }
28837          }
28838          if (s !== 0) {
28839            for (i2 = this.length - 1; i2 >= 0; i2--) {
28840              this.words[i2 + s] = this.words[i2];
28841            }
28842            for (i2 = 0; i2 < s; i2++) {
28843              this.words[i2] = 0;
28844            }
28845            this.length += s;
28846          }
28847          return this.strip();
28848        };
28849        BN.prototype.ishln = function ishln(bits) {
28850          assert2(this.negative === 0);
28851          return this.iushln(bits);
28852        };
28853        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
28854          assert2(typeof bits === "number" && bits >= 0);
28855          var h;
28856          if (hint) {
28857            h = (hint - hint % 26) / 26;
28858          } else {
28859            h = 0;
28860          }
28861          var r = bits % 26;
28862          var s = Math.min((bits - r) / 26, this.length);
28863          var mask = 67108863 ^ 67108863 >>> r << r;
28864          var maskedWords = extended;
28865          h -= s;
28866          h = Math.max(0, h);
28867          if (maskedWords) {
28868            for (var i2 = 0; i2 < s; i2++) {
28869              maskedWords.words[i2] = this.words[i2];
28870            }
28871            maskedWords.length = s;
28872          }
28873          if (s === 0) ;
28874          else if (this.length > s) {
28875            this.length -= s;
28876            for (i2 = 0; i2 < this.length; i2++) {
28877              this.words[i2] = this.words[i2 + s];
28878            }
28879          } else {
28880            this.words[0] = 0;
28881            this.length = 1;
28882          }
28883          var carry = 0;
28884          for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h); i2--) {
28885            var word = this.words[i2] | 0;
28886            this.words[i2] = carry << 26 - r | word >>> r;
28887            carry = word & mask;
28888          }
28889          if (maskedWords && carry !== 0) {
28890            maskedWords.words[maskedWords.length++] = carry;
28891          }
28892          if (this.length === 0) {
28893            this.words[0] = 0;
28894            this.length = 1;
28895          }
28896          return this.strip();
28897        };
28898        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
28899          assert2(this.negative === 0);
28900          return this.iushrn(bits, hint, extended);
28901        };
28902        BN.prototype.shln = function shln(bits) {
28903          return this.clone().ishln(bits);
28904        };
28905        BN.prototype.ushln = function ushln(bits) {
28906          return this.clone().iushln(bits);
28907        };
28908        BN.prototype.shrn = function shrn(bits) {
28909          return this.clone().ishrn(bits);
28910        };
28911        BN.prototype.ushrn = function ushrn(bits) {
28912          return this.clone().iushrn(bits);
28913        };
28914        BN.prototype.testn = function testn(bit) {
28915          assert2(typeof bit === "number" && bit >= 0);
28916          var r = bit % 26;
28917          var s = (bit - r) / 26;
28918          var q = 1 << r;
28919          if (this.length <= s) return false;
28920          var w = this.words[s];
28921          return !!(w & q);
28922        };
28923        BN.prototype.imaskn = function imaskn(bits) {
28924          assert2(typeof bits === "number" && bits >= 0);
28925          var r = bits % 26;
28926          var s = (bits - r) / 26;
28927          assert2(this.negative === 0, "imaskn works only with positive numbers");
28928          if (this.length <= s) {
28929            return this;
28930          }
28931          if (r !== 0) {
28932            s++;
28933          }
28934          this.length = Math.min(s, this.length);
28935          if (r !== 0) {
28936            var mask = 67108863 ^ 67108863 >>> r << r;
28937            this.words[this.length - 1] &= mask;
28938          }
28939          if (this.length === 0) {
28940            this.words[0] = 0;
28941            this.length = 1;
28942          }
28943          return this.strip();
28944        };
28945        BN.prototype.maskn = function maskn(bits) {
28946          return this.clone().imaskn(bits);
28947        };
28948        BN.prototype.iaddn = function iaddn(num) {
28949          assert2(typeof num === "number");
28950          assert2(num < 67108864);
28951          if (num < 0) return this.isubn(-num);
28952          if (this.negative !== 0) {
28953            if (this.length === 1 && (this.words[0] | 0) < num) {
28954              this.words[0] = num - (this.words[0] | 0);
28955              this.negative = 0;
28956              return this;
28957            }
28958            this.negative = 0;
28959            this.isubn(num);
28960            this.negative = 1;
28961            return this;
28962          }
28963          return this._iaddn(num);
28964        };
28965        BN.prototype._iaddn = function _iaddn(num) {
28966          this.words[0] += num;
28967          for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) {
28968            this.words[i2] -= 67108864;
28969            if (i2 === this.length - 1) {
28970              this.words[i2 + 1] = 1;
28971            } else {
28972              this.words[i2 + 1]++;
28973            }
28974          }
28975          this.length = Math.max(this.length, i2 + 1);
28976          return this;
28977        };
28978        BN.prototype.isubn = function isubn(num) {
28979          assert2(typeof num === "number");
28980          assert2(num < 67108864);
28981          if (num < 0) return this.iaddn(-num);
28982          if (this.negative !== 0) {
28983            this.negative = 0;
28984            this.iaddn(num);
28985            this.negative = 1;
28986            return this;
28987          }
28988          this.words[0] -= num;
28989          if (this.length === 1 && this.words[0] < 0) {
28990            this.words[0] = -this.words[0];
28991            this.negative = 1;
28992          } else {
28993            for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) {
28994              this.words[i2] += 67108864;
28995              this.words[i2 + 1] -= 1;
28996            }
28997          }
28998          return this.strip();
28999        };
29000        BN.prototype.addn = function addn(num) {
29001          return this.clone().iaddn(num);
29002        };
29003        BN.prototype.subn = function subn(num) {
29004          return this.clone().isubn(num);
29005        };
29006        BN.prototype.iabs = function iabs() {
29007          this.negative = 0;
29008          return this;
29009        };
29010        BN.prototype.abs = function abs2() {
29011          return this.clone().iabs();
29012        };
29013        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
29014          var len2 = num.length + shift;
29015          var i2;
29016          this._expand(len2);
29017          var w;
29018          var carry = 0;
29019          for (i2 = 0; i2 < num.length; i2++) {
29020            w = (this.words[i2 + shift] | 0) + carry;
29021            var right = (num.words[i2] | 0) * mul;
29022            w -= right & 67108863;
29023            carry = (w >> 26) - (right / 67108864 | 0);
29024            this.words[i2 + shift] = w & 67108863;
29025          }
29026          for (; i2 < this.length - shift; i2++) {
29027            w = (this.words[i2 + shift] | 0) + carry;
29028            carry = w >> 26;
29029            this.words[i2 + shift] = w & 67108863;
29030          }
29031          if (carry === 0) return this.strip();
29032          assert2(carry === -1);
29033          carry = 0;
29034          for (i2 = 0; i2 < this.length; i2++) {
29035            w = -(this.words[i2] | 0) + carry;
29036            carry = w >> 26;
29037            this.words[i2] = w & 67108863;
29038          }
29039          this.negative = 1;
29040          return this.strip();
29041        };
29042        BN.prototype._wordDiv = function _wordDiv(num, mode) {
29043          var shift = this.length - num.length;
29044          var a = this.clone();
29045          var b = num;
29046          var bhi = b.words[b.length - 1] | 0;
29047          var bhiBits = this._countBits(bhi);
29048          shift = 26 - bhiBits;
29049          if (shift !== 0) {

vendor: 27,542 bytes, lines 29050-29905

29050            b = b.ushln(shift);
29051            a.iushln(shift);
29052            bhi = b.words[b.length - 1] | 0;
29053          }
29054          var m = a.length - b.length;
29055          var q;
29056          if (mode !== "mod") {
29057            q = new BN(null);
29058            q.length = m + 1;
29059            q.words = new Array(q.length);
29060            for (var i2 = 0; i2 < q.length; i2++) {
29061              q.words[i2] = 0;
29062            }
29063          }
29064          var diff = a.clone()._ishlnsubmul(b, 1, m);
29065          if (diff.negative === 0) {
29066            a = diff;
29067            if (q) {
29068              q.words[m] = 1;
29069            }
29070          }
29071          for (var j = m - 1; j >= 0; j--) {
29072            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
29073            qj = Math.min(qj / bhi | 0, 67108863);
29074            a._ishlnsubmul(b, qj, j);
29075            while (a.negative !== 0) {
29076              qj--;
29077              a.negative = 0;
29078              a._ishlnsubmul(b, 1, j);
29079              if (!a.isZero()) {
29080                a.negative ^= 1;
29081              }
29082            }
29083            if (q) {
29084              q.words[j] = qj;
29085            }
29086          }
29087          if (q) {
29088            q.strip();
29089          }
29090          a.strip();
29091          if (mode !== "div" && shift !== 0) {
29092            a.iushrn(shift);
29093          }
29094          return {
29095            div: q || null,
29096            mod: a
29097          };
29098        };
29099        BN.prototype.divmod = function divmod(num, mode, positive) {
29100          assert2(!num.isZero());
29101          if (this.isZero()) {
29102            return {
29103              div: new BN(0),
29104              mod: new BN(0)
29105            };
29106          }
29107          var div, mod, res;
29108          if (this.negative !== 0 && num.negative === 0) {
29109            res = this.neg().divmod(num, mode);
29110            if (mode !== "mod") {
29111              div = res.div.neg();
29112            }
29113            if (mode !== "div") {
29114              mod = res.mod.neg();
29115              if (positive && mod.negative !== 0) {
29116                mod.iadd(num);
29117              }
29118            }
29119            return {
29120              div,
29121              mod
29122            };
29123          }
29124          if (this.negative === 0 && num.negative !== 0) {
29125            res = this.divmod(num.neg(), mode);
29126            if (mode !== "mod") {
29127              div = res.div.neg();
29128            }
29129            return {
29130              div,
29131              mod: res.mod
29132            };
29133          }
29134          if ((this.negative & num.negative) !== 0) {
29135            res = this.neg().divmod(num.neg(), mode);
29136            if (mode !== "div") {
29137              mod = res.mod.neg();
29138              if (positive && mod.negative !== 0) {
29139                mod.isub(num);
29140              }
29141            }
29142            return {
29143              div: res.div,
29144              mod
29145            };
29146          }
29147          if (num.length > this.length || this.cmp(num) < 0) {
29148            return {
29149              div: new BN(0),
29150              mod: this
29151            };
29152          }
29153          if (num.length === 1) {
29154            if (mode === "div") {
29155              return {
29156                div: this.divn(num.words[0]),
29157                mod: null
29158              };
29159            }
29160            if (mode === "mod") {
29161              return {
29162                div: null,
29163                mod: new BN(this.modn(num.words[0]))
29164              };
29165            }
29166            return {
29167              div: this.divn(num.words[0]),
29168              mod: new BN(this.modn(num.words[0]))
29169            };
29170          }
29171          return this._wordDiv(num, mode);
29172        };
29173        BN.prototype.div = function div(num) {
29174          return this.divmod(num, "div", false).div;
29175        };
29176        BN.prototype.mod = function mod(num) {
29177          return this.divmod(num, "mod", false).mod;
29178        };
29179        BN.prototype.umod = function umod(num) {
29180          return this.divmod(num, "mod", true).mod;
29181        };
29182        BN.prototype.divRound = function divRound(num) {
29183          var dm = this.divmod(num);
29184          if (dm.mod.isZero()) return dm.div;
29185          var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
29186          var half = num.ushrn(1);
29187          var r2 = num.andln(1);
29188          var cmp = mod.cmp(half);
29189          if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
29190          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
29191        };
29192        BN.prototype.modn = function modn(num) {
29193          assert2(num <= 67108863);
29194          var p = (1 << 26) % num;
29195          var acc = 0;
29196          for (var i2 = this.length - 1; i2 >= 0; i2--) {
29197            acc = (p * acc + (this.words[i2] | 0)) % num;
29198          }
29199          return acc;
29200        };
29201        BN.prototype.idivn = function idivn(num) {
29202          assert2(num <= 67108863);
29203          var carry = 0;
29204          for (var i2 = this.length - 1; i2 >= 0; i2--) {
29205            var w = (this.words[i2] | 0) + carry * 67108864;
29206            this.words[i2] = w / num | 0;
29207            carry = w % num;
29208          }
29209          return this.strip();
29210        };
29211        BN.prototype.divn = function divn(num) {
29212          return this.clone().idivn(num);
29213        };
29214        BN.prototype.egcd = function egcd(p) {
29215          assert2(p.negative === 0);
29216          assert2(!p.isZero());
29217          var x = this;
29218          var y = p.clone();
29219          if (x.negative !== 0) {
29220            x = x.umod(p);
29221          } else {
29222            x = x.clone();
29223          }
29224          var A = new BN(1);
29225          var B = new BN(0);
29226          var C = new BN(0);
29227          var D = new BN(1);
29228          var g = 0;
29229          while (x.isEven() && y.isEven()) {
29230            x.iushrn(1);
29231            y.iushrn(1);
29232            ++g;
29233          }
29234          var yp = y.clone();
29235          var xp = x.clone();
29236          while (!x.isZero()) {
29237            for (var i2 = 0, im = 1; (x.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
29238            if (i2 > 0) {
29239              x.iushrn(i2);
29240              while (i2-- > 0) {
29241                if (A.isOdd() || B.isOdd()) {
29242                  A.iadd(yp);
29243                  B.isub(xp);
29244                }
29245                A.iushrn(1);
29246                B.iushrn(1);
29247              }
29248            }
29249            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
29250            if (j > 0) {
29251              y.iushrn(j);
29252              while (j-- > 0) {
29253                if (C.isOdd() || D.isOdd()) {
29254                  C.iadd(yp);
29255                  D.isub(xp);
29256                }
29257                C.iushrn(1);
29258                D.iushrn(1);
29259              }
29260            }
29261            if (x.cmp(y) >= 0) {
29262              x.isub(y);
29263              A.isub(C);
29264              B.isub(D);
29265            } else {
29266              y.isub(x);
29267              C.isub(A);
29268              D.isub(B);
29269            }
29270          }
29271          return {
29272            a: C,
29273            b: D,
29274            gcd: y.iushln(g)
29275          };
29276        };
29277        BN.prototype._invmp = function _invmp(p) {
29278          assert2(p.negative === 0);
29279          assert2(!p.isZero());
29280          var a = this;
29281          var b = p.clone();
29282          if (a.negative !== 0) {
29283            a = a.umod(p);
29284          } else {
29285            a = a.clone();
29286          }
29287          var x1 = new BN(1);
29288          var x2 = new BN(0);
29289          var delta = b.clone();
29290          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
29291            for (var i2 = 0, im = 1; (a.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
29292            if (i2 > 0) {
29293              a.iushrn(i2);
29294              while (i2-- > 0) {
29295                if (x1.isOdd()) {
29296                  x1.iadd(delta);
29297                }
29298                x1.iushrn(1);
29299              }
29300            }
29301            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
29302            if (j > 0) {
29303              b.iushrn(j);
29304              while (j-- > 0) {
29305                if (x2.isOdd()) {
29306                  x2.iadd(delta);
29307                }
29308                x2.iushrn(1);
29309              }
29310            }
29311            if (a.cmp(b) >= 0) {
29312              a.isub(b);
29313              x1.isub(x2);
29314            } else {
29315              b.isub(a);
29316              x2.isub(x1);
29317            }
29318          }
29319          var res;
29320          if (a.cmpn(1) === 0) {
29321            res = x1;
29322          } else {
29323            res = x2;
29324          }
29325          if (res.cmpn(0) < 0) {
29326            res.iadd(p);
29327          }
29328          return res;
29329        };
29330        BN.prototype.gcd = function gcd(num) {
29331          if (this.isZero()) return num.abs();
29332          if (num.isZero()) return this.abs();
29333          var a = this.clone();
29334          var b = num.clone();
29335          a.negative = 0;
29336          b.negative = 0;
29337          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
29338            a.iushrn(1);
29339            b.iushrn(1);
29340          }
29341          do {
29342            while (a.isEven()) {
29343              a.iushrn(1);
29344            }
29345            while (b.isEven()) {
29346              b.iushrn(1);
29347            }
29348            var r = a.cmp(b);
29349            if (r < 0) {
29350              var t = a;
29351              a = b;
29352              b = t;
29353            } else if (r === 0 || b.cmpn(1) === 0) {
29354              break;
29355            }
29356            a.isub(b);
29357          } while (true);
29358          return b.iushln(shift);
29359        };
29360        BN.prototype.invm = function invm(num) {
29361          return this.egcd(num).a.umod(num);
29362        };
29363        BN.prototype.isEven = function isEven() {
29364          return (this.words[0] & 1) === 0;
29365        };
29366        BN.prototype.isOdd = function isOdd() {
29367          return (this.words[0] & 1) === 1;
29368        };
29369        BN.prototype.andln = function andln(num) {
29370          return this.words[0] & num;
29371        };
29372        BN.prototype.bincn = function bincn(bit) {
29373          assert2(typeof bit === "number");
29374          var r = bit % 26;
29375          var s = (bit - r) / 26;
29376          var q = 1 << r;
29377          if (this.length <= s) {
29378            this._expand(s + 1);
29379            this.words[s] |= q;
29380            return this;
29381          }
29382          var carry = q;
29383          for (var i2 = s; carry !== 0 && i2 < this.length; i2++) {
29384            var w = this.words[i2] | 0;
29385            w += carry;
29386            carry = w >>> 26;
29387            w &= 67108863;
29388            this.words[i2] = w;
29389          }
29390          if (carry !== 0) {
29391            this.words[i2] = carry;
29392            this.length++;
29393          }
29394          return this;
29395        };
29396        BN.prototype.isZero = function isZero() {
29397          return this.length === 1 && this.words[0] === 0;
29398        };
29399        BN.prototype.cmpn = function cmpn(num) {
29400          var negative = num < 0;
29401          if (this.negative !== 0 && !negative) return -1;
29402          if (this.negative === 0 && negative) return 1;
29403          this.strip();
29404          var res;
29405          if (this.length > 1) {
29406            res = 1;
29407          } else {
29408            if (negative) {
29409              num = -num;
29410            }
29411            assert2(num <= 67108863, "Number is too big");
29412            var w = this.words[0] | 0;
29413            res = w === num ? 0 : w < num ? -1 : 1;
29414          }
29415          if (this.negative !== 0) return -res | 0;
29416          return res;
29417        };
29418        BN.prototype.cmp = function cmp(num) {
29419          if (this.negative !== 0 && num.negative === 0) return -1;
29420          if (this.negative === 0 && num.negative !== 0) return 1;
29421          var res = this.ucmp(num);
29422          if (this.negative !== 0) return -res | 0;
29423          return res;
29424        };
29425        BN.prototype.ucmp = function ucmp(num) {
29426          if (this.length > num.length) return 1;
29427          if (this.length < num.length) return -1;
29428          var res = 0;
29429          for (var i2 = this.length - 1; i2 >= 0; i2--) {
29430            var a = this.words[i2] | 0;
29431            var b = num.words[i2] | 0;
29432            if (a === b) continue;
29433            if (a < b) {
29434              res = -1;
29435            } else if (a > b) {
29436              res = 1;
29437            }
29438            break;
29439          }
29440          return res;
29441        };
29442        BN.prototype.gtn = function gtn(num) {
29443          return this.cmpn(num) === 1;
29444        };
29445        BN.prototype.gt = function gt(num) {
29446          return this.cmp(num) === 1;
29447        };
29448        BN.prototype.gten = function gten(num) {
29449          return this.cmpn(num) >= 0;
29450        };
29451        BN.prototype.gte = function gte(num) {
29452          return this.cmp(num) >= 0;
29453        };
29454        BN.prototype.ltn = function ltn(num) {
29455          return this.cmpn(num) === -1;
29456        };
29457        BN.prototype.lt = function lt(num) {
29458          return this.cmp(num) === -1;
29459        };
29460        BN.prototype.lten = function lten(num) {
29461          return this.cmpn(num) <= 0;
29462        };
29463        BN.prototype.lte = function lte(num) {
29464          return this.cmp(num) <= 0;
29465        };
29466        BN.prototype.eqn = function eqn(num) {
29467          return this.cmpn(num) === 0;
29468        };
29469        BN.prototype.eq = function eq(num) {
29470          return this.cmp(num) === 0;
29471        };
29472        BN.red = function red(num) {
29473          return new Red(num);
29474        };
29475        BN.prototype.toRed = function toRed(ctx) {
29476          assert2(!this.red, "Already a number in reduction context");
29477          assert2(this.negative === 0, "red works only with positives");
29478          return ctx.convertTo(this)._forceRed(ctx);
29479        };
29480        BN.prototype.fromRed = function fromRed() {
29481          assert2(this.red, "fromRed works only with numbers in reduction context");
29482          return this.red.convertFrom(this);
29483        };
29484        BN.prototype._forceRed = function _forceRed(ctx) {
29485          this.red = ctx;
29486          return this;
29487        };
29488        BN.prototype.forceRed = function forceRed(ctx) {
29489          assert2(!this.red, "Already a number in reduction context");
29490          return this._forceRed(ctx);
29491        };
29492        BN.prototype.redAdd = function redAdd(num) {
29493          assert2(this.red, "redAdd works only with red numbers");
29494          return this.red.add(this, num);
29495        };
29496        BN.prototype.redIAdd = function redIAdd(num) {
29497          assert2(this.red, "redIAdd works only with red numbers");
29498          return this.red.iadd(this, num);
29499        };
29500        BN.prototype.redSub = function redSub(num) {
29501          assert2(this.red, "redSub works only with red numbers");
29502          return this.red.sub(this, num);
29503        };
29504        BN.prototype.redISub = function redISub(num) {
29505          assert2(this.red, "redISub works only with red numbers");
29506          return this.red.isub(this, num);
29507        };
29508        BN.prototype.redShl = function redShl(num) {
29509          assert2(this.red, "redShl works only with red numbers");
29510          return this.red.shl(this, num);
29511        };
29512        BN.prototype.redMul = function redMul(num) {
29513          assert2(this.red, "redMul works only with red numbers");
29514          this.red._verify2(this, num);
29515          return this.red.mul(this, num);
29516        };
29517        BN.prototype.redIMul = function redIMul(num) {
29518          assert2(this.red, "redMul works only with red numbers");
29519          this.red._verify2(this, num);
29520          return this.red.imul(this, num);
29521        };
29522        BN.prototype.redSqr = function redSqr() {
29523          assert2(this.red, "redSqr works only with red numbers");
29524          this.red._verify1(this);
29525          return this.red.sqr(this);
29526        };
29527        BN.prototype.redISqr = function redISqr() {
29528          assert2(this.red, "redISqr works only with red numbers");
29529          this.red._verify1(this);
29530          return this.red.isqr(this);
29531        };
29532        BN.prototype.redSqrt = function redSqrt() {
29533          assert2(this.red, "redSqrt works only with red numbers");
29534          this.red._verify1(this);
29535          return this.red.sqrt(this);
29536        };
29537        BN.prototype.redInvm = function redInvm() {
29538          assert2(this.red, "redInvm works only with red numbers");
29539          this.red._verify1(this);
29540          return this.red.invm(this);
29541        };
29542        BN.prototype.redNeg = function redNeg() {
29543          assert2(this.red, "redNeg works only with red numbers");
29544          this.red._verify1(this);
29545          return this.red.neg(this);
29546        };
29547        BN.prototype.redPow = function redPow(num) {
29548          assert2(this.red && !num.red, "redPow(normalNum)");
29549          this.red._verify1(this);
29550          return this.red.pow(this, num);
29551        };
29552        var primes = {
29553          k256: null,
29554          p224: null,
29555          p192: null,
29556          p25519: null
29557        };
29558        function MPrime(name, p) {
29559          this.name = name;
29560          this.p = new BN(p, 16);
29561          this.n = this.p.bitLength();
29562          this.k = new BN(1).iushln(this.n).isub(this.p);
29563          this.tmp = this._tmp();
29564        }
29565        MPrime.prototype._tmp = function _tmp() {
29566          var tmp = new BN(null);
29567          tmp.words = new Array(Math.ceil(this.n / 13));
29568          return tmp;
29569        };
29570        MPrime.prototype.ireduce = function ireduce(num) {
29571          var r = num;
29572          var rlen;
29573          do {
29574            this.split(r, this.tmp);
29575            r = this.imulK(r);
29576            r = r.iadd(this.tmp);
29577            rlen = r.bitLength();
29578          } while (rlen > this.n);
29579          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
29580          if (cmp === 0) {
29581            r.words[0] = 0;
29582            r.length = 1;
29583          } else if (cmp > 0) {
29584            r.isub(this.p);
29585          } else {
29586            if (r.strip !== void 0) {
29587              r.strip();
29588            } else {
29589              r._strip();
29590            }
29591          }
29592          return r;
29593        };
29594        MPrime.prototype.split = function split(input, out) {
29595          input.iushrn(this.n, 0, out);
29596        };
29597        MPrime.prototype.imulK = function imulK(num) {
29598          return num.imul(this.k);
29599        };
29600        function K256() {
29601          MPrime.call(
29602            this,
29603            "k256",
29604            "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
29605          );
29606        }
29607        inherits2(K256, MPrime);
29608        K256.prototype.split = function split(input, output) {
29609          var mask = 4194303;
29610          var outLen = Math.min(input.length, 9);
29611          for (var i2 = 0; i2 < outLen; i2++) {
29612            output.words[i2] = input.words[i2];
29613          }
29614          output.length = outLen;
29615          if (input.length <= 9) {
29616            input.words[0] = 0;
29617            input.length = 1;
29618            return;
29619          }
29620          var prev = input.words[9];
29621          output.words[output.length++] = prev & mask;
29622          for (i2 = 10; i2 < input.length; i2++) {
29623            var next = input.words[i2] | 0;
29624            input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22;
29625            prev = next;
29626          }
29627          prev >>>= 22;
29628          input.words[i2 - 10] = prev;
29629          if (prev === 0 && input.length > 10) {
29630            input.length -= 10;
29631          } else {
29632            input.length -= 9;
29633          }
29634        };
29635        K256.prototype.imulK = function imulK(num) {
29636          num.words[num.length] = 0;
29637          num.words[num.length + 1] = 0;
29638          num.length += 2;
29639          var lo = 0;
29640          for (var i2 = 0; i2 < num.length; i2++) {
29641            var w = num.words[i2] | 0;
29642            lo += w * 977;
29643            num.words[i2] = lo & 67108863;
29644            lo = w * 64 + (lo / 67108864 | 0);
29645          }
29646          if (num.words[num.length - 1] === 0) {
29647            num.length--;
29648            if (num.words[num.length - 1] === 0) {
29649              num.length--;
29650            }
29651          }
29652          return num;
29653        };
29654        function P224() {
29655          MPrime.call(
29656            this,
29657            "p224",
29658            "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
29659          );
29660        }
29661        inherits2(P224, MPrime);
29662        function P192() {
29663          MPrime.call(
29664            this,
29665            "p192",
29666            "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
29667          );
29668        }
29669        inherits2(P192, MPrime);
29670        function P25519() {
29671          MPrime.call(
29672            this,
29673            "25519",
29674            "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
29675          );
29676        }
29677        inherits2(P25519, MPrime);
29678        P25519.prototype.imulK = function imulK(num) {
29679          var carry = 0;
29680          for (var i2 = 0; i2 < num.length; i2++) {
29681            var hi = (num.words[i2] | 0) * 19 + carry;
29682            var lo = hi & 67108863;
29683            hi >>>= 26;
29684            num.words[i2] = lo;
29685            carry = hi;
29686          }
29687          if (carry !== 0) {
29688            num.words[num.length++] = carry;
29689          }
29690          return num;
29691        };
29692        BN._prime = function prime(name) {
29693          if (primes[name]) return primes[name];
29694          var prime2;
29695          if (name === "k256") {
29696            prime2 = new K256();
29697          } else if (name === "p224") {
29698            prime2 = new P224();
29699          } else if (name === "p192") {
29700            prime2 = new P192();
29701          } else if (name === "p25519") {
29702            prime2 = new P25519();
29703          } else {
29704            throw new Error("Unknown prime " + name);
29705          }
29706          primes[name] = prime2;
29707          return prime2;
29708        };
29709        function Red(m) {
29710          if (typeof m === "string") {
29711            var prime = BN._prime(m);
29712            this.m = prime.p;
29713            this.prime = prime;
29714          } else {
29715            assert2(m.gtn(1), "modulus must be greater than 1");
29716            this.m = m;
29717            this.prime = null;
29718          }
29719        }
29720        Red.prototype._verify1 = function _verify1(a) {
29721          assert2(a.negative === 0, "red works only with positives");
29722          assert2(a.red, "red works only with red numbers");
29723        };
29724        Red.prototype._verify2 = function _verify2(a, b) {
29725          assert2((a.negative | b.negative) === 0, "red works only with positives");
29726          assert2(
29727            a.red && a.red === b.red,
29728            "red works only with red numbers"
29729          );
29730        };
29731        Red.prototype.imod = function imod(a) {
29732          if (this.prime) return this.prime.ireduce(a)._forceRed(this);
29733          return a.umod(this.m)._forceRed(this);
29734        };
29735        Red.prototype.neg = function neg(a) {
29736          if (a.isZero()) {
29737            return a.clone();
29738          }
29739          return this.m.sub(a)._forceRed(this);
29740        };
29741        Red.prototype.add = function add(a, b) {
29742          this._verify2(a, b);
29743          var res = a.add(b);
29744          if (res.cmp(this.m) >= 0) {
29745            res.isub(this.m);
29746          }
29747          return res._forceRed(this);
29748        };
29749        Red.prototype.iadd = function iadd(a, b) {
29750          this._verify2(a, b);
29751          var res = a.iadd(b);
29752          if (res.cmp(this.m) >= 0) {
29753            res.isub(this.m);
29754          }
29755          return res;
29756        };
29757        Red.prototype.sub = function sub(a, b) {
29758          this._verify2(a, b);
29759          var res = a.sub(b);
29760          if (res.cmpn(0) < 0) {
29761            res.iadd(this.m);
29762          }
29763          return res._forceRed(this);
29764        };
29765        Red.prototype.isub = function isub(a, b) {
29766          this._verify2(a, b);
29767          var res = a.isub(b);
29768          if (res.cmpn(0) < 0) {
29769            res.iadd(this.m);
29770          }
29771          return res;
29772        };
29773        Red.prototype.shl = function shl(a, num) {
29774          this._verify1(a);
29775          return this.imod(a.ushln(num));
29776        };
29777        Red.prototype.imul = function imul(a, b) {
29778          this._verify2(a, b);
29779          return this.imod(a.imul(b));
29780        };
29781        Red.prototype.mul = function mul(a, b) {
29782          this._verify2(a, b);
29783          return this.imod(a.mul(b));
29784        };
29785        Red.prototype.isqr = function isqr(a) {
29786          return this.imul(a, a.clone());
29787        };
29788        Red.prototype.sqr = function sqr(a) {
29789          return this.mul(a, a);
29790        };
29791        Red.prototype.sqrt = function sqrt(a) {
29792          if (a.isZero()) return a.clone();
29793          var mod3 = this.m.andln(3);
29794          assert2(mod3 % 2 === 1);
29795          if (mod3 === 3) {
29796            var pow2 = this.m.add(new BN(1)).iushrn(2);
29797            return this.pow(a, pow2);
29798          }
29799          var q = this.m.subn(1);
29800          var s = 0;
29801          while (!q.isZero() && q.andln(1) === 0) {
29802            s++;
29803            q.iushrn(1);
29804          }
29805          assert2(!q.isZero());
29806          var one = new BN(1).toRed(this);
29807          var nOne = one.redNeg();
29808          var lpow = this.m.subn(1).iushrn(1);
29809          var z = this.m.bitLength();
29810          z = new BN(2 * z * z).toRed(this);
29811          while (this.pow(z, lpow).cmp(nOne) !== 0) {
29812            z.redIAdd(nOne);
29813          }
29814          var c = this.pow(z, q);
29815          var r = this.pow(a, q.addn(1).iushrn(1));
29816          var t = this.pow(a, q);
29817          var m = s;
29818          while (t.cmp(one) !== 0) {
29819            var tmp = t;
29820            for (var i2 = 0; tmp.cmp(one) !== 0; i2++) {
29821              tmp = tmp.redSqr();
29822            }
29823            assert2(i2 < m);
29824            var b = this.pow(c, new BN(1).iushln(m - i2 - 1));
29825            r = r.redMul(b);
29826            c = b.redSqr();
29827            t = t.redMul(c);
29828            m = i2;
29829          }
29830          return r;
29831        };
29832        Red.prototype.invm = function invm(a) {
29833          var inv = a._invmp(this.m);
29834          if (inv.negative !== 0) {
29835            inv.negative = 0;
29836            return this.imod(inv).redNeg();
29837          } else {
29838            return this.imod(inv);
29839          }
29840        };
29841        Red.prototype.pow = function pow2(a, num) {
29842          if (num.isZero()) return new BN(1).toRed(this);
29843          if (num.cmpn(1) === 0) return a.clone();
29844          var windowSize = 4;
29845          var wnd = new Array(1 << windowSize);
29846          wnd[0] = new BN(1).toRed(this);
29847          wnd[1] = a;
29848          for (var i2 = 2; i2 < wnd.length; i2++) {
29849            wnd[i2] = this.mul(wnd[i2 - 1], a);
29850          }
29851          var res = wnd[0];
29852          var current = 0;
29853          var currentLen = 0;
29854          var start = num.bitLength() % 26;
29855          if (start === 0) {
29856            start = 26;
29857          }
29858          for (i2 = num.length - 1; i2 >= 0; i2--) {
29859            var word = num.words[i2];
29860            for (var j = start - 1; j >= 0; j--) {
29861              var bit = word >> j & 1;
29862              if (res !== wnd[0]) {
29863                res = this.sqr(res);
29864              }
29865              if (bit === 0 && current === 0) {
29866                currentLen = 0;
29867                continue;
29868              }
29869              current <<= 1;
29870              current |= bit;
29871              currentLen++;
29872              if (currentLen !== windowSize && (i2 !== 0 || j !== 0)) continue;
29873              res = this.mul(res, wnd[current]);
29874              currentLen = 0;
29875              current = 0;
29876            }
29877            start = 26;
29878          }
29879          return res;
29880        };
29881        Red.prototype.convertTo = function convertTo(num) {
29882          var r = num.umod(this.m);
29883          return r === num ? r.clone() : r;
29884        };
29885        Red.prototype.convertFrom = function convertFrom(num) {
29886          var res = num.clone();
29887          res.red = null;
29888          return res;
29889        };
29890        BN.mont = function mont2(num) {
29891          return new Mont(num);
29892        };
29893        function Mont(m) {
29894          Red.call(this, m);
29895          this.shift = this.m.bitLength();
29896          if (this.shift % 26 !== 0) {
29897            this.shift += 26 - this.shift % 26;
29898          }
29899          this.r = new BN(1).iushln(this.shift);
29900          this.r2 = this.imod(this.r.sqr());
29901          this.rinv = this.r._invmp(this.m);
29902          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
29903          this.minv = this.minv.umod(this.r);
29904          this.minv = this.r.sub(this.minv);
29905        }

vendor: 4,836 bytes, lines 29906-30059

29906        inherits2(Mont, Red);
29907        Mont.prototype.convertTo = function convertTo(num) {
29908          return this.imod(num.ushln(this.shift));
29909        };
29910        Mont.prototype.convertFrom = function convertFrom(num) {
29911          var r = this.imod(num.mul(this.rinv));
29912          r.red = null;
29913          return r;
29914        };
29915        Mont.prototype.imul = function imul(a, b) {
29916          if (a.isZero() || b.isZero()) {
29917            a.words[0] = 0;
29918            a.length = 1;
29919            return a;
29920          }
29921          var t = a.imul(b);
29922          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
29923          var u = t.isub(c).iushrn(this.shift);
29924          var res = u;
29925          if (u.cmp(this.m) >= 0) {
29926            res = u.isub(this.m);
29927          } else if (u.cmpn(0) < 0) {
29928            res = u.iadd(this.m);
29929          }
29930          return res._forceRed(this);
29931        };
29932        Mont.prototype.mul = function mul(a, b) {
29933          if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
29934          var t = a.mul(b);
29935          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
29936          var u = t.isub(c).iushrn(this.shift);
29937          var res = u;
29938          if (u.cmp(this.m) >= 0) {
29939            res = u.isub(this.m);
29940          } else if (u.cmpn(0) < 0) {
29941            res = u.iadd(this.m);
29942          }
29943          return res._forceRed(this);
29944        };
29945        Mont.prototype.invm = function invm(a) {
29946          var res = this.imod(a._invmp(this.m).mul(this.r2));
29947          return res._forceRed(this);
29948        };
29949      })(module, bn$2);
29950    })(bn$3);
29951    return bn$3.exports;
29952  }
29953  var minimalisticAssert;
29954  var hasRequiredMinimalisticAssert;
29955  function requireMinimalisticAssert() {
29956    if (hasRequiredMinimalisticAssert) return minimalisticAssert;
29957    hasRequiredMinimalisticAssert = 1;
29958    minimalisticAssert = assert2;
29959    function assert2(val, msg) {
29960      if (!val)
29961        throw new Error(msg || "Assertion failed");
29962    }
29963    assert2.equal = function assertEqual(l, r, msg) {
29964      if (l != r)
29965        throw new Error(msg || "Assertion failed: " + l + " != " + r);
29966    };
29967    return minimalisticAssert;
29968  }
29969  var utils$2 = {};
29970  var hasRequiredUtils$2;
29971  function requireUtils$2() {
29972    if (hasRequiredUtils$2) return utils$2;
29973    hasRequiredUtils$2 = 1;
29974    (function(exports$12) {
29975      var utils2 = exports$12;
29976      function toArray2(msg, enc) {
29977        if (Array.isArray(msg))
29978          return msg.slice();
29979        if (!msg)
29980          return [];
29981        var res = [];
29982        if (typeof msg !== "string") {
29983          for (var i2 = 0; i2 < msg.length; i2++)
29984            res[i2] = msg[i2] | 0;
29985          return res;
29986        }
29987        if (enc === "hex") {
29988          msg = msg.replace(/[^a-z0-9]+/ig, "");
29989          if (msg.length % 2 !== 0)
29990            msg = "0" + msg;
29991          for (var i2 = 0; i2 < msg.length; i2 += 2)
29992            res.push(parseInt(msg[i2] + msg[i2 + 1], 16));
29993        } else {
29994          for (var i2 = 0; i2 < msg.length; i2++) {
29995            var c = msg.charCodeAt(i2);
29996            var hi = c >> 8;
29997            var lo = c & 255;
29998            if (hi)
29999              res.push(hi, lo);
30000            else
30001              res.push(lo);
30002          }
30003        }
30004        return res;
30005      }
30006      utils2.toArray = toArray2;
30007      function zero2(word) {
30008        if (word.length === 1)
30009          return "0" + word;
30010        else
30011          return word;
30012      }
30013      utils2.zero2 = zero2;
30014      function toHex(msg) {
30015        var res = "";
30016        for (var i2 = 0; i2 < msg.length; i2++)
30017          res += zero2(msg[i2].toString(16));
30018        return res;
30019      }
30020      utils2.toHex = toHex;
30021      utils2.encode = function encode2(arr, enc) {
30022        if (enc === "hex")
30023          return toHex(arr);
30024        else
30025          return arr;
30026      };
30027    })(utils$2);
30028    return utils$2;
30029  }
30030  var hasRequiredUtils$1;
30031  function requireUtils$1() {
30032    if (hasRequiredUtils$1) return utils$3;
30033    hasRequiredUtils$1 = 1;
30034    (function(exports$12) {
30035      var utils2 = exports$12;
30036      var BN = requireBn$1();
30037      var minAssert = requireMinimalisticAssert();
30038      var minUtils = requireUtils$2();
30039      utils2.assert = minAssert;
30040      utils2.toArray = minUtils.toArray;
30041      utils2.zero2 = minUtils.zero2;
30042      utils2.toHex = minUtils.toHex;
30043      utils2.encode = minUtils.encode;
30044      function getNAF(num, w, bits) {
30045        var naf = new Array(Math.max(num.bitLength(), bits) + 1);
30046        var i2;
30047        for (i2 = 0; i2 < naf.length; i2 += 1) {
30048          naf[i2] = 0;
30049        }
30050        var ws = 1 << w + 1;
30051        var k = num.clone();
30052        for (i2 = 0; i2 < naf.length; i2++) {
30053          var z;
30054          var mod = k.andln(ws - 1);
30055          if (k.isOdd()) {
30056            if (mod > (ws >> 1) - 1)
30057              z = (ws >> 1) - mod;
30058            else
30059              z = mod;

vendor: 9,644 bytes, lines 30060-30379

30060            k.isubn(z);
30061          } else {
30062            z = 0;
30063          }
30064          naf[i2] = z;
30065          k.iushrn(1);
30066        }
30067        return naf;
30068      }
30069      utils2.getNAF = getNAF;
30070      function getJSF(k1, k2) {
30071        var jsf = [
30072          [],
30073          []
30074        ];
30075        k1 = k1.clone();
30076        k2 = k2.clone();
30077        var d1 = 0;
30078        var d2 = 0;
30079        var m8;
30080        while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {
30081          var m14 = k1.andln(3) + d1 & 3;
30082          var m24 = k2.andln(3) + d2 & 3;
30083          if (m14 === 3)
30084            m14 = -1;
30085          if (m24 === 3)
30086            m24 = -1;
30087          var u1;
30088          if ((m14 & 1) === 0) {
30089            u1 = 0;
30090          } else {
30091            m8 = k1.andln(7) + d1 & 7;
30092            if ((m8 === 3 || m8 === 5) && m24 === 2)
30093              u1 = -m14;
30094            else
30095              u1 = m14;
30096          }
30097          jsf[0].push(u1);
30098          var u2;
30099          if ((m24 & 1) === 0) {
30100            u2 = 0;
30101          } else {
30102            m8 = k2.andln(7) + d2 & 7;
30103            if ((m8 === 3 || m8 === 5) && m14 === 2)
30104              u2 = -m24;
30105            else
30106              u2 = m24;
30107          }
30108          jsf[1].push(u2);
30109          if (2 * d1 === u1 + 1)
30110            d1 = 1 - d1;
30111          if (2 * d2 === u2 + 1)
30112            d2 = 1 - d2;
30113          k1.iushrn(1);
30114          k2.iushrn(1);
30115        }
30116        return jsf;
30117      }
30118      utils2.getJSF = getJSF;
30119      function cachedProperty(obj, name, computer) {
30120        var key2 = "_" + name;
30121        obj.prototype[name] = function cachedProperty2() {
30122          return this[key2] !== void 0 ? this[key2] : this[key2] = computer.call(this);
30123        };
30124      }
30125      utils2.cachedProperty = cachedProperty;
30126      function parseBytes(bytes) {
30127        return typeof bytes === "string" ? utils2.toArray(bytes, "hex") : bytes;
30128      }
30129      utils2.parseBytes = parseBytes;
30130      function intFromLE(bytes) {
30131        return new BN(bytes, "hex", "le");
30132      }
30133      utils2.intFromLE = intFromLE;
30134    })(utils$3);
30135    return utils$3;
30136  }
30137  var brorand = { exports: {} };
30138  var hasRequiredBrorand;
30139  function requireBrorand() {
30140    if (hasRequiredBrorand) return brorand.exports;
30141    hasRequiredBrorand = 1;
30142    var r;
30143    brorand.exports = function rand(len2) {
30144      if (!r)
30145        r = new Rand(null);
30146      return r.generate(len2);
30147    };
30148    function Rand(rand) {
30149      this.rand = rand;
30150    }
30151    brorand.exports.Rand = Rand;
30152    Rand.prototype.generate = function generate(len2) {
30153      return this._rand(len2);
30154    };
30155    Rand.prototype._rand = function _rand(n) {
30156      if (this.rand.getBytes)
30157        return this.rand.getBytes(n);
30158      var res = new Uint8Array(n);
30159      for (var i2 = 0; i2 < res.length; i2++)
30160        res[i2] = this.rand.getByte();
30161      return res;
30162    };
30163    if (typeof self === "object") {
30164      if (self.crypto && self.crypto.getRandomValues) {
30165        Rand.prototype._rand = function _rand(n) {
30166          var arr = new Uint8Array(n);
30167          self.crypto.getRandomValues(arr);
30168          return arr;
30169        };
30170      } else if (self.msCrypto && self.msCrypto.getRandomValues) {
30171        Rand.prototype._rand = function _rand(n) {
30172          var arr = new Uint8Array(n);
30173          self.msCrypto.getRandomValues(arr);
30174          return arr;
30175        };
30176      } else if (typeof window === "object") {
30177        Rand.prototype._rand = function() {
30178          throw new Error("Not implemented yet");
30179        };
30180      }
30181    } else {
30182      try {
30183        var crypto2 = requireCryptoBrowserify();
30184        if (typeof crypto2.randomBytes !== "function")
30185          throw new Error("Not supported");
30186        Rand.prototype._rand = function _rand(n) {
30187          return crypto2.randomBytes(n);
30188        };
30189      } catch (e) {
30190      }
30191    }
30192    return brorand.exports;
30193  }
30194  var curve = {};
30195  var base$1;
30196  var hasRequiredBase$1;
30197  function requireBase$1() {
30198    if (hasRequiredBase$1) return base$1;
30199    hasRequiredBase$1 = 1;
30200    var BN = requireBn$1();
30201    var utils2 = requireUtils$1();
30202    var getNAF = utils2.getNAF;
30203    var getJSF = utils2.getJSF;
30204    var assert2 = utils2.assert;
30205    function BaseCurve(type2, conf) {
30206      this.type = type2;
30207      this.p = new BN(conf.p, 16);
30208      this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);
30209      this.zero = new BN(0).toRed(this.red);
30210      this.one = new BN(1).toRed(this.red);
30211      this.two = new BN(2).toRed(this.red);
30212      this.n = conf.n && new BN(conf.n, 16);
30213      this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);
30214      this._wnafT1 = new Array(4);
30215      this._wnafT2 = new Array(4);
30216      this._wnafT3 = new Array(4);
30217      this._wnafT4 = new Array(4);
30218      this._bitLength = this.n ? this.n.bitLength() : 0;
30219      var adjustCount = this.n && this.p.div(this.n);
30220      if (!adjustCount || adjustCount.cmpn(100) > 0) {
30221        this.redN = null;
30222      } else {
30223        this._maxwellTrick = true;
30224        this.redN = this.n.toRed(this.red);
30225      }
30226    }
30227    base$1 = BaseCurve;
30228    BaseCurve.prototype.point = function point() {
30229      throw new Error("Not implemented");
30230    };
30231    BaseCurve.prototype.validate = function validate() {
30232      throw new Error("Not implemented");
30233    };
30234    BaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {
30235      assert2(p.precomputed);
30236      var doubles = p._getDoubles();
30237      var naf = getNAF(k, 1, this._bitLength);
30238      var I = (1 << doubles.step + 1) - (doubles.step % 2 === 0 ? 2 : 1);
30239      I /= 3;
30240      var repr = [];
30241      var j;
30242      var nafW;
30243      for (j = 0; j < naf.length; j += doubles.step) {
30244        nafW = 0;
30245        for (var l = j + doubles.step - 1; l >= j; l--)
30246          nafW = (nafW << 1) + naf[l];
30247        repr.push(nafW);
30248      }
30249      var a = this.jpoint(null, null, null);
30250      var b = this.jpoint(null, null, null);
30251      for (var i2 = I; i2 > 0; i2--) {
30252        for (j = 0; j < repr.length; j++) {
30253          nafW = repr[j];
30254          if (nafW === i2)
30255            b = b.mixedAdd(doubles.points[j]);
30256          else if (nafW === -i2)
30257            b = b.mixedAdd(doubles.points[j].neg());
30258        }
30259        a = a.add(b);
30260      }
30261      return a.toP();
30262    };
30263    BaseCurve.prototype._wnafMul = function _wnafMul(p, k) {
30264      var w = 4;
30265      var nafPoints = p._getNAFPoints(w);
30266      w = nafPoints.wnd;
30267      var wnd = nafPoints.points;
30268      var naf = getNAF(k, w, this._bitLength);
30269      var acc = this.jpoint(null, null, null);
30270      for (var i2 = naf.length - 1; i2 >= 0; i2--) {
30271        for (var l = 0; i2 >= 0 && naf[i2] === 0; i2--)
30272          l++;
30273        if (i2 >= 0)
30274          l++;
30275        acc = acc.dblp(l);
30276        if (i2 < 0)
30277          break;
30278        var z = naf[i2];
30279        assert2(z !== 0);
30280        if (p.type === "affine") {
30281          if (z > 0)
30282            acc = acc.mixedAdd(wnd[z - 1 >> 1]);
30283          else
30284            acc = acc.mixedAdd(wnd[-z - 1 >> 1].neg());
30285        } else {
30286          if (z > 0)
30287            acc = acc.add(wnd[z - 1 >> 1]);
30288          else
30289            acc = acc.add(wnd[-z - 1 >> 1].neg());
30290        }
30291      }
30292      return p.type === "affine" ? acc.toP() : acc;
30293    };
30294    BaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW, points, coeffs, len2, jacobianResult) {
30295      var wndWidth = this._wnafT1;
30296      var wnd = this._wnafT2;
30297      var naf = this._wnafT3;
30298      var max2 = 0;
30299      var i2;
30300      var j;
30301      var p;
30302      for (i2 = 0; i2 < len2; i2++) {
30303        p = points[i2];
30304        var nafPoints = p._getNAFPoints(defW);
30305        wndWidth[i2] = nafPoints.wnd;
30306        wnd[i2] = nafPoints.points;
30307      }
30308      for (i2 = len2 - 1; i2 >= 1; i2 -= 2) {
30309        var a = i2 - 1;
30310        var b = i2;
30311        if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {
30312          naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);
30313          naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);
30314          max2 = Math.max(naf[a].length, max2);
30315          max2 = Math.max(naf[b].length, max2);
30316          continue;
30317        }
30318        var comb = [
30319          points[a],
30320          /* 1 */
30321          null,
30322          /* 3 */
30323          null,
30324          /* 5 */
30325          points[b]
30326          /* 7 */
30327        ];
30328        if (points[a].y.cmp(points[b].y) === 0) {
30329          comb[1] = points[a].add(points[b]);
30330          comb[2] = points[a].toJ().mixedAdd(points[b].neg());
30331        } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {
30332          comb[1] = points[a].toJ().mixedAdd(points[b]);
30333          comb[2] = points[a].add(points[b].neg());
30334        } else {
30335          comb[1] = points[a].toJ().mixedAdd(points[b]);
30336          comb[2] = points[a].toJ().mixedAdd(points[b].neg());
30337        }
30338        var index = [
30339          -3,
30340          /* -1 -1 */
30341          -1,
30342          /* -1 0 */
30343          -5,
30344          /* -1 1 */
30345          -7,
30346          /* 0 -1 */
30347          0,
30348          /* 0 0 */
30349          7,
30350          /* 0 1 */
30351          5,
30352          /* 1 -1 */
30353          1,
30354          /* 1 0 */
30355          3
30356          /* 1 1 */
30357        ];
30358        var jsf = getJSF(coeffs[a], coeffs[b]);
30359        max2 = Math.max(jsf[0].length, max2);
30360        naf[a] = new Array(max2);
30361        naf[b] = new Array(max2);
30362        for (j = 0; j < max2; j++) {
30363          var ja = jsf[0][j] | 0;
30364          var jb = jsf[1][j] | 0;
30365          naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];
30366          naf[b][j] = 0;
30367          wnd[a] = comb;
30368        }
30369      }
30370      var acc = this.jpoint(null, null, null);
30371      var tmp = this._wnafT4;
30372      for (i2 = max2; i2 >= 0; i2--) {
30373        var k = 0;
30374        while (i2 >= 0) {
30375          var zero = true;
30376          for (j = 0; j < len2; j++) {
30377            tmp[j] = naf[j][i2] | 0;
30378            if (tmp[j] !== 0)
30379              zero = false;

vendor: 4,984 bytes, lines 30380-30536

30380          }
30381          if (!zero)
30382            break;
30383          k++;
30384          i2--;
30385        }
30386        if (i2 >= 0)
30387          k++;
30388        acc = acc.dblp(k);
30389        if (i2 < 0)
30390          break;
30391        for (j = 0; j < len2; j++) {
30392          var z = tmp[j];
30393          if (z === 0)
30394            continue;
30395          else if (z > 0)
30396            p = wnd[j][z - 1 >> 1];
30397          else if (z < 0)
30398            p = wnd[j][-z - 1 >> 1].neg();
30399          if (p.type === "affine")
30400            acc = acc.mixedAdd(p);
30401          else
30402            acc = acc.add(p);
30403        }
30404      }
30405      for (i2 = 0; i2 < len2; i2++)
30406        wnd[i2] = null;
30407      if (jacobianResult)
30408        return acc;
30409      else
30410        return acc.toP();
30411    };
30412    function BasePoint(curve2, type2) {
30413      this.curve = curve2;
30414      this.type = type2;
30415      this.precomputed = null;
30416    }
30417    BaseCurve.BasePoint = BasePoint;
30418    BasePoint.prototype.eq = function eq() {
30419      throw new Error("Not implemented");
30420    };
30421    BasePoint.prototype.validate = function validate() {
30422      return this.curve.validate(this);
30423    };
30424    BaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
30425      bytes = utils2.toArray(bytes, enc);
30426      var len2 = this.p.byteLength();
30427      if ((bytes[0] === 4 || bytes[0] === 6 || bytes[0] === 7) && bytes.length - 1 === 2 * len2) {
30428        if (bytes[0] === 6)
30429          assert2(bytes[bytes.length - 1] % 2 === 0);
30430        else if (bytes[0] === 7)
30431          assert2(bytes[bytes.length - 1] % 2 === 1);
30432        var res = this.point(
30433          bytes.slice(1, 1 + len2),
30434          bytes.slice(1 + len2, 1 + 2 * len2)
30435        );
30436        return res;
30437      } else if ((bytes[0] === 2 || bytes[0] === 3) && bytes.length - 1 === len2) {
30438        return this.pointFromX(bytes.slice(1, 1 + len2), bytes[0] === 3);
30439      }
30440      throw new Error("Unknown point format");
30441    };
30442    BasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {
30443      return this.encode(enc, true);
30444    };
30445    BasePoint.prototype._encode = function _encode(compact) {
30446      var len2 = this.curve.p.byteLength();
30447      var x = this.getX().toArray("be", len2);
30448      if (compact)
30449        return [this.getY().isEven() ? 2 : 3].concat(x);
30450      return [4].concat(x, this.getY().toArray("be", len2));
30451    };
30452    BasePoint.prototype.encode = function encode2(enc, compact) {
30453      return utils2.encode(this._encode(compact), enc);
30454    };
30455    BasePoint.prototype.precompute = function precompute(power) {
30456      if (this.precomputed)
30457        return this;
30458      var precomputed = {
30459        doubles: null,
30460        naf: null,
30461        beta: null
30462      };
30463      precomputed.naf = this._getNAFPoints(8);
30464      precomputed.doubles = this._getDoubles(4, power);
30465      precomputed.beta = this._getBeta();
30466      this.precomputed = precomputed;
30467      return this;
30468    };
30469    BasePoint.prototype._hasDoubles = function _hasDoubles(k) {
30470      if (!this.precomputed)
30471        return false;
30472      var doubles = this.precomputed.doubles;
30473      if (!doubles)
30474        return false;
30475      return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);
30476    };
30477    BasePoint.prototype._getDoubles = function _getDoubles(step, power) {
30478      if (this.precomputed && this.precomputed.doubles)
30479        return this.precomputed.doubles;
30480      var doubles = [this];
30481      var acc = this;
30482      for (var i2 = 0; i2 < power; i2 += step) {
30483        for (var j = 0; j < step; j++)
30484          acc = acc.dbl();
30485        doubles.push(acc);
30486      }
30487      return {
30488        step,
30489        points: doubles
30490      };
30491    };
30492    BasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {
30493      if (this.precomputed && this.precomputed.naf)
30494        return this.precomputed.naf;
30495      var res = [this];
30496      var max2 = (1 << wnd) - 1;
30497      var dbl = max2 === 1 ? null : this.dbl();
30498      for (var i2 = 1; i2 < max2; i2++)
30499        res[i2] = res[i2 - 1].add(dbl);
30500      return {
30501        wnd,
30502        points: res
30503      };
30504    };
30505    BasePoint.prototype._getBeta = function _getBeta() {
30506      return null;
30507    };
30508    BasePoint.prototype.dblp = function dblp(k) {
30509      var r = this;
30510      for (var i2 = 0; i2 < k; i2++)
30511        r = r.dbl();
30512      return r;
30513    };
30514    return base$1;
30515  }
30516  var short;
30517  var hasRequiredShort;
30518  function requireShort() {
30519    if (hasRequiredShort) return short;
30520    hasRequiredShort = 1;
30521    var utils2 = requireUtils$1();
30522    var BN = requireBn$1();
30523    var inherits2 = requireInherits();
30524    var Base = requireBase$1();
30525    var assert2 = utils2.assert;
30526    function ShortCurve(conf) {
30527      Base.call(this, "short", conf);
30528      this.a = new BN(conf.a, 16).toRed(this.red);
30529      this.b = new BN(conf.b, 16).toRed(this.red);
30530      this.tinv = this.two.redInvm();
30531      this.zeroA = this.a.fromRed().cmpn(0) === 0;
30532      this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;
30533      this.endo = this._getEndomorphism(conf);
30534      this._endoWnafT1 = new Array(4);
30535      this._endoWnafT2 = new Array(4);
30536    }

vendor: 24,876 bytes, lines 30537-31299

30537    inherits2(ShortCurve, Base);
30538    short = ShortCurve;
30539    ShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {
30540      if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)
30541        return;
30542      var beta;
30543      var lambda;
30544      if (conf.beta) {
30545        beta = new BN(conf.beta, 16).toRed(this.red);
30546      } else {
30547        var betas = this._getEndoRoots(this.p);
30548        beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];
30549        beta = beta.toRed(this.red);
30550      }
30551      if (conf.lambda) {
30552        lambda = new BN(conf.lambda, 16);
30553      } else {
30554        var lambdas = this._getEndoRoots(this.n);
30555        if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {
30556          lambda = lambdas[0];
30557        } else {
30558          lambda = lambdas[1];
30559          assert2(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);
30560        }
30561      }
30562      var basis;
30563      if (conf.basis) {
30564        basis = conf.basis.map(function(vec) {
30565          return {
30566            a: new BN(vec.a, 16),
30567            b: new BN(vec.b, 16)
30568          };
30569        });
30570      } else {
30571        basis = this._getEndoBasis(lambda);
30572      }
30573      return {
30574        beta,
30575        lambda,
30576        basis
30577      };
30578    };
30579    ShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {
30580      var red = num === this.p ? this.red : BN.mont(num);
30581      var tinv = new BN(2).toRed(red).redInvm();
30582      var ntinv = tinv.redNeg();
30583      var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);
30584      var l1 = ntinv.redAdd(s).fromRed();
30585      var l2 = ntinv.redSub(s).fromRed();
30586      return [l1, l2];
30587    };
30588    ShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {
30589      var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));
30590      var u = lambda;
30591      var v = this.n.clone();
30592      var x1 = new BN(1);
30593      var y1 = new BN(0);
30594      var x2 = new BN(0);
30595      var y2 = new BN(1);
30596      var a0;
30597      var b0;
30598      var a1;
30599      var b1;
30600      var a2;
30601      var b2;
30602      var prevR;
30603      var i2 = 0;
30604      var r;
30605      var x;
30606      while (u.cmpn(0) !== 0) {
30607        var q = v.div(u);
30608        r = v.sub(q.mul(u));
30609        x = x2.sub(q.mul(x1));
30610        var y = y2.sub(q.mul(y1));
30611        if (!a1 && r.cmp(aprxSqrt) < 0) {
30612          a0 = prevR.neg();
30613          b0 = x1;
30614          a1 = r.neg();
30615          b1 = x;
30616        } else if (a1 && ++i2 === 2) {
30617          break;
30618        }
30619        prevR = r;
30620        v = u;
30621        u = r;
30622        x2 = x1;
30623        x1 = x;
30624        y2 = y1;
30625        y1 = y;
30626      }
30627      a2 = r.neg();
30628      b2 = x;
30629      var len1 = a1.sqr().add(b1.sqr());
30630      var len2 = a2.sqr().add(b2.sqr());
30631      if (len2.cmp(len1) >= 0) {
30632        a2 = a0;
30633        b2 = b0;
30634      }
30635      if (a1.negative) {
30636        a1 = a1.neg();
30637        b1 = b1.neg();
30638      }
30639      if (a2.negative) {
30640        a2 = a2.neg();
30641        b2 = b2.neg();
30642      }
30643      return [
30644        { a: a1, b: b1 },
30645        { a: a2, b: b2 }
30646      ];
30647    };
30648    ShortCurve.prototype._endoSplit = function _endoSplit(k) {
30649      var basis = this.endo.basis;
30650      var v1 = basis[0];
30651      var v2 = basis[1];
30652      var c1 = v2.b.mul(k).divRound(this.n);
30653      var c2 = v1.b.neg().mul(k).divRound(this.n);
30654      var p1 = c1.mul(v1.a);
30655      var p2 = c2.mul(v2.a);
30656      var q1 = c1.mul(v1.b);
30657      var q2 = c2.mul(v2.b);
30658      var k1 = k.sub(p1).sub(p2);
30659      var k2 = q1.add(q2).neg();
30660      return { k1, k2 };
30661    };
30662    ShortCurve.prototype.pointFromX = function pointFromX(x, odd) {
30663      x = new BN(x, 16);
30664      if (!x.red)
30665        x = x.toRed(this.red);
30666      var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);
30667      var y = y2.redSqrt();
30668      if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
30669        throw new Error("invalid point");
30670      var isOdd = y.fromRed().isOdd();
30671      if (odd && !isOdd || !odd && isOdd)
30672        y = y.redNeg();
30673      return this.point(x, y);
30674    };
30675    ShortCurve.prototype.validate = function validate(point) {
30676      if (point.inf)
30677        return true;
30678      var x = point.x;
30679      var y = point.y;
30680      var ax = this.a.redMul(x);
30681      var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);
30682      return y.redSqr().redISub(rhs).cmpn(0) === 0;
30683    };
30684    ShortCurve.prototype._endoWnafMulAdd = function _endoWnafMulAdd(points, coeffs, jacobianResult) {
30685      var npoints = this._endoWnafT1;
30686      var ncoeffs = this._endoWnafT2;
30687      for (var i2 = 0; i2 < points.length; i2++) {
30688        var split = this._endoSplit(coeffs[i2]);
30689        var p = points[i2];
30690        var beta = p._getBeta();
30691        if (split.k1.negative) {
30692          split.k1.ineg();
30693          p = p.neg(true);
30694        }
30695        if (split.k2.negative) {
30696          split.k2.ineg();
30697          beta = beta.neg(true);
30698        }
30699        npoints[i2 * 2] = p;
30700        npoints[i2 * 2 + 1] = beta;
30701        ncoeffs[i2 * 2] = split.k1;
30702        ncoeffs[i2 * 2 + 1] = split.k2;
30703      }
30704      var res = this._wnafMulAdd(1, npoints, ncoeffs, i2 * 2, jacobianResult);
30705      for (var j = 0; j < i2 * 2; j++) {
30706        npoints[j] = null;
30707        ncoeffs[j] = null;
30708      }
30709      return res;
30710    };
30711    function Point(curve2, x, y, isRed) {
30712      Base.BasePoint.call(this, curve2, "affine");
30713      if (x === null && y === null) {
30714        this.x = null;
30715        this.y = null;
30716        this.inf = true;
30717      } else {
30718        this.x = new BN(x, 16);
30719        this.y = new BN(y, 16);
30720        if (isRed) {
30721          this.x.forceRed(this.curve.red);
30722          this.y.forceRed(this.curve.red);
30723        }
30724        if (!this.x.red)
30725          this.x = this.x.toRed(this.curve.red);
30726        if (!this.y.red)
30727          this.y = this.y.toRed(this.curve.red);
30728        this.inf = false;
30729      }
30730    }
30731    inherits2(Point, Base.BasePoint);
30732    ShortCurve.prototype.point = function point(x, y, isRed) {
30733      return new Point(this, x, y, isRed);
30734    };
30735    ShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {
30736      return Point.fromJSON(this, obj, red);
30737    };
30738    Point.prototype._getBeta = function _getBeta() {
30739      if (!this.curve.endo)
30740        return;
30741      var pre = this.precomputed;
30742      if (pre && pre.beta)
30743        return pre.beta;
30744      var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
30745      if (pre) {
30746        var curve2 = this.curve;
30747        var endoMul = function(p) {
30748          return curve2.point(p.x.redMul(curve2.endo.beta), p.y);
30749        };
30750        pre.beta = beta;
30751        beta.precomputed = {
30752          beta: null,
30753          naf: pre.naf && {
30754            wnd: pre.naf.wnd,
30755            points: pre.naf.points.map(endoMul)
30756          },
30757          doubles: pre.doubles && {
30758            step: pre.doubles.step,
30759            points: pre.doubles.points.map(endoMul)
30760          }
30761        };
30762      }
30763      return beta;
30764    };
30765    Point.prototype.toJSON = function toJSON() {
30766      if (!this.precomputed)
30767        return [this.x, this.y];
30768      return [this.x, this.y, this.precomputed && {
30769        doubles: this.precomputed.doubles && {
30770          step: this.precomputed.doubles.step,
30771          points: this.precomputed.doubles.points.slice(1)
30772        },
30773        naf: this.precomputed.naf && {
30774          wnd: this.precomputed.naf.wnd,
30775          points: this.precomputed.naf.points.slice(1)
30776        }
30777      }];
30778    };
30779    Point.fromJSON = function fromJSON(curve2, obj, red) {
30780      if (typeof obj === "string")
30781        obj = JSON.parse(obj);
30782      var res = curve2.point(obj[0], obj[1], red);
30783      if (!obj[2])
30784        return res;
30785      function obj2point(obj2) {
30786        return curve2.point(obj2[0], obj2[1], red);
30787      }
30788      var pre = obj[2];
30789      res.precomputed = {
30790        beta: null,
30791        doubles: pre.doubles && {
30792          step: pre.doubles.step,
30793          points: [res].concat(pre.doubles.points.map(obj2point))
30794        },
30795        naf: pre.naf && {
30796          wnd: pre.naf.wnd,
30797          points: [res].concat(pre.naf.points.map(obj2point))
30798        }
30799      };
30800      return res;
30801    };
30802    Point.prototype.inspect = function inspect() {
30803      if (this.isInfinity())
30804        return "<EC Point Infinity>";
30805      return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
30806    };
30807    Point.prototype.isInfinity = function isInfinity() {
30808      return this.inf;
30809    };
30810    Point.prototype.add = function add(p) {
30811      if (this.inf)
30812        return p;
30813      if (p.inf)
30814        return this;
30815      if (this.eq(p))
30816        return this.dbl();
30817      if (this.neg().eq(p))
30818        return this.curve.point(null, null);
30819      if (this.x.cmp(p.x) === 0)
30820        return this.curve.point(null, null);
30821      var c = this.y.redSub(p.y);
30822      if (c.cmpn(0) !== 0)
30823        c = c.redMul(this.x.redSub(p.x).redInvm());
30824      var nx = c.redSqr().redISub(this.x).redISub(p.x);
30825      var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
30826      return this.curve.point(nx, ny);
30827    };
30828    Point.prototype.dbl = function dbl() {
30829      if (this.inf)
30830        return this;
30831      var ys1 = this.y.redAdd(this.y);
30832      if (ys1.cmpn(0) === 0)
30833        return this.curve.point(null, null);
30834      var a = this.curve.a;
30835      var x2 = this.x.redSqr();
30836      var dyinv = ys1.redInvm();
30837      var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);
30838      var nx = c.redSqr().redISub(this.x.redAdd(this.x));
30839      var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);
30840      return this.curve.point(nx, ny);
30841    };
30842    Point.prototype.getX = function getX() {
30843      return this.x.fromRed();
30844    };
30845    Point.prototype.getY = function getY() {
30846      return this.y.fromRed();
30847    };
30848    Point.prototype.mul = function mul(k) {
30849      k = new BN(k, 16);
30850      if (this.isInfinity())
30851        return this;
30852      else if (this._hasDoubles(k))
30853        return this.curve._fixedNafMul(this, k);
30854      else if (this.curve.endo)
30855        return this.curve._endoWnafMulAdd([this], [k]);
30856      else
30857        return this.curve._wnafMul(this, k);
30858    };
30859    Point.prototype.mulAdd = function mulAdd(k1, p2, k2) {
30860      var points = [this, p2];
30861      var coeffs = [k1, k2];
30862      if (this.curve.endo)
30863        return this.curve._endoWnafMulAdd(points, coeffs);
30864      else
30865        return this.curve._wnafMulAdd(1, points, coeffs, 2);
30866    };
30867    Point.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {
30868      var points = [this, p2];
30869      var coeffs = [k1, k2];
30870      if (this.curve.endo)
30871        return this.curve._endoWnafMulAdd(points, coeffs, true);
30872      else
30873        return this.curve._wnafMulAdd(1, points, coeffs, 2, true);
30874    };
30875    Point.prototype.eq = function eq(p) {
30876      return this === p || this.inf === p.inf && (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);
30877    };
30878    Point.prototype.neg = function neg(_precompute) {
30879      if (this.inf)
30880        return this;
30881      var res = this.curve.point(this.x, this.y.redNeg());
30882      if (_precompute && this.precomputed) {
30883        var pre = this.precomputed;
30884        var negate = function(p) {
30885          return p.neg();
30886        };
30887        res.precomputed = {
30888          naf: pre.naf && {
30889            wnd: pre.naf.wnd,
30890            points: pre.naf.points.map(negate)
30891          },
30892          doubles: pre.doubles && {
30893            step: pre.doubles.step,
30894            points: pre.doubles.points.map(negate)
30895          }
30896        };
30897      }
30898      return res;
30899    };
30900    Point.prototype.toJ = function toJ() {
30901      if (this.inf)
30902        return this.curve.jpoint(null, null, null);
30903      var res = this.curve.jpoint(this.x, this.y, this.curve.one);
30904      return res;
30905    };
30906    function JPoint(curve2, x, y, z) {
30907      Base.BasePoint.call(this, curve2, "jacobian");
30908      if (x === null && y === null && z === null) {
30909        this.x = this.curve.one;
30910        this.y = this.curve.one;
30911        this.z = new BN(0);
30912      } else {
30913        this.x = new BN(x, 16);
30914        this.y = new BN(y, 16);
30915        this.z = new BN(z, 16);
30916      }
30917      if (!this.x.red)
30918        this.x = this.x.toRed(this.curve.red);
30919      if (!this.y.red)
30920        this.y = this.y.toRed(this.curve.red);
30921      if (!this.z.red)
30922        this.z = this.z.toRed(this.curve.red);
30923      this.zOne = this.z === this.curve.one;
30924    }
30925    inherits2(JPoint, Base.BasePoint);
30926    ShortCurve.prototype.jpoint = function jpoint(x, y, z) {
30927      return new JPoint(this, x, y, z);
30928    };
30929    JPoint.prototype.toP = function toP() {
30930      if (this.isInfinity())
30931        return this.curve.point(null, null);
30932      var zinv = this.z.redInvm();
30933      var zinv2 = zinv.redSqr();
30934      var ax = this.x.redMul(zinv2);
30935      var ay = this.y.redMul(zinv2).redMul(zinv);
30936      return this.curve.point(ax, ay);
30937    };
30938    JPoint.prototype.neg = function neg() {
30939      return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
30940    };
30941    JPoint.prototype.add = function add(p) {
30942      if (this.isInfinity())
30943        return p;
30944      if (p.isInfinity())
30945        return this;
30946      var pz2 = p.z.redSqr();
30947      var z2 = this.z.redSqr();
30948      var u1 = this.x.redMul(pz2);
30949      var u2 = p.x.redMul(z2);
30950      var s1 = this.y.redMul(pz2.redMul(p.z));
30951      var s2 = p.y.redMul(z2.redMul(this.z));
30952      var h = u1.redSub(u2);
30953      var r = s1.redSub(s2);
30954      if (h.cmpn(0) === 0) {
30955        if (r.cmpn(0) !== 0)
30956          return this.curve.jpoint(null, null, null);
30957        else
30958          return this.dbl();
30959      }
30960      var h2 = h.redSqr();
30961      var h3 = h2.redMul(h);
30962      var v = u1.redMul(h2);
30963      var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
30964      var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
30965      var nz = this.z.redMul(p.z).redMul(h);
30966      return this.curve.jpoint(nx, ny, nz);
30967    };
30968    JPoint.prototype.mixedAdd = function mixedAdd(p) {
30969      if (this.isInfinity())
30970        return p.toJ();
30971      if (p.isInfinity())
30972        return this;
30973      var z2 = this.z.redSqr();
30974      var u1 = this.x;
30975      var u2 = p.x.redMul(z2);
30976      var s1 = this.y;
30977      var s2 = p.y.redMul(z2).redMul(this.z);
30978      var h = u1.redSub(u2);
30979      var r = s1.redSub(s2);
30980      if (h.cmpn(0) === 0) {
30981        if (r.cmpn(0) !== 0)
30982          return this.curve.jpoint(null, null, null);
30983        else
30984          return this.dbl();
30985      }
30986      var h2 = h.redSqr();
30987      var h3 = h2.redMul(h);
30988      var v = u1.redMul(h2);
30989      var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);
30990      var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));
30991      var nz = this.z.redMul(h);
30992      return this.curve.jpoint(nx, ny, nz);
30993    };
30994    JPoint.prototype.dblp = function dblp(pow2) {
30995      if (pow2 === 0)
30996        return this;
30997      if (this.isInfinity())
30998        return this;
30999      if (!pow2)
31000        return this.dbl();
31001      var i2;
31002      if (this.curve.zeroA || this.curve.threeA) {
31003        var r = this;
31004        for (i2 = 0; i2 < pow2; i2++)
31005          r = r.dbl();
31006        return r;
31007      }
31008      var a = this.curve.a;
31009      var tinv = this.curve.tinv;
31010      var jx = this.x;
31011      var jy = this.y;
31012      var jz = this.z;
31013      var jz4 = jz.redSqr().redSqr();
31014      var jyd = jy.redAdd(jy);
31015      for (i2 = 0; i2 < pow2; i2++) {
31016        var jx2 = jx.redSqr();
31017        var jyd2 = jyd.redSqr();
31018        var jyd4 = jyd2.redSqr();
31019        var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
31020        var t1 = jx.redMul(jyd2);
31021        var nx = c.redSqr().redISub(t1.redAdd(t1));
31022        var t2 = t1.redISub(nx);
31023        var dny = c.redMul(t2);
31024        dny = dny.redIAdd(dny).redISub(jyd4);
31025        var nz = jyd.redMul(jz);
31026        if (i2 + 1 < pow2)
31027          jz4 = jz4.redMul(jyd4);
31028        jx = nx;
31029        jz = nz;
31030        jyd = dny;
31031      }
31032      return this.curve.jpoint(jx, jyd.redMul(tinv), jz);
31033    };
31034    JPoint.prototype.dbl = function dbl() {
31035      if (this.isInfinity())
31036        return this;
31037      if (this.curve.zeroA)
31038        return this._zeroDbl();
31039      else if (this.curve.threeA)
31040        return this._threeDbl();
31041      else
31042        return this._dbl();
31043    };
31044    JPoint.prototype._zeroDbl = function _zeroDbl() {
31045      var nx;
31046      var ny;
31047      var nz;
31048      if (this.zOne) {
31049        var xx = this.x.redSqr();
31050        var yy = this.y.redSqr();
31051        var yyyy = yy.redSqr();
31052        var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
31053        s = s.redIAdd(s);
31054        var m = xx.redAdd(xx).redIAdd(xx);
31055        var t = m.redSqr().redISub(s).redISub(s);
31056        var yyyy8 = yyyy.redIAdd(yyyy);
31057        yyyy8 = yyyy8.redIAdd(yyyy8);
31058        yyyy8 = yyyy8.redIAdd(yyyy8);
31059        nx = t;
31060        ny = m.redMul(s.redISub(t)).redISub(yyyy8);
31061        nz = this.y.redAdd(this.y);
31062      } else {
31063        var a = this.x.redSqr();
31064        var b = this.y.redSqr();
31065        var c = b.redSqr();
31066        var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);
31067        d = d.redIAdd(d);
31068        var e = a.redAdd(a).redIAdd(a);
31069        var f = e.redSqr();
31070        var c8 = c.redIAdd(c);
31071        c8 = c8.redIAdd(c8);
31072        c8 = c8.redIAdd(c8);
31073        nx = f.redISub(d).redISub(d);
31074        ny = e.redMul(d.redISub(nx)).redISub(c8);
31075        nz = this.y.redMul(this.z);
31076        nz = nz.redIAdd(nz);
31077      }
31078      return this.curve.jpoint(nx, ny, nz);
31079    };
31080    JPoint.prototype._threeDbl = function _threeDbl() {
31081      var nx;
31082      var ny;
31083      var nz;
31084      if (this.zOne) {
31085        var xx = this.x.redSqr();
31086        var yy = this.y.redSqr();
31087        var yyyy = yy.redSqr();
31088        var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
31089        s = s.redIAdd(s);
31090        var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);
31091        var t = m.redSqr().redISub(s).redISub(s);
31092        nx = t;
31093        var yyyy8 = yyyy.redIAdd(yyyy);
31094        yyyy8 = yyyy8.redIAdd(yyyy8);
31095        yyyy8 = yyyy8.redIAdd(yyyy8);
31096        ny = m.redMul(s.redISub(t)).redISub(yyyy8);
31097        nz = this.y.redAdd(this.y);
31098      } else {
31099        var delta = this.z.redSqr();
31100        var gamma = this.y.redSqr();
31101        var beta = this.x.redMul(gamma);
31102        var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));
31103        alpha = alpha.redAdd(alpha).redIAdd(alpha);
31104        var beta4 = beta.redIAdd(beta);
31105        beta4 = beta4.redIAdd(beta4);
31106        var beta8 = beta4.redAdd(beta4);
31107        nx = alpha.redSqr().redISub(beta8);
31108        nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);
31109        var ggamma8 = gamma.redSqr();
31110        ggamma8 = ggamma8.redIAdd(ggamma8);
31111        ggamma8 = ggamma8.redIAdd(ggamma8);
31112        ggamma8 = ggamma8.redIAdd(ggamma8);
31113        ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);
31114      }
31115      return this.curve.jpoint(nx, ny, nz);
31116    };
31117    JPoint.prototype._dbl = function _dbl() {
31118      var a = this.curve.a;
31119      var jx = this.x;
31120      var jy = this.y;
31121      var jz = this.z;
31122      var jz4 = jz.redSqr().redSqr();
31123      var jx2 = jx.redSqr();
31124      var jy2 = jy.redSqr();
31125      var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));
31126      var jxd4 = jx.redAdd(jx);
31127      jxd4 = jxd4.redIAdd(jxd4);
31128      var t1 = jxd4.redMul(jy2);
31129      var nx = c.redSqr().redISub(t1.redAdd(t1));
31130      var t2 = t1.redISub(nx);
31131      var jyd8 = jy2.redSqr();
31132      jyd8 = jyd8.redIAdd(jyd8);
31133      jyd8 = jyd8.redIAdd(jyd8);
31134      jyd8 = jyd8.redIAdd(jyd8);
31135      var ny = c.redMul(t2).redISub(jyd8);
31136      var nz = jy.redAdd(jy).redMul(jz);
31137      return this.curve.jpoint(nx, ny, nz);
31138    };
31139    JPoint.prototype.trpl = function trpl() {
31140      if (!this.curve.zeroA)
31141        return this.dbl().add(this);
31142      var xx = this.x.redSqr();
31143      var yy = this.y.redSqr();
31144      var zz = this.z.redSqr();
31145      var yyyy = yy.redSqr();
31146      var m = xx.redAdd(xx).redIAdd(xx);
31147      var mm = m.redSqr();
31148      var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);
31149      e = e.redIAdd(e);
31150      e = e.redAdd(e).redIAdd(e);
31151      e = e.redISub(mm);
31152      var ee = e.redSqr();
31153      var t = yyyy.redIAdd(yyyy);
31154      t = t.redIAdd(t);
31155      t = t.redIAdd(t);
31156      t = t.redIAdd(t);
31157      var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);
31158      var yyu4 = yy.redMul(u);
31159      yyu4 = yyu4.redIAdd(yyu4);
31160      yyu4 = yyu4.redIAdd(yyu4);
31161      var nx = this.x.redMul(ee).redISub(yyu4);
31162      nx = nx.redIAdd(nx);
31163      nx = nx.redIAdd(nx);
31164      var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));
31165      ny = ny.redIAdd(ny);
31166      ny = ny.redIAdd(ny);
31167      ny = ny.redIAdd(ny);
31168      var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);
31169      return this.curve.jpoint(nx, ny, nz);
31170    };
31171    JPoint.prototype.mul = function mul(k, kbase) {
31172      k = new BN(k, kbase);
31173      return this.curve._wnafMul(this, k);
31174    };
31175    JPoint.prototype.eq = function eq(p) {
31176      if (p.type === "affine")
31177        return this.eq(p.toJ());
31178      if (this === p)
31179        return true;
31180      var z2 = this.z.redSqr();
31181      var pz2 = p.z.redSqr();
31182      if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)
31183        return false;
31184      var z3 = z2.redMul(this.z);
31185      var pz3 = pz2.redMul(p.z);
31186      return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;
31187    };
31188    JPoint.prototype.eqXToP = function eqXToP(x) {
31189      var zs = this.z.redSqr();
31190      var rx = x.toRed(this.curve.red).redMul(zs);
31191      if (this.x.cmp(rx) === 0)
31192        return true;
31193      var xc = x.clone();
31194      var t = this.curve.redN.redMul(zs);
31195      for (; ; ) {
31196        xc.iadd(this.curve.n);
31197        if (xc.cmp(this.curve.p) >= 0)
31198          return false;
31199        rx.redIAdd(t);
31200        if (this.x.cmp(rx) === 0)
31201          return true;
31202      }
31203    };
31204    JPoint.prototype.inspect = function inspect() {
31205      if (this.isInfinity())
31206        return "<EC JPoint Infinity>";
31207      return "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
31208    };
31209    JPoint.prototype.isInfinity = function isInfinity() {
31210      return this.z.cmpn(0) === 0;
31211    };
31212    return short;
31213  }
31214  var mont;
31215  var hasRequiredMont;
31216  function requireMont() {
31217    if (hasRequiredMont) return mont;
31218    hasRequiredMont = 1;
31219    var BN = requireBn$1();
31220    var inherits2 = requireInherits();
31221    var Base = requireBase$1();
31222    var utils2 = requireUtils$1();
31223    function MontCurve(conf) {
31224      Base.call(this, "mont", conf);
31225      this.a = new BN(conf.a, 16).toRed(this.red);
31226      this.b = new BN(conf.b, 16).toRed(this.red);
31227      this.i4 = new BN(4).toRed(this.red).redInvm();
31228      this.two = new BN(2).toRed(this.red);
31229      this.a24 = this.i4.redMul(this.a.redAdd(this.two));
31230    }
31231    inherits2(MontCurve, Base);
31232    mont = MontCurve;
31233    MontCurve.prototype.validate = function validate(point) {
31234      var x = point.normalize().x;
31235      var x2 = x.redSqr();
31236      var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);
31237      var y = rhs.redSqrt();
31238      return y.redSqr().cmp(rhs) === 0;
31239    };
31240    function Point(curve2, x, z) {
31241      Base.BasePoint.call(this, curve2, "projective");
31242      if (x === null && z === null) {
31243        this.x = this.curve.one;
31244        this.z = this.curve.zero;
31245      } else {
31246        this.x = new BN(x, 16);
31247        this.z = new BN(z, 16);
31248        if (!this.x.red)
31249          this.x = this.x.toRed(this.curve.red);
31250        if (!this.z.red)
31251          this.z = this.z.toRed(this.curve.red);
31252      }
31253    }
31254    inherits2(Point, Base.BasePoint);
31255    MontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {
31256      return this.point(utils2.toArray(bytes, enc), 1);
31257    };
31258    MontCurve.prototype.point = function point(x, z) {
31259      return new Point(this, x, z);
31260    };
31261    MontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
31262      return Point.fromJSON(this, obj);
31263    };
31264    Point.prototype.precompute = function precompute() {
31265    };
31266    Point.prototype._encode = function _encode() {
31267      return this.getX().toArray("be", this.curve.p.byteLength());
31268    };
31269    Point.fromJSON = function fromJSON(curve2, obj) {
31270      return new Point(curve2, obj[0], obj[1] || curve2.one);
31271    };
31272    Point.prototype.inspect = function inspect() {
31273      if (this.isInfinity())
31274        return "<EC Point Infinity>";
31275      return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
31276    };
31277    Point.prototype.isInfinity = function isInfinity() {
31278      return this.z.cmpn(0) === 0;
31279    };
31280    Point.prototype.dbl = function dbl() {
31281      var a = this.x.redAdd(this.z);
31282      var aa = a.redSqr();
31283      var b = this.x.redSub(this.z);
31284      var bb = b.redSqr();
31285      var c = aa.redSub(bb);
31286      var nx = aa.redMul(bb);
31287      var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));
31288      return this.curve.point(nx, nz);
31289    };
31290    Point.prototype.add = function add() {
31291      throw new Error("Not supported on Montgomery curve");
31292    };
31293    Point.prototype.diffAdd = function diffAdd(p, diff) {
31294      var a = this.x.redAdd(this.z);
31295      var b = this.x.redSub(this.z);
31296      var c = p.x.redAdd(p.z);
31297      var d = p.x.redSub(p.z);
31298      var da = d.redMul(a);
31299      var cb = c.redMul(b);

vendor: 5,338 bytes, lines 31300-31458

31300      var nx = diff.z.redMul(da.redAdd(cb).redSqr());
31301      var nz = diff.x.redMul(da.redISub(cb).redSqr());
31302      return this.curve.point(nx, nz);
31303    };
31304    Point.prototype.mul = function mul(k) {
31305      var t = k.clone();
31306      var a = this;
31307      var b = this.curve.point(null, null);
31308      var c = this;
31309      for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))
31310        bits.push(t.andln(1));
31311      for (var i2 = bits.length - 1; i2 >= 0; i2--) {
31312        if (bits[i2] === 0) {
31313          a = a.diffAdd(b, c);
31314          b = b.dbl();
31315        } else {
31316          b = a.diffAdd(b, c);
31317          a = a.dbl();
31318        }
31319      }
31320      return b;
31321    };
31322    Point.prototype.mulAdd = function mulAdd() {
31323      throw new Error("Not supported on Montgomery curve");
31324    };
31325    Point.prototype.jumlAdd = function jumlAdd() {
31326      throw new Error("Not supported on Montgomery curve");
31327    };
31328    Point.prototype.eq = function eq(other) {
31329      return this.getX().cmp(other.getX()) === 0;
31330    };
31331    Point.prototype.normalize = function normalize() {
31332      this.x = this.x.redMul(this.z.redInvm());
31333      this.z = this.curve.one;
31334      return this;
31335    };
31336    Point.prototype.getX = function getX() {
31337      this.normalize();
31338      return this.x.fromRed();
31339    };
31340    return mont;
31341  }
31342  var edwards;
31343  var hasRequiredEdwards;
31344  function requireEdwards() {
31345    if (hasRequiredEdwards) return edwards;
31346    hasRequiredEdwards = 1;
31347    var utils2 = requireUtils$1();
31348    var BN = requireBn$1();
31349    var inherits2 = requireInherits();
31350    var Base = requireBase$1();
31351    var assert2 = utils2.assert;
31352    function EdwardsCurve(conf) {
31353      this.twisted = (conf.a | 0) !== 1;
31354      this.mOneA = this.twisted && (conf.a | 0) === -1;
31355      this.extended = this.mOneA;
31356      Base.call(this, "edwards", conf);
31357      this.a = new BN(conf.a, 16).umod(this.red.m);
31358      this.a = this.a.toRed(this.red);
31359      this.c = new BN(conf.c, 16).toRed(this.red);
31360      this.c2 = this.c.redSqr();
31361      this.d = new BN(conf.d, 16).toRed(this.red);
31362      this.dd = this.d.redAdd(this.d);
31363      assert2(!this.twisted || this.c.fromRed().cmpn(1) === 0);
31364      this.oneC = (conf.c | 0) === 1;
31365    }
31366    inherits2(EdwardsCurve, Base);
31367    edwards = EdwardsCurve;
31368    EdwardsCurve.prototype._mulA = function _mulA(num) {
31369      if (this.mOneA)
31370        return num.redNeg();
31371      else
31372        return this.a.redMul(num);
31373    };
31374    EdwardsCurve.prototype._mulC = function _mulC(num) {
31375      if (this.oneC)
31376        return num;
31377      else
31378        return this.c.redMul(num);
31379    };
31380    EdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {
31381      return this.point(x, y, z, t);
31382    };
31383    EdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {
31384      x = new BN(x, 16);
31385      if (!x.red)
31386        x = x.toRed(this.red);
31387      var x2 = x.redSqr();
31388      var rhs = this.c2.redSub(this.a.redMul(x2));
31389      var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));
31390      var y2 = rhs.redMul(lhs.redInvm());
31391      var y = y2.redSqrt();
31392      if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)
31393        throw new Error("invalid point");
31394      var isOdd = y.fromRed().isOdd();
31395      if (odd && !isOdd || !odd && isOdd)
31396        y = y.redNeg();
31397      return this.point(x, y);
31398    };
31399    EdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {
31400      y = new BN(y, 16);
31401      if (!y.red)
31402        y = y.toRed(this.red);
31403      var y2 = y.redSqr();
31404      var lhs = y2.redSub(this.c2);
31405      var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);
31406      var x2 = lhs.redMul(rhs.redInvm());
31407      if (x2.cmp(this.zero) === 0) {
31408        if (odd)
31409          throw new Error("invalid point");
31410        else
31411          return this.point(this.zero, y);
31412      }
31413      var x = x2.redSqrt();
31414      if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)
31415        throw new Error("invalid point");
31416      if (x.fromRed().isOdd() !== odd)
31417        x = x.redNeg();
31418      return this.point(x, y);
31419    };
31420    EdwardsCurve.prototype.validate = function validate(point) {
31421      if (point.isInfinity())
31422        return true;
31423      point.normalize();
31424      var x2 = point.x.redSqr();
31425      var y2 = point.y.redSqr();
31426      var lhs = x2.redMul(this.a).redAdd(y2);
31427      var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));
31428      return lhs.cmp(rhs) === 0;
31429    };
31430    function Point(curve2, x, y, z, t) {
31431      Base.BasePoint.call(this, curve2, "projective");
31432      if (x === null && y === null && z === null) {
31433        this.x = this.curve.zero;
31434        this.y = this.curve.one;
31435        this.z = this.curve.one;
31436        this.t = this.curve.zero;
31437        this.zOne = true;
31438      } else {
31439        this.x = new BN(x, 16);
31440        this.y = new BN(y, 16);
31441        this.z = z ? new BN(z, 16) : this.curve.one;
31442        this.t = t && new BN(t, 16);
31443        if (!this.x.red)
31444          this.x = this.x.toRed(this.curve.red);
31445        if (!this.y.red)
31446          this.y = this.y.toRed(this.curve.red);
31447        if (!this.z.red)
31448          this.z = this.z.toRed(this.curve.red);
31449        if (this.t && !this.t.red)
31450          this.t = this.t.toRed(this.curve.red);
31451        this.zOne = this.z === this.curve.one;
31452        if (this.curve.extended && !this.t) {
31453          this.t = this.x.redMul(this.y);
31454          if (!this.zOne)
31455            this.t = this.t.redMul(this.z.redInvm());
31456        }
31457      }
31458    }

vendor: 13,852 bytes, lines 31459-31909

31459    inherits2(Point, Base.BasePoint);
31460    EdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {
31461      return Point.fromJSON(this, obj);
31462    };
31463    EdwardsCurve.prototype.point = function point(x, y, z, t) {
31464      return new Point(this, x, y, z, t);
31465    };
31466    Point.fromJSON = function fromJSON(curve2, obj) {
31467      return new Point(curve2, obj[0], obj[1], obj[2]);
31468    };
31469    Point.prototype.inspect = function inspect() {
31470      if (this.isInfinity())
31471        return "<EC Point Infinity>";
31472      return "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
31473    };
31474    Point.prototype.isInfinity = function isInfinity() {
31475      return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
31476    };
31477    Point.prototype._extDbl = function _extDbl() {
31478      var a = this.x.redSqr();
31479      var b = this.y.redSqr();
31480      var c = this.z.redSqr();
31481      c = c.redIAdd(c);
31482      var d = this.curve._mulA(a);
31483      var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);
31484      var g = d.redAdd(b);
31485      var f = g.redSub(c);
31486      var h = d.redSub(b);
31487      var nx = e.redMul(f);
31488      var ny = g.redMul(h);
31489      var nt = e.redMul(h);
31490      var nz = f.redMul(g);
31491      return this.curve.point(nx, ny, nz, nt);
31492    };
31493    Point.prototype._projDbl = function _projDbl() {
31494      var b = this.x.redAdd(this.y).redSqr();
31495      var c = this.x.redSqr();
31496      var d = this.y.redSqr();
31497      var nx;
31498      var ny;
31499      var nz;
31500      var e;
31501      var h;
31502      var j;
31503      if (this.curve.twisted) {
31504        e = this.curve._mulA(c);
31505        var f = e.redAdd(d);
31506        if (this.zOne) {
31507          nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));
31508          ny = f.redMul(e.redSub(d));
31509          nz = f.redSqr().redSub(f).redSub(f);
31510        } else {
31511          h = this.z.redSqr();
31512          j = f.redSub(h).redISub(h);
31513          nx = b.redSub(c).redISub(d).redMul(j);
31514          ny = f.redMul(e.redSub(d));
31515          nz = f.redMul(j);
31516        }
31517      } else {
31518        e = c.redAdd(d);
31519        h = this.curve._mulC(this.z).redSqr();
31520        j = e.redSub(h).redSub(h);
31521        nx = this.curve._mulC(b.redISub(e)).redMul(j);
31522        ny = this.curve._mulC(e).redMul(c.redISub(d));
31523        nz = e.redMul(j);
31524      }
31525      return this.curve.point(nx, ny, nz);
31526    };
31527    Point.prototype.dbl = function dbl() {
31528      if (this.isInfinity())
31529        return this;
31530      if (this.curve.extended)
31531        return this._extDbl();
31532      else
31533        return this._projDbl();
31534    };
31535    Point.prototype._extAdd = function _extAdd(p) {
31536      var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));
31537      var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));
31538      var c = this.t.redMul(this.curve.dd).redMul(p.t);
31539      var d = this.z.redMul(p.z.redAdd(p.z));
31540      var e = b.redSub(a);
31541      var f = d.redSub(c);
31542      var g = d.redAdd(c);
31543      var h = b.redAdd(a);
31544      var nx = e.redMul(f);
31545      var ny = g.redMul(h);
31546      var nt = e.redMul(h);
31547      var nz = f.redMul(g);
31548      return this.curve.point(nx, ny, nz, nt);
31549    };
31550    Point.prototype._projAdd = function _projAdd(p) {
31551      var a = this.z.redMul(p.z);
31552      var b = a.redSqr();
31553      var c = this.x.redMul(p.x);
31554      var d = this.y.redMul(p.y);
31555      var e = this.curve.d.redMul(c).redMul(d);
31556      var f = b.redSub(e);
31557      var g = b.redAdd(e);
31558      var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);
31559      var nx = a.redMul(f).redMul(tmp);
31560      var ny;
31561      var nz;
31562      if (this.curve.twisted) {
31563        ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));
31564        nz = f.redMul(g);
31565      } else {
31566        ny = a.redMul(g).redMul(d.redSub(c));
31567        nz = this.curve._mulC(f).redMul(g);
31568      }
31569      return this.curve.point(nx, ny, nz);
31570    };
31571    Point.prototype.add = function add(p) {
31572      if (this.isInfinity())
31573        return p;
31574      if (p.isInfinity())
31575        return this;
31576      if (this.curve.extended)
31577        return this._extAdd(p);
31578      else
31579        return this._projAdd(p);
31580    };
31581    Point.prototype.mul = function mul(k) {
31582      if (this._hasDoubles(k))
31583        return this.curve._fixedNafMul(this, k);
31584      else
31585        return this.curve._wnafMul(this, k);
31586    };
31587    Point.prototype.mulAdd = function mulAdd(k1, p, k2) {
31588      return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, false);
31589    };
31590    Point.prototype.jmulAdd = function jmulAdd(k1, p, k2) {
31591      return this.curve._wnafMulAdd(1, [this, p], [k1, k2], 2, true);
31592    };
31593    Point.prototype.normalize = function normalize() {
31594      if (this.zOne)
31595        return this;
31596      var zi = this.z.redInvm();
31597      this.x = this.x.redMul(zi);
31598      this.y = this.y.redMul(zi);
31599      if (this.t)
31600        this.t = this.t.redMul(zi);
31601      this.z = this.curve.one;
31602      this.zOne = true;
31603      return this;
31604    };
31605    Point.prototype.neg = function neg() {
31606      return this.curve.point(
31607        this.x.redNeg(),
31608        this.y,
31609        this.z,
31610        this.t && this.t.redNeg()
31611      );
31612    };
31613    Point.prototype.getX = function getX() {
31614      this.normalize();
31615      return this.x.fromRed();
31616    };
31617    Point.prototype.getY = function getY() {
31618      this.normalize();
31619      return this.y.fromRed();
31620    };
31621    Point.prototype.eq = function eq(other) {
31622      return this === other || this.getX().cmp(other.getX()) === 0 && this.getY().cmp(other.getY()) === 0;
31623    };
31624    Point.prototype.eqXToP = function eqXToP(x) {
31625      var rx = x.toRed(this.curve.red).redMul(this.z);
31626      if (this.x.cmp(rx) === 0)
31627        return true;
31628      var xc = x.clone();
31629      var t = this.curve.redN.redMul(this.z);
31630      for (; ; ) {
31631        xc.iadd(this.curve.n);
31632        if (xc.cmp(this.curve.p) >= 0)
31633          return false;
31634        rx.redIAdd(t);
31635        if (this.x.cmp(rx) === 0)
31636          return true;
31637      }
31638    };
31639    Point.prototype.toP = Point.prototype.normalize;
31640    Point.prototype.mixedAdd = Point.prototype.add;
31641    return edwards;
31642  }
31643  var hasRequiredCurve;
31644  function requireCurve() {
31645    if (hasRequiredCurve) return curve;
31646    hasRequiredCurve = 1;
31647    (function(exports$12) {
31648      var curve2 = exports$12;
31649      curve2.base = requireBase$1();
31650      curve2.short = requireShort();
31651      curve2.mont = requireMont();
31652      curve2.edwards = requireEdwards();
31653    })(curve);
31654    return curve;
31655  }
31656  var curves = {};
31657  var hash = {};
31658  var utils$1 = {};
31659  var hasRequiredUtils;
31660  function requireUtils() {
31661    if (hasRequiredUtils) return utils$1;
31662    hasRequiredUtils = 1;
31663    var assert2 = requireMinimalisticAssert();
31664    var inherits2 = requireInherits();
31665    utils$1.inherits = inherits2;
31666    function isSurrogatePair(msg, i2) {
31667      if ((msg.charCodeAt(i2) & 64512) !== 55296) {
31668        return false;
31669      }
31670      if (i2 < 0 || i2 + 1 >= msg.length) {
31671        return false;
31672      }
31673      return (msg.charCodeAt(i2 + 1) & 64512) === 56320;
31674    }
31675    function toArray2(msg, enc) {
31676      if (Array.isArray(msg))
31677        return msg.slice();
31678      if (!msg)
31679        return [];
31680      var res = [];
31681      if (typeof msg === "string") {
31682        if (!enc) {
31683          var p = 0;
31684          for (var i2 = 0; i2 < msg.length; i2++) {
31685            var c = msg.charCodeAt(i2);
31686            if (c < 128) {
31687              res[p++] = c;
31688            } else if (c < 2048) {
31689              res[p++] = c >> 6 | 192;
31690              res[p++] = c & 63 | 128;
31691            } else if (isSurrogatePair(msg, i2)) {
31692              c = 65536 + ((c & 1023) << 10) + (msg.charCodeAt(++i2) & 1023);
31693              res[p++] = c >> 18 | 240;
31694              res[p++] = c >> 12 & 63 | 128;
31695              res[p++] = c >> 6 & 63 | 128;
31696              res[p++] = c & 63 | 128;
31697            } else {
31698              res[p++] = c >> 12 | 224;
31699              res[p++] = c >> 6 & 63 | 128;
31700              res[p++] = c & 63 | 128;
31701            }
31702          }
31703        } else if (enc === "hex") {
31704          msg = msg.replace(/[^a-z0-9]+/ig, "");
31705          if (msg.length % 2 !== 0)
31706            msg = "0" + msg;
31707          for (i2 = 0; i2 < msg.length; i2 += 2)
31708            res.push(parseInt(msg[i2] + msg[i2 + 1], 16));
31709        }
31710      } else {
31711        for (i2 = 0; i2 < msg.length; i2++)
31712          res[i2] = msg[i2] | 0;
31713      }
31714      return res;
31715    }
31716    utils$1.toArray = toArray2;
31717    function toHex(msg) {
31718      var res = "";
31719      for (var i2 = 0; i2 < msg.length; i2++)
31720        res += zero2(msg[i2].toString(16));
31721      return res;
31722    }
31723    utils$1.toHex = toHex;
31724    function htonl(w) {
31725      var res = w >>> 24 | w >>> 8 & 65280 | w << 8 & 16711680 | (w & 255) << 24;
31726      return res >>> 0;
31727    }
31728    utils$1.htonl = htonl;
31729    function toHex32(msg, endian) {
31730      var res = "";
31731      for (var i2 = 0; i2 < msg.length; i2++) {
31732        var w = msg[i2];
31733        if (endian === "little")
31734          w = htonl(w);
31735        res += zero8(w.toString(16));
31736      }
31737      return res;
31738    }
31739    utils$1.toHex32 = toHex32;
31740    function zero2(word) {
31741      if (word.length === 1)
31742        return "0" + word;
31743      else
31744        return word;
31745    }
31746    utils$1.zero2 = zero2;
31747    function zero8(word) {
31748      if (word.length === 7)
31749        return "0" + word;
31750      else if (word.length === 6)
31751        return "00" + word;
31752      else if (word.length === 5)
31753        return "000" + word;
31754      else if (word.length === 4)
31755        return "0000" + word;
31756      else if (word.length === 3)
31757        return "00000" + word;
31758      else if (word.length === 2)
31759        return "000000" + word;
31760      else if (word.length === 1)
31761        return "0000000" + word;
31762      else
31763        return word;
31764    }
31765    utils$1.zero8 = zero8;
31766    function join32(msg, start, end, endian) {
31767      var len2 = end - start;
31768      assert2(len2 % 4 === 0);
31769      var res = new Array(len2 / 4);
31770      for (var i2 = 0, k = start; i2 < res.length; i2++, k += 4) {
31771        var w;
31772        if (endian === "big")
31773          w = msg[k] << 24 | msg[k + 1] << 16 | msg[k + 2] << 8 | msg[k + 3];
31774        else
31775          w = msg[k + 3] << 24 | msg[k + 2] << 16 | msg[k + 1] << 8 | msg[k];
31776        res[i2] = w >>> 0;
31777      }
31778      return res;
31779    }
31780    utils$1.join32 = join32;
31781    function split32(msg, endian) {
31782      var res = new Array(msg.length * 4);
31783      for (var i2 = 0, k = 0; i2 < msg.length; i2++, k += 4) {
31784        var m = msg[i2];
31785        if (endian === "big") {
31786          res[k] = m >>> 24;
31787          res[k + 1] = m >>> 16 & 255;
31788          res[k + 2] = m >>> 8 & 255;
31789          res[k + 3] = m & 255;
31790        } else {
31791          res[k + 3] = m >>> 24;
31792          res[k + 2] = m >>> 16 & 255;
31793          res[k + 1] = m >>> 8 & 255;
31794          res[k] = m & 255;
31795        }
31796      }
31797      return res;
31798    }
31799    utils$1.split32 = split32;
31800    function rotr32(w, b) {
31801      return w >>> b | w << 32 - b;
31802    }
31803    utils$1.rotr32 = rotr32;
31804    function rotl32(w, b) {
31805      return w << b | w >>> 32 - b;
31806    }
31807    utils$1.rotl32 = rotl32;
31808    function sum32(a, b) {
31809      return a + b >>> 0;
31810    }
31811    utils$1.sum32 = sum32;
31812    function sum32_3(a, b, c) {
31813      return a + b + c >>> 0;
31814    }
31815    utils$1.sum32_3 = sum32_3;
31816    function sum32_4(a, b, c, d) {
31817      return a + b + c + d >>> 0;
31818    }
31819    utils$1.sum32_4 = sum32_4;
31820    function sum32_5(a, b, c, d, e) {
31821      return a + b + c + d + e >>> 0;
31822    }
31823    utils$1.sum32_5 = sum32_5;
31824    function sum64(buf, pos, ah, al) {
31825      var bh = buf[pos];
31826      var bl = buf[pos + 1];
31827      var lo = al + bl >>> 0;
31828      var hi = (lo < al ? 1 : 0) + ah + bh;
31829      buf[pos] = hi >>> 0;
31830      buf[pos + 1] = lo;
31831    }
31832    utils$1.sum64 = sum64;
31833    function sum64_hi(ah, al, bh, bl) {
31834      var lo = al + bl >>> 0;
31835      var hi = (lo < al ? 1 : 0) + ah + bh;
31836      return hi >>> 0;
31837    }
31838    utils$1.sum64_hi = sum64_hi;
31839    function sum64_lo(ah, al, bh, bl) {
31840      var lo = al + bl;
31841      return lo >>> 0;
31842    }
31843    utils$1.sum64_lo = sum64_lo;
31844    function sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {
31845      var carry = 0;
31846      var lo = al;
31847      lo = lo + bl >>> 0;
31848      carry += lo < al ? 1 : 0;
31849      lo = lo + cl >>> 0;
31850      carry += lo < cl ? 1 : 0;
31851      lo = lo + dl >>> 0;
31852      carry += lo < dl ? 1 : 0;
31853      var hi = ah + bh + ch + dh + carry;
31854      return hi >>> 0;
31855    }
31856    utils$1.sum64_4_hi = sum64_4_hi;
31857    function sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {
31858      var lo = al + bl + cl + dl;
31859      return lo >>> 0;
31860    }
31861    utils$1.sum64_4_lo = sum64_4_lo;
31862    function sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
31863      var carry = 0;
31864      var lo = al;
31865      lo = lo + bl >>> 0;
31866      carry += lo < al ? 1 : 0;
31867      lo = lo + cl >>> 0;
31868      carry += lo < cl ? 1 : 0;
31869      lo = lo + dl >>> 0;
31870      carry += lo < dl ? 1 : 0;
31871      lo = lo + el >>> 0;
31872      carry += lo < el ? 1 : 0;
31873      var hi = ah + bh + ch + dh + eh + carry;
31874      return hi >>> 0;
31875    }
31876    utils$1.sum64_5_hi = sum64_5_hi;
31877    function sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {
31878      var lo = al + bl + cl + dl + el;
31879      return lo >>> 0;
31880    }
31881    utils$1.sum64_5_lo = sum64_5_lo;
31882    function rotr64_hi(ah, al, num) {
31883      var r = al << 32 - num | ah >>> num;
31884      return r >>> 0;
31885    }
31886    utils$1.rotr64_hi = rotr64_hi;
31887    function rotr64_lo(ah, al, num) {
31888      var r = ah << 32 - num | al >>> num;
31889      return r >>> 0;
31890    }
31891    utils$1.rotr64_lo = rotr64_lo;
31892    function shr64_hi(ah, al, num) {
31893      return ah >>> num;
31894    }
31895    utils$1.shr64_hi = shr64_hi;
31896    function shr64_lo(ah, al, num) {
31897      var r = ah << 32 - num | al >>> num;
31898      return r >>> 0;
31899    }
31900    utils$1.shr64_lo = shr64_lo;
31901    return utils$1;
31902  }
31903  var common$3 = {};
31904  var hasRequiredCommon$3;
31905  function requireCommon$3() {
31906    if (hasRequiredCommon$3) return common$3;
31907    hasRequiredCommon$3 = 1;
31908    var utils2 = requireUtils();
31909    var assert2 = requireMinimalisticAssert();

vendor: 5,262 bytes, lines 31910-32089

31910    function BlockHash() {
31911      this.pending = null;
31912      this.pendingTotal = 0;
31913      this.blockSize = this.constructor.blockSize;
31914      this.outSize = this.constructor.outSize;
31915      this.hmacStrength = this.constructor.hmacStrength;
31916      this.padLength = this.constructor.padLength / 8;
31917      this.endian = "big";
31918      this._delta8 = this.blockSize / 8;
31919      this._delta32 = this.blockSize / 32;
31920    }
31921    common$3.BlockHash = BlockHash;
31922    BlockHash.prototype.update = function update(msg, enc) {
31923      msg = utils2.toArray(msg, enc);
31924      if (!this.pending)
31925        this.pending = msg;
31926      else
31927        this.pending = this.pending.concat(msg);
31928      this.pendingTotal += msg.length;
31929      if (this.pending.length >= this._delta8) {
31930        msg = this.pending;
31931        var r = msg.length % this._delta8;
31932        this.pending = msg.slice(msg.length - r, msg.length);
31933        if (this.pending.length === 0)
31934          this.pending = null;
31935        msg = utils2.join32(msg, 0, msg.length - r, this.endian);
31936        for (var i2 = 0; i2 < msg.length; i2 += this._delta32)
31937          this._update(msg, i2, i2 + this._delta32);
31938      }
31939      return this;
31940    };
31941    BlockHash.prototype.digest = function digest(enc) {
31942      this.update(this._pad());
31943      assert2(this.pending === null);
31944      return this._digest(enc);
31945    };
31946    BlockHash.prototype._pad = function pad() {
31947      var len2 = this.pendingTotal;
31948      var bytes = this._delta8;
31949      var k = bytes - (len2 + this.padLength) % bytes;
31950      var res = new Array(k + this.padLength);
31951      res[0] = 128;
31952      for (var i2 = 1; i2 < k; i2++)
31953        res[i2] = 0;
31954      len2 <<= 3;
31955      if (this.endian === "big") {
31956        for (var t = 8; t < this.padLength; t++)
31957          res[i2++] = 0;
31958        res[i2++] = 0;
31959        res[i2++] = 0;
31960        res[i2++] = 0;
31961        res[i2++] = 0;
31962        res[i2++] = len2 >>> 24 & 255;
31963        res[i2++] = len2 >>> 16 & 255;
31964        res[i2++] = len2 >>> 8 & 255;
31965        res[i2++] = len2 & 255;
31966      } else {
31967        res[i2++] = len2 & 255;
31968        res[i2++] = len2 >>> 8 & 255;
31969        res[i2++] = len2 >>> 16 & 255;
31970        res[i2++] = len2 >>> 24 & 255;
31971        res[i2++] = 0;
31972        res[i2++] = 0;
31973        res[i2++] = 0;
31974        res[i2++] = 0;
31975        for (t = 8; t < this.padLength; t++)
31976          res[i2++] = 0;
31977      }
31978      return res;
31979    };
31980    return common$3;
31981  }
31982  var sha = {};
31983  var common$2 = {};
31984  var hasRequiredCommon$2;
31985  function requireCommon$2() {
31986    if (hasRequiredCommon$2) return common$2;
31987    hasRequiredCommon$2 = 1;
31988    var utils2 = requireUtils();
31989    var rotr32 = utils2.rotr32;
31990    function ft_1(s, x, y, z) {
31991      if (s === 0)
31992        return ch32(x, y, z);
31993      if (s === 1 || s === 3)
31994        return p32(x, y, z);
31995      if (s === 2)
31996        return maj32(x, y, z);
31997    }
31998    common$2.ft_1 = ft_1;
31999    function ch32(x, y, z) {
32000      return x & y ^ ~x & z;
32001    }
32002    common$2.ch32 = ch32;
32003    function maj32(x, y, z) {
32004      return x & y ^ x & z ^ y & z;
32005    }
32006    common$2.maj32 = maj32;
32007    function p32(x, y, z) {
32008      return x ^ y ^ z;
32009    }
32010    common$2.p32 = p32;
32011    function s0_256(x) {
32012      return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
32013    }
32014    common$2.s0_256 = s0_256;
32015    function s1_256(x) {
32016      return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
32017    }
32018    common$2.s1_256 = s1_256;
32019    function g0_256(x) {
32020      return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
32021    }
32022    common$2.g0_256 = g0_256;
32023    function g1_256(x) {
32024      return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
32025    }
32026    common$2.g1_256 = g1_256;
32027    return common$2;
32028  }
32029  var _1;
32030  var hasRequired_1;
32031  function require_1() {
32032    if (hasRequired_1) return _1;
32033    hasRequired_1 = 1;
32034    var utils2 = requireUtils();
32035    var common2 = requireCommon$3();
32036    var shaCommon = requireCommon$2();
32037    var rotl32 = utils2.rotl32;
32038    var sum32 = utils2.sum32;
32039    var sum32_5 = utils2.sum32_5;
32040    var ft_1 = shaCommon.ft_1;
32041    var BlockHash = common2.BlockHash;
32042    var sha1_K = [
32043      1518500249,
32044      1859775393,
32045      2400959708,
32046      3395469782
32047    ];
32048    function SHA1() {
32049      if (!(this instanceof SHA1))
32050        return new SHA1();
32051      BlockHash.call(this);
32052      this.h = [
32053        1732584193,
32054        4023233417,
32055        2562383102,
32056        271733878,
32057        3285377520
32058      ];
32059      this.W = new Array(80);
32060    }
32061    utils2.inherits(SHA1, BlockHash);
32062    _1 = SHA1;
32063    SHA1.blockSize = 512;
32064    SHA1.outSize = 160;
32065    SHA1.hmacStrength = 80;
32066    SHA1.padLength = 64;
32067    SHA1.prototype._update = function _update(msg, start) {
32068      var W = this.W;
32069      for (var i2 = 0; i2 < 16; i2++)
32070        W[i2] = msg[start + i2];
32071      for (; i2 < W.length; i2++)
32072        W[i2] = rotl32(W[i2 - 3] ^ W[i2 - 8] ^ W[i2 - 14] ^ W[i2 - 16], 1);
32073      var a = this.h[0];
32074      var b = this.h[1];
32075      var c = this.h[2];
32076      var d = this.h[3];
32077      var e = this.h[4];
32078      for (i2 = 0; i2 < W.length; i2++) {
32079        var s = ~~(i2 / 20);
32080        var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i2], sha1_K[s]);
32081        e = d;
32082        d = c;
32083        c = rotl32(b, 30);
32084        b = a;
32085        a = t;
32086      }
32087      this.h[0] = sum32(this.h[0], a);
32088      this.h[1] = sum32(this.h[1], b);
32089      this.h[2] = sum32(this.h[2], c);

vendor: 5,524 bytes, lines 32090-32307

32090      this.h[3] = sum32(this.h[3], d);
32091      this.h[4] = sum32(this.h[4], e);
32092    };
32093    SHA1.prototype._digest = function digest(enc) {
32094      if (enc === "hex")
32095        return utils2.toHex32(this.h, "big");
32096      else
32097        return utils2.split32(this.h, "big");
32098    };
32099    return _1;
32100  }
32101  var _256;
32102  var hasRequired_256;
32103  function require_256() {
32104    if (hasRequired_256) return _256;
32105    hasRequired_256 = 1;
32106    var utils2 = requireUtils();
32107    var common2 = requireCommon$3();
32108    var shaCommon = requireCommon$2();
32109    var assert2 = requireMinimalisticAssert();
32110    var sum32 = utils2.sum32;
32111    var sum32_4 = utils2.sum32_4;
32112    var sum32_5 = utils2.sum32_5;
32113    var ch32 = shaCommon.ch32;
32114    var maj32 = shaCommon.maj32;
32115    var s0_256 = shaCommon.s0_256;
32116    var s1_256 = shaCommon.s1_256;
32117    var g0_256 = shaCommon.g0_256;
32118    var g1_256 = shaCommon.g1_256;
32119    var BlockHash = common2.BlockHash;
32120    var sha256_K = [
32121      1116352408,
32122      1899447441,
32123      3049323471,
32124      3921009573,
32125      961987163,
32126      1508970993,
32127      2453635748,
32128      2870763221,
32129      3624381080,
32130      310598401,
32131      607225278,
32132      1426881987,
32133      1925078388,
32134      2162078206,
32135      2614888103,
32136      3248222580,
32137      3835390401,
32138      4022224774,
32139      264347078,
32140      604807628,
32141      770255983,
32142      1249150122,
32143      1555081692,
32144      1996064986,
32145      2554220882,
32146      2821834349,
32147      2952996808,
32148      3210313671,
32149      3336571891,
32150      3584528711,
32151      113926993,
32152      338241895,
32153      666307205,
32154      773529912,
32155      1294757372,
32156      1396182291,
32157      1695183700,
32158      1986661051,
32159      2177026350,
32160      2456956037,
32161      2730485921,
32162      2820302411,
32163      3259730800,
32164      3345764771,
32165      3516065817,
32166      3600352804,
32167      4094571909,
32168      275423344,
32169      430227734,
32170      506948616,
32171      659060556,
32172      883997877,
32173      958139571,
32174      1322822218,
32175      1537002063,
32176      1747873779,
32177      1955562222,
32178      2024104815,
32179      2227730452,
32180      2361852424,
32181      2428436474,
32182      2756734187,
32183      3204031479,
32184      3329325298
32185    ];
32186    function SHA256() {
32187      if (!(this instanceof SHA256))
32188        return new SHA256();
32189      BlockHash.call(this);
32190      this.h = [
32191        1779033703,
32192        3144134277,
32193        1013904242,
32194        2773480762,
32195        1359893119,
32196        2600822924,
32197        528734635,
32198        1541459225
32199      ];
32200      this.k = sha256_K;
32201      this.W = new Array(64);
32202    }
32203    utils2.inherits(SHA256, BlockHash);
32204    _256 = SHA256;
32205    SHA256.blockSize = 512;
32206    SHA256.outSize = 256;
32207    SHA256.hmacStrength = 192;
32208    SHA256.padLength = 64;
32209    SHA256.prototype._update = function _update(msg, start) {
32210      var W = this.W;
32211      for (var i2 = 0; i2 < 16; i2++)
32212        W[i2] = msg[start + i2];
32213      for (; i2 < W.length; i2++)
32214        W[i2] = sum32_4(g1_256(W[i2 - 2]), W[i2 - 7], g0_256(W[i2 - 15]), W[i2 - 16]);
32215      var a = this.h[0];
32216      var b = this.h[1];
32217      var c = this.h[2];
32218      var d = this.h[3];
32219      var e = this.h[4];
32220      var f = this.h[5];
32221      var g = this.h[6];
32222      var h = this.h[7];
32223      assert2(this.k.length === W.length);
32224      for (i2 = 0; i2 < W.length; i2++) {
32225        var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i2], W[i2]);
32226        var T2 = sum32(s0_256(a), maj32(a, b, c));
32227        h = g;
32228        g = f;
32229        f = e;
32230        e = sum32(d, T1);
32231        d = c;
32232        c = b;
32233        b = a;
32234        a = sum32(T1, T2);
32235      }
32236      this.h[0] = sum32(this.h[0], a);
32237      this.h[1] = sum32(this.h[1], b);
32238      this.h[2] = sum32(this.h[2], c);
32239      this.h[3] = sum32(this.h[3], d);
32240      this.h[4] = sum32(this.h[4], e);
32241      this.h[5] = sum32(this.h[5], f);
32242      this.h[6] = sum32(this.h[6], g);
32243      this.h[7] = sum32(this.h[7], h);
32244    };
32245    SHA256.prototype._digest = function digest(enc) {
32246      if (enc === "hex")
32247        return utils2.toHex32(this.h, "big");
32248      else
32249        return utils2.split32(this.h, "big");
32250    };
32251    return _256;
32252  }
32253  var _224;
32254  var hasRequired_224;
32255  function require_224() {
32256    if (hasRequired_224) return _224;
32257    hasRequired_224 = 1;
32258    var utils2 = requireUtils();
32259    var SHA256 = require_256();
32260    function SHA224() {
32261      if (!(this instanceof SHA224))
32262        return new SHA224();
32263      SHA256.call(this);
32264      this.h = [
32265        3238371032,
32266        914150663,
32267        812702999,
32268        4144912697,
32269        4290775857,
32270        1750603025,
32271        1694076839,
32272        3204075428
32273      ];
32274    }
32275    utils2.inherits(SHA224, SHA256);
32276    _224 = SHA224;
32277    SHA224.blockSize = 512;
32278    SHA224.outSize = 224;
32279    SHA224.hmacStrength = 192;
32280    SHA224.padLength = 64;
32281    SHA224.prototype._digest = function digest(enc) {
32282      if (enc === "hex")
32283        return utils2.toHex32(this.h.slice(0, 7), "big");
32284      else
32285        return utils2.split32(this.h.slice(0, 7), "big");
32286    };
32287    return _224;
32288  }
32289  var _512;
32290  var hasRequired_512;
32291  function require_512() {
32292    if (hasRequired_512) return _512;
32293    hasRequired_512 = 1;
32294    var utils2 = requireUtils();
32295    var common2 = requireCommon$3();
32296    var assert2 = requireMinimalisticAssert();
32297    var rotr64_hi = utils2.rotr64_hi;
32298    var rotr64_lo = utils2.rotr64_lo;
32299    var shr64_hi = utils2.shr64_hi;
32300    var shr64_lo = utils2.shr64_lo;
32301    var sum64 = utils2.sum64;
32302    var sum64_hi = utils2.sum64_hi;
32303    var sum64_lo = utils2.sum64_lo;
32304    var sum64_4_hi = utils2.sum64_4_hi;
32305    var sum64_4_lo = utils2.sum64_4_lo;
32306    var sum64_5_hi = utils2.sum64_5_hi;
32307    var sum64_5_lo = utils2.sum64_5_lo;

32308    var BlockHash = common2.BlockHash;
32309    var sha512_K = [
32310      1116352408,
32311      3609767458,
32312      1899447441,
32313      602891725,
32314      3049323471,
32315      3964484399,
32316      3921009573,
32317      2173295548,
32318      961987163,
32319      4081628472,
32320      1508970993,
32321      3053834265,
32322      2453635748,
32323      2937671579,
32324      2870763221,
32325      3664609560,
32326      3624381080,
32327      2734883394,
32328      310598401,
32329      1164996542,
32330      607225278,
32331      1323610764,
32332      1426881987,
32333      3590304994,
32334      1925078388,
32335      4068182383,
32336      2162078206,
32337      991336113,
32338      2614888103,
32339      633803317,
32340      3248222580,
32341      3479774868,
32342      3835390401,
32343      2666613458,
32344      4022224774,
32345      944711139,
32346      264347078,
32347      2341262773,
32348      604807628,
32349      2007800933,
32350      770255983,
32351      1495990901,
32352      1249150122,
32353      1856431235,
32354      1555081692,
32355      3175218132,
32356      1996064986,
32357      2198950837,
32358      2554220882,
32359      3999719339,
32360      2821834349,
32361      766784016,
32362      2952996808,
32363      2566594879,
32364      3210313671,
32365      3203337956,
32366      3336571891,
32367      1034457026,
32368      3584528711,
32369      2466948901,
32370      113926993,
32371      3758326383,
32372      338241895,
32373      168717936,
32374      666307205,
32375      1188179964,
32376      773529912,
32377      1546045734,
32378      1294757372,
32379      1522805485,
32380      1396182291,
32381      2643833823,
32382      1695183700,
32383      2343527390,
32384      1986661051,
32385      1014477480,
32386      2177026350,
32387      1206759142,
32388      2456956037,
32389      344077627,
32390      2730485921,
32391      1290863460,
32392      2820302411,
32393      3158454273,
32394      3259730800,
32395      3505952657,
32396      3345764771,
32397      106217008,
32398      3516065817,
32399      3606008344,
32400      3600352804,
32401      1432725776,
32402      4094571909,
32403      1467031594,
32404      275423344,
32405      851169720,
32406      430227734,
32407      3100823752,
32408      506948616,
32409      1363258195,
32410      659060556,
32411      3750685593,
32412      883997877,
32413      3785050280,
32414      958139571,
32415      3318307427,
32416      1322822218,
32417      3812723403,
32418      1537002063,
32419      2003034995,
32420      1747873779,
32421      3602036899,
32422      1955562222,
32423      1575990012,
32424      2024104815,
32425      1125592928,
32426      2227730452,
32427      2716904306,
32428      2361852424,
32429      442776044,
32430      2428436474,
32431      593698344,
32432      2756734187,
32433      3733110249,
32434      3204031479,
32435      2999351573,
32436      3329325298,
32437      3815920427,
32438      3391569614,
32439      3928383900,

vendor: 4,592 bytes, lines 32440-32625

32440      3515267271,
32441      566280711,
32442      3940187606,
32443      3454069534,
32444      4118630271,
32445      4000239992,
32446      116418474,
32447      1914138554,
32448      174292421,
32449      2731055270,
32450      289380356,
32451      3203993006,
32452      460393269,
32453      320620315,
32454      685471733,
32455      587496836,
32456      852142971,
32457      1086792851,
32458      1017036298,
32459      365543100,
32460      1126000580,
32461      2618297676,
32462      1288033470,
32463      3409855158,
32464      1501505948,
32465      4234509866,
32466      1607167915,
32467      987167468,
32468      1816402316,
32469      1246189591
32470    ];
32471    function SHA512() {
32472      if (!(this instanceof SHA512))
32473        return new SHA512();
32474      BlockHash.call(this);
32475      this.h = [
32476        1779033703,
32477        4089235720,
32478        3144134277,
32479        2227873595,
32480        1013904242,
32481        4271175723,
32482        2773480762,
32483        1595750129,
32484        1359893119,
32485        2917565137,
32486        2600822924,
32487        725511199,
32488        528734635,
32489        4215389547,
32490        1541459225,
32491        327033209
32492      ];
32493      this.k = sha512_K;
32494      this.W = new Array(160);
32495    }
32496    utils2.inherits(SHA512, BlockHash);
32497    _512 = SHA512;
32498    SHA512.blockSize = 1024;
32499    SHA512.outSize = 512;
32500    SHA512.hmacStrength = 192;
32501    SHA512.padLength = 128;
32502    SHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {
32503      var W = this.W;
32504      for (var i2 = 0; i2 < 32; i2++)
32505        W[i2] = msg[start + i2];
32506      for (; i2 < W.length; i2 += 2) {
32507        var c0_hi = g1_512_hi(W[i2 - 4], W[i2 - 3]);
32508        var c0_lo = g1_512_lo(W[i2 - 4], W[i2 - 3]);
32509        var c1_hi = W[i2 - 14];
32510        var c1_lo = W[i2 - 13];
32511        var c2_hi = g0_512_hi(W[i2 - 30], W[i2 - 29]);
32512        var c2_lo = g0_512_lo(W[i2 - 30], W[i2 - 29]);
32513        var c3_hi = W[i2 - 32];
32514        var c3_lo = W[i2 - 31];
32515        W[i2] = sum64_4_hi(
32516          c0_hi,
32517          c0_lo,
32518          c1_hi,
32519          c1_lo,
32520          c2_hi,
32521          c2_lo,
32522          c3_hi,
32523          c3_lo
32524        );
32525        W[i2 + 1] = sum64_4_lo(
32526          c0_hi,
32527          c0_lo,
32528          c1_hi,
32529          c1_lo,
32530          c2_hi,
32531          c2_lo,
32532          c3_hi,
32533          c3_lo
32534        );
32535      }
32536    };
32537    SHA512.prototype._update = function _update(msg, start) {
32538      this._prepareBlock(msg, start);
32539      var W = this.W;
32540      var ah = this.h[0];
32541      var al = this.h[1];
32542      var bh = this.h[2];
32543      var bl = this.h[3];
32544      var ch = this.h[4];
32545      var cl = this.h[5];
32546      var dh = this.h[6];
32547      var dl = this.h[7];
32548      var eh = this.h[8];
32549      var el = this.h[9];
32550      var fh = this.h[10];
32551      var fl = this.h[11];
32552      var gh = this.h[12];
32553      var gl = this.h[13];
32554      var hh = this.h[14];
32555      var hl = this.h[15];
32556      assert2(this.k.length === W.length);
32557      for (var i2 = 0; i2 < W.length; i2 += 2) {
32558        var c0_hi = hh;
32559        var c0_lo = hl;
32560        var c1_hi = s1_512_hi(eh, el);
32561        var c1_lo = s1_512_lo(eh, el);
32562        var c2_hi = ch64_hi(eh, el, fh, fl, gh);
32563        var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);
32564        var c3_hi = this.k[i2];
32565        var c3_lo = this.k[i2 + 1];
32566        var c4_hi = W[i2];
32567        var c4_lo = W[i2 + 1];
32568        var T1_hi = sum64_5_hi(
32569          c0_hi,
32570          c0_lo,
32571          c1_hi,
32572          c1_lo,
32573          c2_hi,
32574          c2_lo,
32575          c3_hi,
32576          c3_lo,
32577          c4_hi,
32578          c4_lo
32579        );
32580        var T1_lo = sum64_5_lo(
32581          c0_hi,
32582          c0_lo,
32583          c1_hi,
32584          c1_lo,
32585          c2_hi,
32586          c2_lo,
32587          c3_hi,
32588          c3_lo,
32589          c4_hi,
32590          c4_lo
32591        );
32592        c0_hi = s0_512_hi(ah, al);
32593        c0_lo = s0_512_lo(ah, al);
32594        c1_hi = maj64_hi(ah, al, bh, bl, ch);
32595        c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);
32596        var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);
32597        var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);
32598        hh = gh;
32599        hl = gl;
32600        gh = fh;
32601        gl = fl;
32602        fh = eh;
32603        fl = el;
32604        eh = sum64_hi(dh, dl, T1_hi, T1_lo);
32605        el = sum64_lo(dl, dl, T1_hi, T1_lo);
32606        dh = ch;
32607        dl = cl;
32608        ch = bh;
32609        cl = bl;
32610        bh = ah;
32611        bl = al;
32612        ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);
32613        al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);
32614      }
32615      sum64(this.h, 0, ah, al);
32616      sum64(this.h, 2, bh, bl);
32617      sum64(this.h, 4, ch, cl);
32618      sum64(this.h, 6, dh, dl);
32619      sum64(this.h, 8, eh, el);
32620      sum64(this.h, 10, fh, fl);
32621      sum64(this.h, 12, gh, gl);
32622      sum64(this.h, 14, hh, hl);
32623    };
32624    SHA512.prototype._digest = function digest(enc) {
32625      if (enc === "hex")

32626        return utils2.toHex32(this.h, "big");
32627      else
32628        return utils2.split32(this.h, "big");
32629    };
32630    function ch64_hi(xh, xl, yh, yl, zh) {
32631      var r = xh & yh ^ ~xh & zh;
32632      if (r < 0)
32633        r += 4294967296;
32634      return r;
32635    }
32636    function ch64_lo(xh, xl, yh, yl, zh, zl) {
32637      var r = xl & yl ^ ~xl & zl;
32638      if (r < 0)
32639        r += 4294967296;
32640      return r;
32641    }
32642    function maj64_hi(xh, xl, yh, yl, zh) {
32643      var r = xh & yh ^ xh & zh ^ yh & zh;
32644      if (r < 0)
32645        r += 4294967296;
32646      return r;
32647    }
32648    function maj64_lo(xh, xl, yh, yl, zh, zl) {
32649      var r = xl & yl ^ xl & zl ^ yl & zl;
32650      if (r < 0)
32651        r += 4294967296;
32652      return r;
32653    }
32654    function s0_512_hi(xh, xl) {
32655      var c0_hi = rotr64_hi(xh, xl, 28);
32656      var c1_hi = rotr64_hi(xl, xh, 2);
32657      var c2_hi = rotr64_hi(xl, xh, 7);
32658      var r = c0_hi ^ c1_hi ^ c2_hi;
32659      if (r < 0)
32660        r += 4294967296;
32661      return r;
32662    }
32663    function s0_512_lo(xh, xl) {
32664      var c0_lo = rotr64_lo(xh, xl, 28);
32665      var c1_lo = rotr64_lo(xl, xh, 2);
32666      var c2_lo = rotr64_lo(xl, xh, 7);
32667      var r = c0_lo ^ c1_lo ^ c2_lo;
32668      if (r < 0)
32669        r += 4294967296;
32670      return r;
32671    }
32672    function s1_512_hi(xh, xl) {
32673      var c0_hi = rotr64_hi(xh, xl, 14);
32674      var c1_hi = rotr64_hi(xh, xl, 18);
32675      var c2_hi = rotr64_hi(xl, xh, 9);
32676      var r = c0_hi ^ c1_hi ^ c2_hi;
32677      if (r < 0)
32678        r += 4294967296;
32679      return r;
32680    }
32681    function s1_512_lo(xh, xl) {
32682      var c0_lo = rotr64_lo(xh, xl, 14);
32683      var c1_lo = rotr64_lo(xh, xl, 18);
32684      var c2_lo = rotr64_lo(xl, xh, 9);
32685      var r = c0_lo ^ c1_lo ^ c2_lo;
32686      if (r < 0)
32687        r += 4294967296;
32688      return r;
32689    }
32690    function g0_512_hi(xh, xl) {
32691      var c0_hi = rotr64_hi(xh, xl, 1);
32692      var c1_hi = rotr64_hi(xh, xl, 8);
32693      var c2_hi = shr64_hi(xh, xl, 7);
32694      var r = c0_hi ^ c1_hi ^ c2_hi;
32695      if (r < 0)
32696        r += 4294967296;
32697      return r;
32698    }
32699    function g0_512_lo(xh, xl) {
32700      var c0_lo = rotr64_lo(xh, xl, 1);
32701      var c1_lo = rotr64_lo(xh, xl, 8);
32702      var c2_lo = shr64_lo(xh, xl, 7);
32703      var r = c0_lo ^ c1_lo ^ c2_lo;
32704      if (r < 0)
32705        r += 4294967296;
32706      return r;
32707    }
32708    function g1_512_hi(xh, xl) {
32709      var c0_hi = rotr64_hi(xh, xl, 19);
32710      var c1_hi = rotr64_hi(xl, xh, 29);
32711      var c2_hi = shr64_hi(xh, xl, 6);
32712      var r = c0_hi ^ c1_hi ^ c2_hi;
32713      if (r < 0)
32714        r += 4294967296;
32715      return r;
32716    }
32717    function g1_512_lo(xh, xl) {
32718      var c0_lo = rotr64_lo(xh, xl, 19);
32719      var c1_lo = rotr64_lo(xl, xh, 29);
32720      var c2_lo = shr64_lo(xh, xl, 6);
32721      var r = c0_lo ^ c1_lo ^ c2_lo;
32722      if (r < 0)
32723        r += 4294967296;
32724      return r;
32725    }
32726    return _512;
32727  }
32728  var _384;
32729  var hasRequired_384;
32730  function require_384() {
32731    if (hasRequired_384) return _384;
32732    hasRequired_384 = 1;
32733    var utils2 = requireUtils();
32734    var SHA512 = require_512();
32735    function SHA384() {
32736      if (!(this instanceof SHA384))
32737        return new SHA384();
32738      SHA512.call(this);
32739      this.h = [
32740        3418070365,
32741        3238371032,
32742        1654270250,
32743        914150663,
32744        2438529370,
32745        812702999,
32746        355462360,
32747        4144912697,
32748        1731405415,
32749        4290775857,
32750        2394180231,
32751        1750603025,
32752        3675008525,
32753        1694076839,
32754        1203062813,
32755        3204075428
32756      ];
32757    }
32758    utils2.inherits(SHA384, SHA512);
32759    _384 = SHA384;
32760    SHA384.blockSize = 1024;
32761    SHA384.outSize = 384;
32762    SHA384.hmacStrength = 192;
32763    SHA384.padLength = 128;
32764    SHA384.prototype._digest = function digest(enc) {
32765      if (enc === "hex")
32766        return utils2.toHex32(this.h.slice(0, 12), "big");
32767      else
32768        return utils2.split32(this.h.slice(0, 12), "big");
32769    };
32770    return _384;
32771  }
32772  var hasRequiredSha;
32773  function requireSha() {
32774    if (hasRequiredSha) return sha;
32775    hasRequiredSha = 1;
32776    sha.sha1 = require_1();
32777    sha.sha224 = require_224();
32778    sha.sha256 = require_256();
32779    sha.sha384 = require_384();
32780    sha.sha512 = require_512();
32781    return sha;
32782  }
32783  var ripemd = {};
32784  var hasRequiredRipemd;
32785  function requireRipemd() {
32786    if (hasRequiredRipemd) return ripemd;
32787    hasRequiredRipemd = 1;
32788    var utils2 = requireUtils();
32789    var common2 = requireCommon$3();
32790    var rotl32 = utils2.rotl32;
32791    var sum32 = utils2.sum32;
32792    var sum32_3 = utils2.sum32_3;
32793    var sum32_4 = utils2.sum32_4;

vendor: 11,523 bytes, lines 32794-33372

32794    var BlockHash = common2.BlockHash;
32795    function RIPEMD160() {
32796      if (!(this instanceof RIPEMD160))
32797        return new RIPEMD160();
32798      BlockHash.call(this);
32799      this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
32800      this.endian = "little";
32801    }
32802    utils2.inherits(RIPEMD160, BlockHash);
32803    ripemd.ripemd160 = RIPEMD160;
32804    RIPEMD160.blockSize = 512;
32805    RIPEMD160.outSize = 160;
32806    RIPEMD160.hmacStrength = 192;
32807    RIPEMD160.padLength = 64;
32808    RIPEMD160.prototype._update = function update(msg, start) {
32809      var A = this.h[0];
32810      var B = this.h[1];
32811      var C = this.h[2];
32812      var D = this.h[3];
32813      var E = this.h[4];
32814      var Ah = A;
32815      var Bh = B;
32816      var Ch = C;
32817      var Dh = D;
32818      var Eh = E;
32819      for (var j = 0; j < 80; j++) {
32820        var T = sum32(
32821          rotl32(
32822            sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),
32823            s[j]
32824          ),
32825          E
32826        );
32827        A = E;
32828        E = D;
32829        D = rotl32(C, 10);
32830        C = B;
32831        B = T;
32832        T = sum32(
32833          rotl32(
32834            sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),
32835            sh[j]
32836          ),
32837          Eh
32838        );
32839        Ah = Eh;
32840        Eh = Dh;
32841        Dh = rotl32(Ch, 10);
32842        Ch = Bh;
32843        Bh = T;
32844      }
32845      T = sum32_3(this.h[1], C, Dh);
32846      this.h[1] = sum32_3(this.h[2], D, Eh);
32847      this.h[2] = sum32_3(this.h[3], E, Ah);
32848      this.h[3] = sum32_3(this.h[4], A, Bh);
32849      this.h[4] = sum32_3(this.h[0], B, Ch);
32850      this.h[0] = T;
32851    };
32852    RIPEMD160.prototype._digest = function digest(enc) {
32853      if (enc === "hex")
32854        return utils2.toHex32(this.h, "little");
32855      else
32856        return utils2.split32(this.h, "little");
32857    };
32858    function f(j, x, y, z) {
32859      if (j <= 15)
32860        return x ^ y ^ z;
32861      else if (j <= 31)
32862        return x & y | ~x & z;
32863      else if (j <= 47)
32864        return (x | ~y) ^ z;
32865      else if (j <= 63)
32866        return x & z | y & ~z;
32867      else
32868        return x ^ (y | ~z);
32869    }
32870    function K(j) {
32871      if (j <= 15)
32872        return 0;
32873      else if (j <= 31)
32874        return 1518500249;
32875      else if (j <= 47)
32876        return 1859775393;
32877      else if (j <= 63)
32878        return 2400959708;
32879      else
32880        return 2840853838;
32881    }
32882    function Kh(j) {
32883      if (j <= 15)
32884        return 1352829926;
32885      else if (j <= 31)
32886        return 1548603684;
32887      else if (j <= 47)
32888        return 1836072691;
32889      else if (j <= 63)
32890        return 2053994217;
32891      else
32892        return 0;
32893    }
32894    var r = [
32895      0,
32896      1,
32897      2,
32898      3,
32899      4,
32900      5,
32901      6,
32902      7,
32903      8,
32904      9,
32905      10,
32906      11,
32907      12,
32908      13,
32909      14,
32910      15,
32911      7,
32912      4,
32913      13,
32914      1,
32915      10,
32916      6,
32917      15,
32918      3,
32919      12,
32920      0,
32921      9,
32922      5,
32923      2,
32924      14,
32925      11,
32926      8,
32927      3,
32928      10,
32929      14,
32930      4,
32931      9,
32932      15,
32933      8,
32934      1,
32935      2,
32936      7,
32937      0,
32938      6,
32939      13,
32940      11,
32941      5,
32942      12,
32943      1,
32944      9,
32945      11,
32946      10,
32947      0,
32948      8,
32949      12,
32950      4,
32951      13,
32952      3,
32953      7,
32954      15,
32955      14,
32956      5,
32957      6,
32958      2,
32959      4,
32960      0,
32961      5,
32962      9,
32963      7,
32964      12,
32965      2,
32966      10,
32967      14,
32968      1,
32969      3,
32970      8,
32971      11,
32972      6,
32973      15,
32974      13
32975    ];
32976    var rh = [
32977      5,
32978      14,
32979      7,
32980      0,
32981      9,
32982      2,
32983      11,
32984      4,
32985      13,
32986      6,
32987      15,
32988      8,
32989      1,
32990      10,
32991      3,
32992      12,
32993      6,
32994      11,
32995      3,
32996      7,
32997      0,
32998      13,
32999      5,
33000      10,
33001      14,
33002      15,
33003      8,
33004      12,
33005      4,
33006      9,
33007      1,
33008      2,
33009      15,
33010      5,
33011      1,
33012      3,
33013      7,
33014      14,
33015      6,
33016      9,
33017      11,
33018      8,
33019      12,
33020      2,
33021      10,
33022      0,
33023      4,
33024      13,
33025      8,
33026      6,
33027      4,
33028      1,
33029      3,
33030      11,
33031      15,
33032      0,
33033      5,
33034      12,
33035      2,
33036      13,
33037      9,
33038      7,
33039      10,
33040      14,
33041      12,
33042      15,
33043      10,
33044      4,
33045      1,
33046      5,
33047      8,
33048      7,
33049      6,
33050      2,
33051      13,
33052      14,
33053      0,
33054      3,
33055      9,
33056      11
33057    ];
33058    var s = [
33059      11,
33060      14,
33061      15,
33062      12,
33063      5,
33064      8,
33065      7,
33066      9,
33067      11,
33068      13,
33069      14,
33070      15,
33071      6,
33072      7,
33073      9,
33074      8,
33075      7,
33076      6,
33077      8,
33078      13,
33079      11,
33080      9,
33081      7,
33082      15,
33083      7,
33084      12,
33085      15,
33086      9,
33087      11,
33088      7,
33089      13,
33090      12,
33091      11,
33092      13,
33093      6,
33094      7,
33095      14,
33096      9,
33097      13,
33098      15,
33099      14,
33100      8,
33101      13,
33102      6,
33103      5,
33104      12,
33105      7,
33106      5,
33107      11,
33108      12,
33109      14,
33110      15,
33111      14,
33112      15,
33113      9,
33114      8,
33115      9,
33116      14,
33117      5,
33118      6,
33119      8,
33120      6,
33121      5,
33122      12,
33123      9,
33124      15,
33125      5,
33126      11,
33127      6,
33128      8,
33129      13,
33130      12,
33131      5,
33132      12,
33133      13,
33134      14,
33135      11,
33136      8,
33137      5,
33138      6
33139    ];
33140    var sh = [
33141      8,
33142      9,
33143      9,
33144      11,
33145      13,
33146      15,
33147      15,
33148      5,
33149      7,
33150      7,
33151      8,
33152      11,
33153      14,
33154      14,
33155      12,
33156      6,
33157      9,
33158      13,
33159      15,
33160      7,
33161      12,
33162      8,
33163      9,
33164      11,
33165      7,
33166      7,
33167      12,
33168      7,
33169      6,
33170      15,
33171      13,
33172      11,
33173      9,
33174      7,
33175      15,
33176      11,
33177      8,
33178      6,
33179      6,
33180      14,
33181      12,
33182      13,
33183      5,
33184      14,
33185      13,
33186      13,
33187      7,
33188      5,
33189      15,
33190      5,
33191      8,
33192      11,
33193      14,
33194      14,
33195      6,
33196      14,
33197      6,
33198      9,
33199      12,
33200      9,
33201      12,
33202      5,
33203      15,
33204      8,
33205      8,
33206      5,
33207      12,
33208      9,
33209      12,
33210      5,
33211      14,
33212      6,
33213      8,
33214      13,
33215      6,
33216      5,
33217      15,
33218      13,
33219      11,
33220      11
33221    ];
33222    return ripemd;
33223  }
33224  var hmac;
33225  var hasRequiredHmac;
33226  function requireHmac() {
33227    if (hasRequiredHmac) return hmac;
33228    hasRequiredHmac = 1;
33229    var utils2 = requireUtils();
33230    var assert2 = requireMinimalisticAssert();
33231    function Hmac(hash2, key2, enc) {
33232      if (!(this instanceof Hmac))
33233        return new Hmac(hash2, key2, enc);
33234      this.Hash = hash2;
33235      this.blockSize = hash2.blockSize / 8;
33236      this.outSize = hash2.outSize / 8;
33237      this.inner = null;
33238      this.outer = null;
33239      this._init(utils2.toArray(key2, enc));
33240    }
33241    hmac = Hmac;
33242    Hmac.prototype._init = function init(key2) {
33243      if (key2.length > this.blockSize)
33244        key2 = new this.Hash().update(key2).digest();
33245      assert2(key2.length <= this.blockSize);
33246      for (var i2 = key2.length; i2 < this.blockSize; i2++)
33247        key2.push(0);
33248      for (i2 = 0; i2 < key2.length; i2++)
33249        key2[i2] ^= 54;
33250      this.inner = new this.Hash().update(key2);
33251      for (i2 = 0; i2 < key2.length; i2++)
33252        key2[i2] ^= 106;
33253      this.outer = new this.Hash().update(key2);
33254    };
33255    Hmac.prototype.update = function update(msg, enc) {
33256      this.inner.update(msg, enc);
33257      return this;
33258    };
33259    Hmac.prototype.digest = function digest(enc) {
33260      this.outer.update(this.inner.digest());
33261      return this.outer.digest(enc);
33262    };
33263    return hmac;
33264  }
33265  var hasRequiredHash;
33266  function requireHash() {
33267    if (hasRequiredHash) return hash;
33268    hasRequiredHash = 1;
33269    (function(exports$12) {
33270      var hash2 = exports$12;
33271      hash2.utils = requireUtils();
33272      hash2.common = requireCommon$3();
33273      hash2.sha = requireSha();
33274      hash2.ripemd = requireRipemd();
33275      hash2.hmac = requireHmac();
33276      hash2.sha1 = hash2.sha.sha1;
33277      hash2.sha256 = hash2.sha.sha256;
33278      hash2.sha224 = hash2.sha.sha224;
33279      hash2.sha384 = hash2.sha.sha384;
33280      hash2.sha512 = hash2.sha.sha512;
33281      hash2.ripemd160 = hash2.ripemd.ripemd160;
33282    })(hash);
33283    return hash;
33284  }
33285  var secp256k1;
33286  var hasRequiredSecp256k1;
33287  function requireSecp256k1() {
33288    if (hasRequiredSecp256k1) return secp256k1;
33289    hasRequiredSecp256k1 = 1;
33290    secp256k1 = {
33291      doubles: {
33292        step: 4,
33293        points: [
33294          [
33295            "e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a",
33296            "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821"
33297          ],
33298          [
33299            "8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508",
33300            "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf"
33301          ],
33302          [
33303            "175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739",
33304            "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695"
33305          ],
33306          [
33307            "363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640",
33308            "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9"
33309          ],
33310          [
33311            "8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c",
33312            "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36"
33313          ],
33314          [
33315            "723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda",
33316            "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f"
33317          ],
33318          [
33319            "eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa",
33320            "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999"
33321          ],
33322          [
33323            "100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0",
33324            "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09"
33325          ],
33326          [
33327            "e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d",
33328            "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d"
33329          ],
33330          [
33331            "feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d",
33332            "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088"
33333          ],
33334          [
33335            "da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1",
33336            "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d"
33337          ],
33338          [
33339            "53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0",
33340            "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8"
33341          ],
33342          [
33343            "8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047",
33344            "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a"
33345          ],
33346          [
33347            "385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862",
33348            "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453"
33349          ],
33350          [
33351            "6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7",
33352            "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160"
33353          ],
33354          [
33355            "3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd",
33356            "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0"
33357          ],
33358          [
33359            "85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83",
33360            "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6"
33361          ],
33362          [
33363            "948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a",
33364            "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589"
33365          ],
33366          [
33367            "6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8",
33368            "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17"
33369          ],
33370          [
33371            "e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d",
33372            "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda"

33373          ],
33374          [
33375            "e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725",
33376            "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd"
33377          ],
33378          [
33379            "213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754",
33380            "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2"
33381          ],
33382          [
33383            "4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c",
33384            "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6"
33385          ],
33386          [
33387            "fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6",
33388            "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f"
33389          ],
33390          [
33391            "76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39",
33392            "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01"
33393          ],
33394          [
33395            "c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891",
33396            "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3"
33397          ],
33398          [
33399            "d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b",
33400            "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f"
33401          ],
33402          [
33403            "b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03",
33404            "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7"
33405          ],
33406          [
33407            "e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d",
33408            "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78"
33409          ],
33410          [
33411            "a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070",
33412            "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1"
33413          ],
33414          [
33415            "90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4",
33416            "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150"
33417          ],
33418          [
33419            "8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da",
33420            "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82"
33421          ],
33422          [
33423            "e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11",
33424            "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc"
33425          ],
33426          [
33427            "8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e",
33428            "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b"
33429          ],
33430          [
33431            "e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41",
33432            "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51"
33433          ],
33434          [
33435            "b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef",
33436            "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45"
33437          ],
33438          [
33439            "d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8",
33440            "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120"
33441          ],
33442          [
33443            "324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d",
33444            "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84"
33445          ],
33446          [
33447            "4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96",
33448            "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d"
33449          ],
33450          [
33451            "9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd",
33452            "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d"
33453          ],
33454          [
33455            "6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5",
33456            "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8"
33457          ],
33458          [
33459            "a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266",
33460            "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8"
33461          ],
33462          [
33463            "7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71",
33464            "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac"
33465          ],
33466          [
33467            "928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac",
33468            "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f"
33469          ],
33470          [
33471            "85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751",
33472            "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962"
33473          ],
33474          [
33475            "ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e",
33476            "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907"
33477          ],
33478          [
33479            "827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241",
33480            "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec"
33481          ],
33482          [
33483            "eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3",
33484            "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5a

33484d93d"
33485          ],
33486          [
33487            "e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f",
33488            "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414"
33489          ],
33490          [
33491            "1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19",
33492            "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd"
33493          ],
33494          [
33495            "146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be",
33496            "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0"
33497          ],
33498          [
33499            "fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9",
33500            "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811"
33501          ],
33502          [
33503            "da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2",
33504            "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1"
33505          ],
33506          [
33507            "a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13",
33508            "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c"
33509          ],
33510          [
33511            "174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c",
33512            "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73"
33513          ],
33514          [
33515            "959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba",
33516            "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd"
33517          ],
33518          [
33519            "d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151",
33520            "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405"
33521          ],
33522          [
33523            "64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073",
33524            "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589"
33525          ],
33526          [
33527            "8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458",
33528            "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e"
33529          ],
33530          [
33531            "13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b",
33532            "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27"
33533          ],
33534          [
33535            "bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366",
33536            "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1"
33537          ],
33538          [
33539            "8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa",
33540            "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482"
33541          ],
33542          [
33543            "8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0",
33544            "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945"
33545          ],
33546          [
33547            "dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787",
33548            "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573"
33549          ],
33550          [
33551            "f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e",
33552            "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82"
33553          ]
33554        ]
33555      },
33556      naf: {
33557        wnd: 7,
33558        points: [
33559          [
33560            "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9",
33561            "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672"
33562          ],
33563          [
33564            "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4",
33565            "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6"
33566          ],
33567          [
33568            "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc",
33569            "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da"
33570          ],
33571          [
33572            "acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe",
33573            "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37"
33574          ],
33575          [
33576            "774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb",
33577            "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b"
33578          ],
33579          [
33580            "f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8",
33581            "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81"
33582          ],
33583          [
33584            "d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e",
33585            "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58"
33586          ],
33587          [
33588            "defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34",
33589            "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77"
33590          ],
33591          [
33592            "2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c",
33593            "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a"

33594          ],
33595          [
33596            "352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5",
33597            "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c"
33598          ],
33599          [
33600            "2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f",
33601            "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67"
33602          ],
33603          [
33604            "9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714",
33605            "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402"
33606          ],
33607          [
33608            "daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729",
33609            "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55"
33610          ],
33611          [
33612            "c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db",
33613            "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482"
33614          ],
33615          [
33616            "6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4",
33617            "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82"
33618          ],
33619          [
33620            "1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5",
33621            "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396"
33622          ],
33623          [
33624            "605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479",
33625            "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49"
33626          ],
33627          [
33628            "62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d",
33629            "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf"
33630          ],
33631          [
33632            "80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f",
33633            "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a"
33634          ],
33635          [
33636            "7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb",
33637            "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7"
33638          ],
33639          [
33640            "d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9",
33641            "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933"
33642          ],
33643          [
33644            "49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963",
33645            "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a"
33646          ],
33647          [
33648            "77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74",
33649            "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6"
33650          ],
33651          [
33652            "f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530",
33653            "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37"
33654          ],
33655          [
33656            "463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b",
33657            "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e"
33658          ],
33659          [
33660            "f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247",
33661            "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6"
33662          ],
33663          [
33664            "caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1",
33665            "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476"
33666          ],
33667          [
33668            "2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120",
33669            "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40"
33670          ],
33671          [
33672            "7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435",
33673            "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61"
33674          ],
33675          [
33676            "754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18",
33677            "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683"
33678          ],
33679          [
33680            "e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8",
33681            "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5"
33682          ],
33683          [
33684            "186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb",
33685            "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b"
33686          ],
33687          [
33688            "df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f",
33689            "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417"
33690          ],
33691          [
33692            "5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143",
33693            "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868"
33694          ],
33695          [
33696            "290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba",
33697            "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a"
33698          ],
33699          [
33700            "af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45",
33701            "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6"
33702          ],
33703          [
33704            "766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a",
33705            "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996"
33706          ],
33707          [
33708            "59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e",
33709            "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e"
33710          ],
33711          [
33712            "f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8",
33713            "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d"
33714          ],
33715          [
33716            "7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c",
33717            "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2"
33718          ],
33719          [
33720            "948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519",
33721            "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e"
33722          ],
33723          [
33724            "7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab",
33725            "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437"
33726          ],
33727          [
33728            "3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca",
33729            "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311"
33730          ],
33731          [
33732            "d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf",
33733            "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4"
33734          ],
33735          [
33736            "1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610",
33737            "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575"
33738          ],
33739          [

33740            "733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4",
33741            "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d"
33742          ],
33743          [
33744            "15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c",
33745            "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d"
33746          ],
33747          [
33748            "a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940",
33749            "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629"
33750          ],
33751          [
33752            "e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980",
33753            "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06"
33754          ],
33755          [
33756            "311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3",
33757            "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374"
33758          ],
33759          [
33760            "34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf",
33761            "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee"
33762          ],
33763          [
33764            "f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63",
33765            "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1"
33766          ],
33767          [
33768            "d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448",
33769            "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b"
33770          ],
33771          [
33772            "32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf",
33773            "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661"
33774          ],
33775          [
33776            "7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5",
33777            "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6"
33778          ],
33779          [
33780            "ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6",
33781            "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e"
33782          ],
33783          [
33784            "16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5",
33785            "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d"
33786          ],
33787          [
33788            "eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99",
33789            "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc"
33790          ],
33791          [
33792            "78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51",
33793            "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4"
33794          ],
33795          [
33796            "494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5",
33797            "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c"
33798          ],
33799          [
33800            "a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5",
33801            "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b"
33802          ],
33803          [
33804            "c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997",
33805            "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913"
33806          ],
33807          [
33808            "841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881",
33809            "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154"
33810          ],
33811          [
33812            "5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5",
33813            "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865"
33814          ],
33815          [
33816            "36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66",
33817            "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc"
33818          ],
33819          [
33820            "336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726",
33821            "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224"
33822          ],
33823          [
33824            "8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede",
33825            "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e"
33826          ],
33827          [
33828            "1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94",
33829            "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6"
33830          ],
33831          [
33832            "85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31",
33833            "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511"
33834          ],
33835          [
33836            "29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51",
33837            "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b"
33838          ],
33839          [

33840            "a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252",
33841            "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2"
33842          ],
33843          [
33844            "4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5",
33845            "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c"
33846          ],
33847          [
33848            "d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b",
33849            "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3"
33850          ],
33851          [
33852            "ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4",
33853            "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d"
33854          ],
33855          [
33856            "af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f",
33857            "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700"
33858          ],
33859          [
33860            "e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889",
33861            "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4"
33862          ],
33863          [
33864            "591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246",
33865            "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196"
33866          ],
33867          [
33868            "11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984",
33869            "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4"
33870          ],
33871          [
33872            "3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a",
33873            "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257"
33874          ],
33875          [
33876            "cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030",
33877            "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13"
33878          ],
33879          [
33880            "c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197",
33881            "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096"
33882          ],
33883          [
33884            "c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593",
33885            "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38"
33886          ],
33887          [
33888            "a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef",
33889            "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f"
33890          ],
33891          [
33892            "347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38",
33893            "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448"
33894          ],
33895          [
33896            "da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a",
33897            "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a"
33898          ],
33899          [
33900            "c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111",
33901            "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4"
33902          ],
33903          [
33904            "4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502",
33905            "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437"
33906          ],
33907          [
33908            "3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea",
33909            "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7"
33910          ],
33911          [
33912            "cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26",
33913            "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d"
33914          ],
33915          [
33916            "b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986",
33917            "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a"
33918          ],
33919          [
33920            "d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e",
33921            "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54"
33922          ],
33923          [
33924            "48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4",
33925            "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77"
33926          ],
33927          [
33928            "dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda",
33929            "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517"
33930          ],
33931          [
33932            "6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859",
33933            "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10"
33934          ],
33935          [

33936            "e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f",
33937            "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125"
33938          ],
33939          [
33940            "eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c",
33941            "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e"
33942          ],
33943          [
33944            "13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942",
33945            "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1"
33946          ],
33947          [
33948            "ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a",
33949            "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2"
33950          ],
33951          [
33952            "b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80",
33953            "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423"
33954          ],
33955          [
33956            "ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d",
33957            "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8"
33958          ],
33959          [
33960            "8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1",
33961            "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758"
33962          ],
33963          [
33964            "52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63",
33965            "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375"
33966          ],
33967          [
33968            "e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352",
33969            "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d"
33970          ],
33971          [
33972            "7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193",
33973            "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec"
33974          ],
33975          [
33976            "5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00",
33977            "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0"
33978          ],
33979          [
33980            "32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58",
33981            "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c"
33982          ],
33983          [
33984            "e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7",
33985            "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4"
33986          ],
33987          [
33988            "8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8",
33989            "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f"
33990          ],
33991          [
33992            "4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e",
33993            "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649"
33994          ],
33995          [
33996            "3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d",
33997            "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826"
33998          ],
33999          [
34000            "674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b",
34001            "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5"
34002          ],
34003          [
34004            "d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f",
34005            "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87"
34006          ],
34007          [
34008            "30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6",
34009            "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b"
34010          ],
34011          [
34012            "be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297",
34013            "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc"
34014          ],
34015          [
34016            "93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a",
34017            "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c"
34018          ],
34019          [
34020            "b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c",
34021            "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f"
34022          ],
34023          [
34024            "d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52",
34025            "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a"
34026          ],
34027          [
34028            "d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb",
34029            "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46"
34030          ],
34031          [
34032            "463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065",
34033            "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f"
34034          ],
34035          [
34036            "7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917",
34037            "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03"
34038          ],
34039          [
34040            "74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9",
34041            "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08"
34042          ],
34043          [
34044            "30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3",
34045            "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8"
34046          ],
34047          [
34048            "9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57",
34049            "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373"
34050          ],
34051          [
34052            "176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66",
34053            "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3"
34054          ],
34055          [

34056            "75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8",
34057            "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8"
34058          ],
34059          [
34060            "809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721",
34061            "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1"
34062          ],
34063          [
34064            "1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180",
34065            "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9"
34066          ]
34067        ]
34068      }
34069    };
34070    return secp256k1;
34071  }
34072  var hasRequiredCurves;
34073  function requireCurves() {
34074    if (hasRequiredCurves) return curves;
34075    hasRequiredCurves = 1;
34076    (function(exports$12) {
34077      var curves2 = exports$12;
34078      var hash2 = requireHash();
34079      var curve2 = requireCurve();
34080      var utils2 = requireUtils$1();
34081      var assert2 = utils2.assert;
34082      function PresetCurve(options) {
34083        if (options.type === "short")
34084          this.curve = new curve2.short(options);
34085        else if (options.type === "edwards")
34086          this.curve = new curve2.edwards(options);
34087        else
34088          this.curve = new curve2.mont(options);
34089        this.g = this.curve.g;
34090        this.n = this.curve.n;
34091        this.hash = options.hash;
34092        assert2(this.g.validate(), "Invalid curve");
34093        assert2(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O");
34094      }
34095      curves2.PresetCurve = PresetCurve;
34096      function defineCurve(name, options) {
34097        Object.defineProperty(curves2, name, {
34098          configurable: true,
34099          enumerable: true,
34100          get: function() {
34101            var curve3 = new PresetCurve(options);
34102            Object.defineProperty(curves2, name, {
34103              configurable: true,
34104              enumerable: true,
34105              value: curve3
34106            });
34107            return curve3;
34108          }
34109        });
34110      }
34111      defineCurve("p192", {
34112        type: "short",
34113        prime: "p192",
34114        p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff",
34115        a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc",
34116        b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1",
34117        n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831",
34118        hash: hash2.sha256,

34119        gRed: false,
34120        g: [
34121          "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012",
34122          "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811"
34123        ]
34124      });
34125      defineCurve("p224", {
34126        type: "short",
34127        prime: "p224",
34128        p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001",
34129        a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe",
34130        b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4",
34131        n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d",
34132        hash: hash2.sha256,
34133        gRed: false,
34134        g: [
34135          "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21",
34136          "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34"
34137        ]
34138      });
34139      defineCurve("p256", {
34140        type: "short",
34141        prime: null,
34142        p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff",
34143        a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc",
34144        b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b",
34145        n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551",
34146        hash: hash2.sha256,

34147        gRed: false,
34148        g: [
34149          "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296",
34150          "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5"
34151        ]
34152      });
34153      defineCurve("p384", {
34154        type: "short",
34155        prime: null,
34156        p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff",
34157        a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc",
34158        b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef",
34159        n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973",
34160        hash: hash2.sha384,
34161        gRed: false,
34162        g: [
34163          "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7",
34164          "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"
34165        ]
34166      });
34167      defineCurve("p521", {
34168        type: "short",
34169        prime: null,
34170        p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff",
34171        a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc",
34172        b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00",
34173        n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409",
34174        hash: hash2.sha512,

34175        gRed: false,
34176        g: [
34177          "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66",
34178          "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650"
34179        ]
34180      });
34181      defineCurve("curve25519", {
34182        type: "mont",
34183        prime: "p25519",
34184        p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
34185        a: "76d06",
34186        b: "1",
34187        n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
34188        hash: hash2.sha256,
34189        gRed: false,
34190        g: [
34191          "9"
34192        ]
34193      });
34194      defineCurve("ed25519", {
34195        type: "edwards",
34196        prime: "p25519",
34197        p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed",
34198        a: "-1",
34199        c: "1",
34200        // -121665 * (121666^(-1)) (mod P)
34201        d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3",
34202        n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed",
34203        hash: hash2.sha256,

34204        gRed: false,
34205        g: [
34206          "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a",
34207          // 4/5
34208          "6666666666666666666666666666666666666666666666666666666666666658"
34209        ]
34210      });
34211      var pre;
34212      try {
34213        pre = requireSecp256k1();
34214      } catch (e) {
34215        pre = void 0;
34216      }
34217      defineCurve("secp256k1", {
34218        type: "short",
34219        prime: "k256",
34220        p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f",
34221        a: "0",
34222        b: "7",
34223        n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141",
34224        h: "1",
34225        hash: hash2.sha256,
34226        // Precomputed endomorphism
34227        beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee",
34228        lambda: "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72",
34229        basis: [
34230          {
34231            a: "3086d221a7d46bcde86c90e49284eb15",
34232            b: "-e4437ed6010e88286f547fa90abfe4c3"
34233          },
34234          {
34235            a: "114ca50f7a8e2f3f657c1108d9d44cfd8",
34236            b: "3086d221a7d46bcde86c90e49284eb15"
34237          }
34238        ],

vendor: 14,916 bytes, lines 34239-34710

34239        gRed: false,
34240        g: [
34241          "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
34242          "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
34243          pre
34244        ]
34245      });
34246    })(curves);
34247    return curves;
34248  }
34249  var hmacDrbg;
34250  var hasRequiredHmacDrbg;
34251  function requireHmacDrbg() {
34252    if (hasRequiredHmacDrbg) return hmacDrbg;
34253    hasRequiredHmacDrbg = 1;
34254    var hash2 = requireHash();
34255    var utils2 = requireUtils$2();
34256    var assert2 = requireMinimalisticAssert();
34257    function HmacDRBG(options) {
34258      if (!(this instanceof HmacDRBG))
34259        return new HmacDRBG(options);
34260      this.hash = options.hash;
34261      this.predResist = !!options.predResist;
34262      this.outLen = this.hash.outSize;
34263      this.minEntropy = options.minEntropy || this.hash.hmacStrength;
34264      this._reseed = null;
34265      this.reseedInterval = null;
34266      this.K = null;
34267      this.V = null;
34268      var entropy = utils2.toArray(options.entropy, options.entropyEnc || "hex");
34269      var nonce = utils2.toArray(options.nonce, options.nonceEnc || "hex");
34270      var pers = utils2.toArray(options.pers, options.persEnc || "hex");
34271      assert2(
34272        entropy.length >= this.minEntropy / 8,
34273        "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
34274      );
34275      this._init(entropy, nonce, pers);
34276    }
34277    hmacDrbg = HmacDRBG;
34278    HmacDRBG.prototype._init = function init(entropy, nonce, pers) {
34279      var seed = entropy.concat(nonce).concat(pers);
34280      this.K = new Array(this.outLen / 8);
34281      this.V = new Array(this.outLen / 8);
34282      for (var i2 = 0; i2 < this.V.length; i2++) {
34283        this.K[i2] = 0;
34284        this.V[i2] = 1;
34285      }
34286      this._update(seed);
34287      this._reseed = 1;
34288      this.reseedInterval = 281474976710656;
34289    };
34290    HmacDRBG.prototype._hmac = function hmac2() {
34291      return new hash2.hmac(this.hash, this.K);
34292    };
34293    HmacDRBG.prototype._update = function update(seed) {
34294      var kmac = this._hmac().update(this.V).update([0]);
34295      if (seed)
34296        kmac = kmac.update(seed);
34297      this.K = kmac.digest();
34298      this.V = this._hmac().update(this.V).digest();
34299      if (!seed)
34300        return;
34301      this.K = this._hmac().update(this.V).update([1]).update(seed).digest();
34302      this.V = this._hmac().update(this.V).digest();
34303    };
34304    HmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {
34305      if (typeof entropyEnc !== "string") {
34306        addEnc = add;
34307        add = entropyEnc;
34308        entropyEnc = null;
34309      }
34310      entropy = utils2.toArray(entropy, entropyEnc);
34311      add = utils2.toArray(add, addEnc);
34312      assert2(
34313        entropy.length >= this.minEntropy / 8,
34314        "Not enough entropy. Minimum is: " + this.minEntropy + " bits"
34315      );
34316      this._update(entropy.concat(add || []));
34317      this._reseed = 1;
34318    };
34319    HmacDRBG.prototype.generate = function generate(len2, enc, add, addEnc) {
34320      if (this._reseed > this.reseedInterval)
34321        throw new Error("Reseed is required");
34322      if (typeof enc !== "string") {
34323        addEnc = add;
34324        add = enc;
34325        enc = null;
34326      }
34327      if (add) {
34328        add = utils2.toArray(add, addEnc || "hex");
34329        this._update(add);
34330      }
34331      var temp = [];
34332      while (temp.length < len2) {
34333        this.V = this._hmac().update(this.V).digest();
34334        temp = temp.concat(this.V);
34335      }
34336      var res = temp.slice(0, len2);
34337      this._update(add);
34338      this._reseed++;
34339      return utils2.encode(res, enc);
34340    };
34341    return hmacDrbg;
34342  }
34343  var key$1;
34344  var hasRequiredKey$1;
34345  function requireKey$1() {
34346    if (hasRequiredKey$1) return key$1;
34347    hasRequiredKey$1 = 1;
34348    var BN = requireBn$1();
34349    var utils2 = requireUtils$1();
34350    var assert2 = utils2.assert;
34351    function KeyPair(ec2, options) {
34352      this.ec = ec2;
34353      this.priv = null;
34354      this.pub = null;
34355      if (options.priv)
34356        this._importPrivate(options.priv, options.privEnc);
34357      if (options.pub)
34358        this._importPublic(options.pub, options.pubEnc);
34359    }
34360    key$1 = KeyPair;
34361    KeyPair.fromPublic = function fromPublic(ec2, pub, enc) {
34362      if (pub instanceof KeyPair)
34363        return pub;
34364      return new KeyPair(ec2, {
34365        pub,
34366        pubEnc: enc
34367      });
34368    };
34369    KeyPair.fromPrivate = function fromPrivate(ec2, priv, enc) {
34370      if (priv instanceof KeyPair)
34371        return priv;
34372      return new KeyPair(ec2, {
34373        priv,
34374        privEnc: enc
34375      });
34376    };
34377    KeyPair.prototype.validate = function validate() {
34378      var pub = this.getPublic();
34379      if (pub.isInfinity())
34380        return { result: false, reason: "Invalid public key" };
34381      if (!pub.validate())
34382        return { result: false, reason: "Public key is not a point" };
34383      if (!pub.mul(this.ec.curve.n).isInfinity())
34384        return { result: false, reason: "Public key * N != O" };
34385      return { result: true, reason: null };
34386    };
34387    KeyPair.prototype.getPublic = function getPublic(compact, enc) {
34388      if (typeof compact === "string") {
34389        enc = compact;
34390        compact = null;
34391      }
34392      if (!this.pub)
34393        this.pub = this.ec.g.mul(this.priv);
34394      if (!enc)
34395        return this.pub;
34396      return this.pub.encode(enc, compact);
34397    };
34398    KeyPair.prototype.getPrivate = function getPrivate(enc) {
34399      if (enc === "hex")
34400        return this.priv.toString(16, 2);
34401      else
34402        return this.priv;
34403    };
34404    KeyPair.prototype._importPrivate = function _importPrivate(key2, enc) {
34405      this.priv = new BN(key2, enc || 16);
34406      this.priv = this.priv.umod(this.ec.curve.n);
34407    };
34408    KeyPair.prototype._importPublic = function _importPublic(key2, enc) {
34409      if (key2.x || key2.y) {
34410        if (this.ec.curve.type === "mont") {
34411          assert2(key2.x, "Need x coordinate");
34412        } else if (this.ec.curve.type === "short" || this.ec.curve.type === "edwards") {
34413          assert2(key2.x && key2.y, "Need both x and y coordinate");
34414        }
34415        this.pub = this.ec.curve.point(key2.x, key2.y);
34416        return;
34417      }
34418      this.pub = this.ec.curve.decodePoint(key2, enc);
34419    };
34420    KeyPair.prototype.derive = function derive(pub) {
34421      if (!pub.validate()) {
34422        assert2(pub.validate(), "public point not validated");
34423      }
34424      return pub.mul(this.priv).getX();
34425    };
34426    KeyPair.prototype.sign = function sign2(msg, enc, options) {
34427      return this.ec.sign(msg, this, enc, options);
34428    };
34429    KeyPair.prototype.verify = function verify(msg, signature2, options) {
34430      return this.ec.verify(msg, signature2, this, void 0, options);
34431    };
34432    KeyPair.prototype.inspect = function inspect() {
34433      return "<Key priv: " + (this.priv && this.priv.toString(16, 2)) + " pub: " + (this.pub && this.pub.inspect()) + " >";
34434    };
34435    return key$1;
34436  }
34437  var signature$1;
34438  var hasRequiredSignature$1;
34439  function requireSignature$1() {
34440    if (hasRequiredSignature$1) return signature$1;
34441    hasRequiredSignature$1 = 1;
34442    var BN = requireBn$1();
34443    var utils2 = requireUtils$1();
34444    var assert2 = utils2.assert;
34445    function Signature(options, enc) {
34446      if (options instanceof Signature)
34447        return options;
34448      if (this._importDER(options, enc))
34449        return;
34450      assert2(options.r && options.s, "Signature without r or s");
34451      this.r = new BN(options.r, 16);
34452      this.s = new BN(options.s, 16);
34453      if (options.recoveryParam === void 0)
34454        this.recoveryParam = null;
34455      else
34456        this.recoveryParam = options.recoveryParam;
34457    }
34458    signature$1 = Signature;
34459    function Position() {
34460      this.place = 0;
34461    }
34462    function getLength(buf, p) {
34463      var initial = buf[p.place++];
34464      if (!(initial & 128)) {
34465        return initial;
34466      }
34467      var octetLen = initial & 15;
34468      if (octetLen === 0 || octetLen > 4) {
34469        return false;
34470      }
34471      if (buf[p.place] === 0) {
34472        return false;
34473      }
34474      var val = 0;
34475      for (var i2 = 0, off = p.place; i2 < octetLen; i2++, off++) {
34476        val <<= 8;
34477        val |= buf[off];
34478        val >>>= 0;
34479      }
34480      if (val <= 127) {
34481        return false;
34482      }
34483      p.place = off;
34484      return val;
34485    }
34486    function rmPadding(buf) {
34487      var i2 = 0;
34488      var len2 = buf.length - 1;
34489      while (!buf[i2] && !(buf[i2 + 1] & 128) && i2 < len2) {
34490        i2++;
34491      }
34492      if (i2 === 0) {
34493        return buf;
34494      }
34495      return buf.slice(i2);
34496    }
34497    Signature.prototype._importDER = function _importDER(data, enc) {
34498      data = utils2.toArray(data, enc);
34499      var p = new Position();
34500      if (data[p.place++] !== 48) {
34501        return false;
34502      }
34503      var len2 = getLength(data, p);
34504      if (len2 === false) {
34505        return false;
34506      }
34507      if (len2 + p.place !== data.length) {
34508        return false;
34509      }
34510      if (data[p.place++] !== 2) {
34511        return false;
34512      }
34513      var rlen = getLength(data, p);
34514      if (rlen === false) {
34515        return false;
34516      }
34517      if ((data[p.place] & 128) !== 0) {
34518        return false;
34519      }
34520      var r = data.slice(p.place, rlen + p.place);
34521      p.place += rlen;
34522      if (data[p.place++] !== 2) {
34523        return false;
34524      }
34525      var slen = getLength(data, p);
34526      if (slen === false) {
34527        return false;
34528      }
34529      if (data.length !== slen + p.place) {
34530        return false;
34531      }
34532      if ((data[p.place] & 128) !== 0) {
34533        return false;
34534      }
34535      var s = data.slice(p.place, slen + p.place);
34536      if (r[0] === 0) {
34537        if (r[1] & 128) {
34538          r = r.slice(1);
34539        } else {
34540          return false;
34541        }
34542      }
34543      if (s[0] === 0) {
34544        if (s[1] & 128) {
34545          s = s.slice(1);
34546        } else {
34547          return false;
34548        }
34549      }
34550      this.r = new BN(r);
34551      this.s = new BN(s);
34552      this.recoveryParam = null;
34553      return true;
34554    };
34555    function constructLength(arr, len2) {
34556      if (len2 < 128) {
34557        arr.push(len2);
34558        return;
34559      }
34560      var octets = 1 + (Math.log(len2) / Math.LN2 >>> 3);
34561      arr.push(octets | 128);
34562      while (--octets) {
34563        arr.push(len2 >>> (octets << 3) & 255);
34564      }
34565      arr.push(len2);
34566    }
34567    Signature.prototype.toDER = function toDER(enc) {
34568      var r = this.r.toArray();
34569      var s = this.s.toArray();
34570      if (r[0] & 128)
34571        r = [0].concat(r);
34572      if (s[0] & 128)
34573        s = [0].concat(s);
34574      r = rmPadding(r);
34575      s = rmPadding(s);
34576      while (!s[0] && !(s[1] & 128)) {
34577        s = s.slice(1);
34578      }
34579      var arr = [2];
34580      constructLength(arr, r.length);
34581      arr = arr.concat(r);
34582      arr.push(2);
34583      constructLength(arr, s.length);
34584      var backHalf = arr.concat(s);
34585      var res = [48];
34586      constructLength(res, backHalf.length);
34587      res = res.concat(backHalf);
34588      return utils2.encode(res, enc);
34589    };
34590    return signature$1;
34591  }
34592  var ec;
34593  var hasRequiredEc;
34594  function requireEc() {
34595    if (hasRequiredEc) return ec;
34596    hasRequiredEc = 1;
34597    var BN = requireBn$1();
34598    var HmacDRBG = requireHmacDrbg();
34599    var utils2 = requireUtils$1();
34600    var curves2 = requireCurves();
34601    var rand = requireBrorand();
34602    var assert2 = utils2.assert;
34603    var KeyPair = requireKey$1();
34604    var Signature = requireSignature$1();
34605    function EC(options) {
34606      if (!(this instanceof EC))
34607        return new EC(options);
34608      if (typeof options === "string") {
34609        assert2(
34610          Object.prototype.hasOwnProperty.call(curves2, options),
34611          "Unknown curve " + options
34612        );
34613        options = curves2[options];
34614      }
34615      if (options instanceof curves2.PresetCurve)
34616        options = { curve: options };
34617      this.curve = options.curve.curve;
34618      this.n = this.curve.n;
34619      this.nh = this.n.ushrn(1);
34620      this.g = this.curve.g;
34621      this.g = options.curve.g;
34622      this.g.precompute(options.curve.n.bitLength() + 1);
34623      this.hash = options.hash || options.curve.hash;
34624    }
34625    ec = EC;
34626    EC.prototype.keyPair = function keyPair(options) {
34627      return new KeyPair(this, options);
34628    };
34629    EC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {
34630      return KeyPair.fromPrivate(this, priv, enc);
34631    };
34632    EC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {
34633      return KeyPair.fromPublic(this, pub, enc);
34634    };
34635    EC.prototype.genKeyPair = function genKeyPair(options) {
34636      if (!options)
34637        options = {};
34638      var drbg = new HmacDRBG({
34639        hash: this.hash,
34640        pers: options.pers,
34641        persEnc: options.persEnc || "utf8",
34642        entropy: options.entropy || rand(this.hash.hmacStrength),
34643        entropyEnc: options.entropy && options.entropyEnc || "utf8",
34644        nonce: this.n.toArray()
34645      });
34646      var bytes = this.n.byteLength();
34647      var ns2 = this.n.sub(new BN(2));
34648      for (; ; ) {
34649        var priv = new BN(drbg.generate(bytes));
34650        if (priv.cmp(ns2) > 0)
34651          continue;
34652        priv.iaddn(1);
34653        return this.keyFromPrivate(priv);
34654      }
34655    };
34656    EC.prototype._truncateToN = function _truncateToN(msg, truncOnly, bitLength) {
34657      var byteLength2;
34658      if (BN.isBN(msg) || typeof msg === "number") {
34659        msg = new BN(msg, 16);
34660        byteLength2 = msg.byteLength();
34661      } else if (typeof msg === "object") {
34662        byteLength2 = msg.length;
34663        msg = new BN(msg, 16);
34664      } else {
34665        var str = msg.toString();
34666        byteLength2 = str.length + 1 >>> 1;
34667        msg = new BN(str, 16);
34668      }
34669      if (typeof bitLength !== "number") {
34670        bitLength = byteLength2 * 8;
34671      }
34672      var delta = bitLength - this.n.bitLength();
34673      if (delta > 0)
34674        msg = msg.ushrn(delta);
34675      if (!truncOnly && msg.cmp(this.n) >= 0)
34676        return msg.sub(this.n);
34677      else
34678        return msg;
34679    };
34680    EC.prototype.sign = function sign2(msg, key2, enc, options) {
34681      if (typeof enc === "object") {
34682        options = enc;
34683        enc = null;
34684      }
34685      if (!options)
34686        options = {};
34687      if (typeof msg !== "string" && typeof msg !== "number" && !BN.isBN(msg)) {
34688        assert2(
34689          typeof msg === "object" && msg && typeof msg.length === "number",
34690          "Expected message to be an array-like, a hex string, or a BN instance"
34691        );
34692        assert2(msg.length >>> 0 === msg.length);
34693        for (var i2 = 0; i2 < msg.length; i2++) assert2((msg[i2] & 255) === msg[i2]);
34694      }
34695      key2 = this.keyFromPrivate(key2, enc);
34696      msg = this._truncateToN(msg, false, options.msgBitLength);
34697      assert2(!msg.isNeg(), "Can not sign a negative message");
34698      var bytes = this.n.byteLength();
34699      var bkey = key2.getPrivate().toArray("be", bytes);
34700      var nonce = msg.toArray("be", bytes);
34701      assert2(new BN(nonce).eq(msg), "Can not sign message");
34702      var drbg = new HmacDRBG({
34703        hash: this.hash,
34704        entropy: bkey,
34705        nonce,
34706        pers: options.pers,
34707        persEnc: options.persEnc || "utf8"
34708      });
34709      var ns1 = this.n.sub(new BN(1));
34710      for (var iter = 0; ; iter++) {

vendor: 6,921 bytes, lines 34711-34907

34711        var k = options.k ? options.k(iter) : new BN(drbg.generate(this.n.byteLength()));
34712        k = this._truncateToN(k, true);
34713        if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)
34714          continue;
34715        var kp = this.g.mul(k);
34716        if (kp.isInfinity())
34717          continue;
34718        var kpX = kp.getX();
34719        var r = kpX.umod(this.n);
34720        if (r.cmpn(0) === 0)
34721          continue;
34722        var s = k.invm(this.n).mul(r.mul(key2.getPrivate()).iadd(msg));
34723        s = s.umod(this.n);
34724        if (s.cmpn(0) === 0)
34725          continue;
34726        var recoveryParam = (kp.getY().isOdd() ? 1 : 0) | (kpX.cmp(r) !== 0 ? 2 : 0);
34727        if (options.canonical && s.cmp(this.nh) > 0) {
34728          s = this.n.sub(s);
34729          recoveryParam ^= 1;
34730        }
34731        return new Signature({ r, s, recoveryParam });
34732      }
34733    };
34734    EC.prototype.verify = function verify(msg, signature2, key2, enc, options) {
34735      if (!options)
34736        options = {};
34737      msg = this._truncateToN(msg, false, options.msgBitLength);
34738      key2 = this.keyFromPublic(key2, enc);
34739      signature2 = new Signature(signature2, "hex");
34740      var r = signature2.r;
34741      var s = signature2.s;
34742      if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)
34743        return false;
34744      if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)
34745        return false;
34746      var sinv = s.invm(this.n);
34747      var u1 = sinv.mul(msg).umod(this.n);
34748      var u2 = sinv.mul(r).umod(this.n);
34749      var p;
34750      if (!this.curve._maxwellTrick) {
34751        p = this.g.mulAdd(u1, key2.getPublic(), u2);
34752        if (p.isInfinity())
34753          return false;
34754        return p.getX().umod(this.n).cmp(r) === 0;
34755      }
34756      p = this.g.jmulAdd(u1, key2.getPublic(), u2);
34757      if (p.isInfinity())
34758        return false;
34759      return p.eqXToP(r);
34760    };
34761    EC.prototype.recoverPubKey = function(msg, signature2, j, enc) {
34762      assert2((3 & j) === j, "The recovery param is more than two bits");
34763      signature2 = new Signature(signature2, enc);
34764      var n = this.n;
34765      var e = new BN(msg);
34766      var r = signature2.r;
34767      var s = signature2.s;
34768      var isYOdd = j & 1;
34769      var isSecondKey = j >> 1;
34770      if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)
34771        throw new Error("Unable to find sencond key candinate");
34772      if (isSecondKey)
34773        r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);
34774      else
34775        r = this.curve.pointFromX(r, isYOdd);
34776      var rInv = signature2.r.invm(n);
34777      var s1 = n.sub(e).mul(rInv).umod(n);
34778      var s2 = s.mul(rInv).umod(n);
34779      return this.g.mulAdd(s1, r, s2);
34780    };
34781    EC.prototype.getKeyRecoveryParam = function(e, signature2, Q, enc) {
34782      signature2 = new Signature(signature2, enc);
34783      if (signature2.recoveryParam !== null)
34784        return signature2.recoveryParam;
34785      for (var i2 = 0; i2 < 4; i2++) {
34786        var Qprime;
34787        try {
34788          Qprime = this.recoverPubKey(e, signature2, i2);
34789        } catch (e2) {
34790          continue;
34791        }
34792        if (Qprime.eq(Q))
34793          return i2;
34794      }
34795      throw new Error("Unable to find valid recovery factor");
34796    };
34797    return ec;
34798  }
34799  var key;
34800  var hasRequiredKey;
34801  function requireKey() {
34802    if (hasRequiredKey) return key;
34803    hasRequiredKey = 1;
34804    var utils2 = requireUtils$1();
34805    var assert2 = utils2.assert;
34806    var parseBytes = utils2.parseBytes;
34807    var cachedProperty = utils2.cachedProperty;
34808    function KeyPair(eddsa2, params) {
34809      this.eddsa = eddsa2;
34810      this._secret = parseBytes(params.secret);
34811      if (eddsa2.isPoint(params.pub))
34812        this._pub = params.pub;
34813      else
34814        this._pubBytes = parseBytes(params.pub);
34815    }
34816    KeyPair.fromPublic = function fromPublic(eddsa2, pub) {
34817      if (pub instanceof KeyPair)
34818        return pub;
34819      return new KeyPair(eddsa2, { pub });
34820    };
34821    KeyPair.fromSecret = function fromSecret(eddsa2, secret) {
34822      if (secret instanceof KeyPair)
34823        return secret;
34824      return new KeyPair(eddsa2, { secret });
34825    };
34826    KeyPair.prototype.secret = function secret() {
34827      return this._secret;
34828    };
34829    cachedProperty(KeyPair, "pubBytes", function pubBytes() {
34830      return this.eddsa.encodePoint(this.pub());
34831    });
34832    cachedProperty(KeyPair, "pub", function pub() {
34833      if (this._pubBytes)
34834        return this.eddsa.decodePoint(this._pubBytes);
34835      return this.eddsa.g.mul(this.priv());
34836    });
34837    cachedProperty(KeyPair, "privBytes", function privBytes() {
34838      var eddsa2 = this.eddsa;
34839      var hash2 = this.hash();
34840      var lastIx = eddsa2.encodingLength - 1;
34841      var a = hash2.slice(0, eddsa2.encodingLength);
34842      a[0] &= 248;
34843      a[lastIx] &= 127;
34844      a[lastIx] |= 64;
34845      return a;
34846    });
34847    cachedProperty(KeyPair, "priv", function priv() {
34848      return this.eddsa.decodeInt(this.privBytes());
34849    });
34850    cachedProperty(KeyPair, "hash", function hash2() {
34851      return this.eddsa.hash().update(this.secret()).digest();
34852    });
34853    cachedProperty(KeyPair, "messagePrefix", function messagePrefix() {
34854      return this.hash().slice(this.eddsa.encodingLength);
34855    });
34856    KeyPair.prototype.sign = function sign2(message) {
34857      assert2(this._secret, "KeyPair can only verify");
34858      return this.eddsa.sign(message, this);
34859    };
34860    KeyPair.prototype.verify = function verify(message, sig) {
34861      return this.eddsa.verify(message, sig, this);
34862    };
34863    KeyPair.prototype.getSecret = function getSecret(enc) {
34864      assert2(this._secret, "KeyPair is public only");
34865      return utils2.encode(this.secret(), enc);
34866    };
34867    KeyPair.prototype.getPublic = function getPublic(enc) {
34868      return utils2.encode(this.pubBytes(), enc);
34869    };
34870    key = KeyPair;
34871    return key;
34872  }
34873  var signature;
34874  var hasRequiredSignature;
34875  function requireSignature() {
34876    if (hasRequiredSignature) return signature;
34877    hasRequiredSignature = 1;
34878    var BN = requireBn$1();
34879    var utils2 = requireUtils$1();
34880    var assert2 = utils2.assert;
34881    var cachedProperty = utils2.cachedProperty;
34882    var parseBytes = utils2.parseBytes;
34883    function Signature(eddsa2, sig) {
34884      this.eddsa = eddsa2;
34885      if (typeof sig !== "object")
34886        sig = parseBytes(sig);
34887      if (Array.isArray(sig)) {
34888        assert2(sig.length === eddsa2.encodingLength * 2, "Signature has invalid size");
34889        sig = {
34890          R: sig.slice(0, eddsa2.encodingLength),
34891          S: sig.slice(eddsa2.encodingLength)
34892        };
34893      }
34894      assert2(sig.R && sig.S, "Signature without R or S");
34895      if (eddsa2.isPoint(sig.R))
34896        this._R = sig.R;
34897      if (sig.S instanceof BN)
34898        this._S = sig.S;
34899      this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;
34900      this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;
34901    }
34902    cachedProperty(Signature, "S", function S() {
34903      return this.eddsa.decodeInt(this.Sencoded());
34904    });
34905    cachedProperty(Signature, "R", function R() {
34906      return this.eddsa.decodePoint(this.Rencoded());
34907    });

vendor: 8,808 bytes, lines 34908-35180

34908    cachedProperty(Signature, "Rencoded", function Rencoded() {
34909      return this.eddsa.encodePoint(this.R());
34910    });
34911    cachedProperty(Signature, "Sencoded", function Sencoded() {
34912      return this.eddsa.encodeInt(this.S());
34913    });
34914    Signature.prototype.toBytes = function toBytes() {
34915      return this.Rencoded().concat(this.Sencoded());
34916    };
34917    Signature.prototype.toHex = function toHex() {
34918      return utils2.encode(this.toBytes(), "hex").toUpperCase();
34919    };
34920    signature = Signature;
34921    return signature;
34922  }
34923  var eddsa;
34924  var hasRequiredEddsa;
34925  function requireEddsa() {
34926    if (hasRequiredEddsa) return eddsa;
34927    hasRequiredEddsa = 1;
34928    var hash2 = requireHash();
34929    var curves2 = requireCurves();
34930    var utils2 = requireUtils$1();
34931    var assert2 = utils2.assert;
34932    var parseBytes = utils2.parseBytes;
34933    var KeyPair = requireKey();
34934    var Signature = requireSignature();
34935    function EDDSA(curve2) {
34936      assert2(curve2 === "ed25519", "only tested with ed25519 so far");
34937      if (!(this instanceof EDDSA))
34938        return new EDDSA(curve2);
34939      curve2 = curves2[curve2].curve;
34940      this.curve = curve2;
34941      this.g = curve2.g;
34942      this.g.precompute(curve2.n.bitLength() + 1);
34943      this.pointClass = curve2.point().constructor;
34944      this.encodingLength = Math.ceil(curve2.n.bitLength() / 8);
34945      this.hash = hash2.sha512;
34946    }
34947    eddsa = EDDSA;
34948    EDDSA.prototype.sign = function sign2(message, secret) {
34949      message = parseBytes(message);
34950      var key2 = this.keyFromSecret(secret);
34951      var r = this.hashInt(key2.messagePrefix(), message);
34952      var R = this.g.mul(r);
34953      var Rencoded = this.encodePoint(R);
34954      var s_ = this.hashInt(Rencoded, key2.pubBytes(), message).mul(key2.priv());
34955      var S = r.add(s_).umod(this.curve.n);
34956      return this.makeSignature({ R, S, Rencoded });
34957    };
34958    EDDSA.prototype.verify = function verify(message, sig, pub) {
34959      message = parseBytes(message);
34960      sig = this.makeSignature(sig);
34961      if (sig.S().gte(sig.eddsa.curve.n) || sig.S().isNeg()) {
34962        return false;
34963      }
34964      var key2 = this.keyFromPublic(pub);
34965      var h = this.hashInt(sig.Rencoded(), key2.pubBytes(), message);
34966      var SG = this.g.mul(sig.S());
34967      var RplusAh = sig.R().add(key2.pub().mul(h));
34968      return RplusAh.eq(SG);
34969    };
34970    EDDSA.prototype.hashInt = function hashInt() {
34971      var hash3 = this.hash();
34972      for (var i2 = 0; i2 < arguments.length; i2++)
34973        hash3.update(arguments[i2]);
34974      return utils2.intFromLE(hash3.digest()).umod(this.curve.n);
34975    };
34976    EDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {
34977      return KeyPair.fromPublic(this, pub);
34978    };
34979    EDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {
34980      return KeyPair.fromSecret(this, secret);
34981    };
34982    EDDSA.prototype.makeSignature = function makeSignature(sig) {
34983      if (sig instanceof Signature)
34984        return sig;
34985      return new Signature(this, sig);
34986    };
34987    EDDSA.prototype.encodePoint = function encodePoint(point) {
34988      var enc = point.getY().toArray("le", this.encodingLength);
34989      enc[this.encodingLength - 1] |= point.getX().isOdd() ? 128 : 0;
34990      return enc;
34991    };
34992    EDDSA.prototype.decodePoint = function decodePoint(bytes) {
34993      bytes = utils2.parseBytes(bytes);
34994      var lastIx = bytes.length - 1;
34995      var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & -129);
34996      var xIsOdd = (bytes[lastIx] & 128) !== 0;
34997      var y = utils2.intFromLE(normed);
34998      return this.curve.pointFromY(y, xIsOdd);
34999    };
35000    EDDSA.prototype.encodeInt = function encodeInt(num) {
35001      return num.toArray("le", this.encodingLength);
35002    };
35003    EDDSA.prototype.decodeInt = function decodeInt(bytes) {
35004      return utils2.intFromLE(bytes);
35005    };
35006    EDDSA.prototype.isPoint = function isPoint(val) {
35007      return val instanceof this.pointClass;
35008    };
35009    return eddsa;
35010  }
35011  var hasRequiredElliptic;
35012  function requireElliptic() {
35013    if (hasRequiredElliptic) return elliptic;
35014    hasRequiredElliptic = 1;
35015    (function(exports$12) {
35016      var elliptic2 = exports$12;
35017      elliptic2.version = require$$0$1.version;
35018      elliptic2.utils = requireUtils$1();
35019      elliptic2.rand = requireBrorand();
35020      elliptic2.curve = requireCurve();
35021      elliptic2.curves = requireCurves();
35022      elliptic2.ec = requireEc();
35023      elliptic2.eddsa = requireEddsa();
35024    })(elliptic);
35025    return elliptic;
35026  }
35027  var browser$3;
35028  var hasRequiredBrowser$3;
35029  function requireBrowser$3() {
35030    if (hasRequiredBrowser$3) return browser$3;
35031    hasRequiredBrowser$3 = 1;
35032    var elliptic2 = requireElliptic();
35033    var BN = requireBn$1();
35034    browser$3 = function createECDH(curve2) {
35035      return new ECDH(curve2);
35036    };
35037    var aliases = {
35038      secp256k1: {
35039        name: "secp256k1",
35040        byteLength: 32
35041      },
35042      secp224r1: {
35043        name: "p224",
35044        byteLength: 28
35045      },
35046      prime256v1: {
35047        name: "p256",
35048        byteLength: 32
35049      },
35050      prime192v1: {
35051        name: "p192",
35052        byteLength: 24
35053      },
35054      ed25519: {
35055        name: "ed25519",
35056        byteLength: 32
35057      },
35058      secp384r1: {
35059        name: "p384",
35060        byteLength: 48
35061      },
35062      secp521r1: {
35063        name: "p521",
35064        byteLength: 66
35065      }
35066    };
35067    aliases.p224 = aliases.secp224r1;
35068    aliases.p256 = aliases.secp256r1 = aliases.prime256v1;
35069    aliases.p192 = aliases.secp192r1 = aliases.prime192v1;
35070    aliases.p384 = aliases.secp384r1;
35071    aliases.p521 = aliases.secp521r1;
35072    function ECDH(curve2) {
35073      this.curveType = aliases[curve2];
35074      if (!this.curveType) {
35075        this.curveType = {
35076          name: curve2
35077        };
35078      }
35079      this.curve = new elliptic2.ec(this.curveType.name);
35080      this.keys = void 0;
35081    }
35082    ECDH.prototype.generateKeys = function(enc, format) {
35083      this.keys = this.curve.genKeyPair();
35084      return this.getPublicKey(enc, format);
35085    };
35086    ECDH.prototype.computeSecret = function(other, inenc, enc) {
35087      inenc = inenc || "utf8";
35088      if (!Buffer.isBuffer(other)) {
35089        other = new Buffer(other, inenc);
35090      }
35091      var otherPub = this.curve.keyFromPublic(other).getPublic();
35092      var out = otherPub.mul(this.keys.getPrivate()).getX();
35093      return formatReturnValue(out, enc, this.curveType.byteLength);
35094    };
35095    ECDH.prototype.getPublicKey = function(enc, format) {
35096      var key2 = this.keys.getPublic(format === "compressed", true);
35097      if (format === "hybrid") {
35098        if (key2[key2.length - 1] % 2) {
35099          key2[0] = 7;
35100        } else {
35101          key2[0] = 6;
35102        }
35103      }
35104      return formatReturnValue(key2, enc);
35105    };
35106    ECDH.prototype.getPrivateKey = function(enc) {
35107      return formatReturnValue(this.keys.getPrivate(), enc);
35108    };
35109    ECDH.prototype.setPublicKey = function(pub, enc) {
35110      enc = enc || "utf8";
35111      if (!Buffer.isBuffer(pub)) {
35112        pub = new Buffer(pub, enc);
35113      }
35114      this.keys._importPublic(pub);
35115      return this;
35116    };
35117    ECDH.prototype.setPrivateKey = function(priv, enc) {
35118      enc = enc || "utf8";
35119      if (!Buffer.isBuffer(priv)) {
35120        priv = new Buffer(priv, enc);
35121      }
35122      var _priv = new BN(priv);
35123      _priv = _priv.toString(16);
35124      this.keys = this.curve.genKeyPair();
35125      this.keys._importPrivate(_priv);
35126      return this;
35127    };
35128    function formatReturnValue(bn2, enc, len2) {
35129      if (!Array.isArray(bn2)) {
35130        bn2 = bn2.toArray();
35131      }
35132      var buf = new Buffer(bn2);
35133      if (len2 && buf.length < len2) {
35134        var zeros = new Buffer(len2 - buf.length);
35135        zeros.fill(0);
35136        buf = Buffer.concat([zeros, buf]);
35137      }
35138      if (!enc) {
35139        return buf;
35140      } else {
35141        return buf.toString(enc);
35142      }
35143    }
35144    return browser$3;
35145  }
35146  var createEcdh;
35147  var hasRequiredCreateEcdh;
35148  function requireCreateEcdh() {
35149    if (hasRequiredCreateEcdh) return createEcdh;
35150    hasRequiredCreateEcdh = 1;
35151    var createECDH = requireCryptoBrowserify().createECDH;
35152    createEcdh = createECDH || requireBrowser$3();
35153    return createEcdh;
35154  }
35155  var publicEncrypt$1 = {};
35156  var browser$2 = {};
35157  var asn1$1 = {};
35158  var asn1 = {};
35159  var api = {};
35160  var vmBrowserify = {};
35161  var hasRequiredVmBrowserify;
35162  function requireVmBrowserify() {
35163    if (hasRequiredVmBrowserify) return vmBrowserify;
35164    hasRequiredVmBrowserify = 1;
35165    (function(exports$1) {
35166      var indexOf = function(xs, item) {
35167        if (xs.indexOf) return xs.indexOf(item);
35168        else for (var i2 = 0; i2 < xs.length; i2++) {
35169          if (xs[i2] === item) return i2;
35170        }
35171        return -1;
35172      };
35173      var Object_keys = function(obj) {
35174        if (Object.keys) return Object.keys(obj);
35175        else {
35176          var res = [];
35177          for (var key2 in obj) res.push(key2);
35178          return res;
35179        }
35180      };

vendor: 4,916 bytes, lines 35181-35345

35181      var forEach = function(xs, fn) {
35182        if (xs.forEach) return xs.forEach(fn);
35183        else for (var i2 = 0; i2 < xs.length; i2++) {
35184          fn(xs[i2], i2, xs);
35185        }
35186      };
35187      var defineProp = (function() {
35188        try {
35189          Object.defineProperty({}, "_", {});
35190          return function(obj, name, value) {
35191            Object.defineProperty(obj, name, {
35192              writable: true,
35193              enumerable: false,
35194              configurable: true,
35195              value
35196            });
35197          };
35198        } catch (e) {
35199          return function(obj, name, value) {
35200            obj[name] = value;
35201          };
35202        }
35203      })();
35204      var globals = [
35205        "Array",
35206        "Boolean",
35207        "Date",
35208        "Error",
35209        "EvalError",
35210        "Function",
35211        "Infinity",
35212        "JSON",
35213        "Math",
35214        "NaN",
35215        "Number",
35216        "Object",
35217        "RangeError",
35218        "ReferenceError",
35219        "RegExp",
35220        "String",
35221        "SyntaxError",
35222        "TypeError",
35223        "URIError",
35224        "decodeURI",
35225        "decodeURIComponent",
35226        "encodeURI",
35227        "encodeURIComponent",
35228        "escape",
35229        "eval",
35230        "isFinite",
35231        "isNaN",
35232        "parseFloat",
35233        "parseInt",
35234        "undefined",
35235        "unescape"
35236      ];
35237      function Context() {
35238      }
35239      Context.prototype = {};
35240      var Script = exports$1.Script = function NodeScript(code2) {
35241        if (!(this instanceof Script)) return new Script(code2);
35242        this.code = code2;
35243      };
35244      Script.prototype.runInContext = function(context) {
35245        if (!(context instanceof Context)) {
35246          throw new TypeError("needs a 'context' argument.");
35247        }
35248        var iframe = document.createElement("iframe");
35249        if (!iframe.style) iframe.style = {};
35250        iframe.style.display = "none";
35251        document.body.appendChild(iframe);
35252        var win = iframe.contentWindow;
35253        var wEval = win.eval, wExecScript = win.execScript;
35254        if (!wEval && wExecScript) {
35255          wExecScript.call(win, "null");
35256          wEval = win.eval;
35257        }
35258        forEach(Object_keys(context), function(key2) {
35259          win[key2] = context[key2];
35260        });
35261        forEach(globals, function(key2) {
35262          if (context[key2]) {
35263            win[key2] = context[key2];
35264          }
35265        });
35266        var winKeys = Object_keys(win);
35267        var res = wEval.call(win, this.code);
35268        forEach(Object_keys(win), function(key2) {
35269          if (key2 in context || indexOf(winKeys, key2) === -1) {
35270            context[key2] = win[key2];
35271          }
35272        });
35273        forEach(globals, function(key2) {
35274          if (!(key2 in context)) {
35275            defineProp(context, key2, win[key2]);
35276          }
35277        });
35278        document.body.removeChild(iframe);
35279        return res;
35280      };
35281      Script.prototype.runInThisContext = function() {
35282        return eval(this.code);
35283      };
35284      Script.prototype.runInNewContext = function(context) {
35285        var ctx = Script.createContext(context);
35286        var res = this.runInContext(ctx);
35287        if (context) {
35288          forEach(Object_keys(ctx), function(key2) {
35289            context[key2] = ctx[key2];
35290          });
35291        }
35292        return res;
35293      };
35294      forEach(Object_keys(Script.prototype), function(name) {
35295        exports$1[name] = Script[name] = function(code2) {
35296          var s = Script(code2);
35297          return s[name].apply(s, [].slice.call(arguments, 1));
35298        };
35299      });
35300      exports$1.isContext = function(context) {
35301        return context instanceof Context;
35302      };
35303      exports$1.createScript = function(code2) {
35304        return exports$1.Script(code2);
35305      };
35306      exports$1.createContext = Script.createContext = function(context) {
35307        var copy = new Context();
35308        if (typeof context === "object") {
35309          forEach(Object_keys(context), function(key2) {
35310            copy[key2] = context[key2];
35311          });
35312        }
35313        return copy;
35314      };
35315    })(vmBrowserify);
35316    return vmBrowserify;
35317  }
35318  var hasRequiredApi;
35319  function requireApi() {
35320    if (hasRequiredApi) return api;
35321    hasRequiredApi = 1;
35322    (function(exports$12) {
35323      var asn12 = requireAsn1$1();
35324      var inherits2 = requireInherits();
35325      var api2 = exports$12;
35326      api2.define = function define(name, body) {
35327        return new Entity(name, body);
35328      };
35329      function Entity(name, body) {
35330        this.name = name;
35331        this.body = body;
35332        this.decoders = {};
35333        this.encoders = {};
35334      }
35335      Entity.prototype._createNamed = function createNamed(base2) {
35336        var named;
35337        try {
35338          named = requireVmBrowserify().runInThisContext(
35339            "(function " + this.name + "(entity) {\n  this._initNamed(entity);\n})"
35340          );
35341        } catch (e) {
35342          named = function(entity) {
35343            this._initNamed(entity);
35344          };
35345        }

vendor: 4,730 bytes, lines 35346-35492

35346        inherits2(named, base2);
35347        named.prototype._initNamed = function initnamed(entity) {
35348          base2.call(this, entity);
35349        };
35350        return new named(this);
35351      };
35352      Entity.prototype._getDecoder = function _getDecoder(enc) {
35353        enc = enc || "der";
35354        if (!this.decoders.hasOwnProperty(enc))
35355          this.decoders[enc] = this._createNamed(asn12.decoders[enc]);
35356        return this.decoders[enc];
35357      };
35358      Entity.prototype.decode = function decode(data, enc, options) {
35359        return this._getDecoder(enc).decode(data, options);
35360      };
35361      Entity.prototype._getEncoder = function _getEncoder(enc) {
35362        enc = enc || "der";
35363        if (!this.encoders.hasOwnProperty(enc))
35364          this.encoders[enc] = this._createNamed(asn12.encoders[enc]);
35365        return this.encoders[enc];
35366      };
35367      Entity.prototype.encode = function encode2(data, enc, reporter2) {
35368        return this._getEncoder(enc).encode(data, reporter2);
35369      };
35370    })(api);
35371    return api;
35372  }
35373  var base = {};
35374  var reporter = {};
35375  var hasRequiredReporter;
35376  function requireReporter() {
35377    if (hasRequiredReporter) return reporter;
35378    hasRequiredReporter = 1;
35379    var inherits2 = requireInherits();
35380    function Reporter(options) {
35381      this._reporterState = {
35382        obj: null,
35383        path: [],
35384        options: options || {},
35385        errors: []
35386      };
35387    }
35388    reporter.Reporter = Reporter;
35389    Reporter.prototype.isError = function isError(obj) {
35390      return obj instanceof ReporterError;
35391    };
35392    Reporter.prototype.save = function save() {
35393      var state2 = this._reporterState;
35394      return { obj: state2.obj, pathLen: state2.path.length };
35395    };
35396    Reporter.prototype.restore = function restore(data) {
35397      var state2 = this._reporterState;
35398      state2.obj = data.obj;
35399      state2.path = state2.path.slice(0, data.pathLen);
35400    };
35401    Reporter.prototype.enterKey = function enterKey(key2) {
35402      return this._reporterState.path.push(key2);
35403    };
35404    Reporter.prototype.exitKey = function exitKey(index) {
35405      var state2 = this._reporterState;
35406      state2.path = state2.path.slice(0, index - 1);
35407    };
35408    Reporter.prototype.leaveKey = function leaveKey(index, key2, value) {
35409      var state2 = this._reporterState;
35410      this.exitKey(index);
35411      if (state2.obj !== null)
35412        state2.obj[key2] = value;
35413    };
35414    Reporter.prototype.path = function path() {
35415      return this._reporterState.path.join("/");
35416    };
35417    Reporter.prototype.enterObject = function enterObject() {
35418      var state2 = this._reporterState;
35419      var prev = state2.obj;
35420      state2.obj = {};
35421      return prev;
35422    };
35423    Reporter.prototype.leaveObject = function leaveObject(prev) {
35424      var state2 = this._reporterState;
35425      var now = state2.obj;
35426      state2.obj = prev;
35427      return now;
35428    };
35429    Reporter.prototype.error = function error(msg) {
35430      var err;
35431      var state2 = this._reporterState;
35432      var inherited = msg instanceof ReporterError;
35433      if (inherited) {
35434        err = msg;
35435      } else {
35436        err = new ReporterError(state2.path.map(function(elem) {
35437          return "[" + JSON.stringify(elem) + "]";
35438        }).join(""), msg.message || msg, msg.stack);
35439      }
35440      if (!state2.options.partial)
35441        throw err;
35442      if (!inherited)
35443        state2.errors.push(err);
35444      return err;
35445    };
35446    Reporter.prototype.wrapResult = function wrapResult(result) {
35447      var state2 = this._reporterState;
35448      if (!state2.options.partial)
35449        return result;
35450      return {
35451        result: this.isError(result) ? null : result,
35452        errors: state2.errors
35453      };
35454    };
35455    function ReporterError(path, msg) {
35456      this.path = path;
35457      this.rethrow(msg);
35458    }
35459    inherits2(ReporterError, Error);
35460    ReporterError.prototype.rethrow = function rethrow(msg) {
35461      this.message = msg + " at: " + (this.path || "(shallow)");
35462      if (Error.captureStackTrace)
35463        Error.captureStackTrace(this, ReporterError);
35464      if (!this.stack) {
35465        try {
35466          throw new Error(this.message);
35467        } catch (e) {
35468          this.stack = e.stack;
35469        }
35470      }
35471      return this;
35472    };
35473    return reporter;
35474  }
35475  var buffer = {};
35476  var hasRequiredBuffer;
35477  function requireBuffer() {
35478    if (hasRequiredBuffer) return buffer;
35479    hasRequiredBuffer = 1;
35480    var inherits2 = requireInherits();
35481    var Reporter = requireBase().Reporter;
35482    var Buffer2 = requireDist().Buffer;
35483    function DecoderBuffer(base2, options) {
35484      Reporter.call(this, options);
35485      if (!Buffer2.isBuffer(base2)) {
35486        this.error("Input not Buffer");
35487        return;
35488      }
35489      this.base = base2;
35490      this.offset = 0;
35491      this.length = base2.length;
35492    }

vendor: 12,620 bytes, lines 35493-35906

35493    inherits2(DecoderBuffer, Reporter);
35494    buffer.DecoderBuffer = DecoderBuffer;
35495    DecoderBuffer.prototype.save = function save() {
35496      return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };
35497    };
35498    DecoderBuffer.prototype.restore = function restore(save) {
35499      var res = new DecoderBuffer(this.base);
35500      res.offset = save.offset;
35501      res.length = this.offset;
35502      this.offset = save.offset;
35503      Reporter.prototype.restore.call(this, save.reporter);
35504      return res;
35505    };
35506    DecoderBuffer.prototype.isEmpty = function isEmpty() {
35507      return this.offset === this.length;
35508    };
35509    DecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {
35510      if (this.offset + 1 <= this.length)
35511        return this.base.readUInt8(this.offset++, true);
35512      else
35513        return this.error(fail || "DecoderBuffer overrun");
35514    };
35515    DecoderBuffer.prototype.skip = function skip(bytes, fail) {
35516      if (!(this.offset + bytes <= this.length))
35517        return this.error(fail || "DecoderBuffer overrun");
35518      var res = new DecoderBuffer(this.base);
35519      res._reporterState = this._reporterState;
35520      res.offset = this.offset;
35521      res.length = this.offset + bytes;
35522      this.offset += bytes;
35523      return res;
35524    };
35525    DecoderBuffer.prototype.raw = function raw(save) {
35526      return this.base.slice(save ? save.offset : this.offset, this.length);
35527    };
35528    function EncoderBuffer(value, reporter2) {
35529      if (Array.isArray(value)) {
35530        this.length = 0;
35531        this.value = value.map(function(item) {
35532          if (!(item instanceof EncoderBuffer))
35533            item = new EncoderBuffer(item, reporter2);
35534          this.length += item.length;
35535          return item;
35536        }, this);
35537      } else if (typeof value === "number") {
35538        if (!(0 <= value && value <= 255))
35539          return reporter2.error("non-byte EncoderBuffer value");
35540        this.value = value;
35541        this.length = 1;
35542      } else if (typeof value === "string") {
35543        this.value = value;
35544        this.length = Buffer2.byteLength(value);
35545      } else if (Buffer2.isBuffer(value)) {
35546        this.value = value;
35547        this.length = value.length;
35548      } else {
35549        return reporter2.error("Unsupported type: " + typeof value);
35550      }
35551    }
35552    buffer.EncoderBuffer = EncoderBuffer;
35553    EncoderBuffer.prototype.join = function join(out, offset) {
35554      if (!out)
35555        out = new Buffer2(this.length);
35556      if (!offset)
35557        offset = 0;
35558      if (this.length === 0)
35559        return out;
35560      if (Array.isArray(this.value)) {
35561        this.value.forEach(function(item) {
35562          item.join(out, offset);
35563          offset += item.length;
35564        });
35565      } else {
35566        if (typeof this.value === "number")
35567          out[offset] = this.value;
35568        else if (typeof this.value === "string")
35569          out.write(this.value, offset);
35570        else if (Buffer2.isBuffer(this.value))
35571          this.value.copy(out, offset);
35572        offset += this.length;
35573      }
35574      return out;
35575    };
35576    return buffer;
35577  }
35578  var node$1;
35579  var hasRequiredNode$1;
35580  function requireNode$1() {
35581    if (hasRequiredNode$1) return node$1;
35582    hasRequiredNode$1 = 1;
35583    var Reporter = requireBase().Reporter;
35584    var EncoderBuffer = requireBase().EncoderBuffer;
35585    var DecoderBuffer = requireBase().DecoderBuffer;
35586    var assert2 = requireMinimalisticAssert();
35587    var tags = [
35588      "seq",
35589      "seqof",
35590      "set",
35591      "setof",
35592      "objid",
35593      "bool",
35594      "gentime",
35595      "utctime",
35596      "null_",
35597      "enum",
35598      "int",
35599      "objDesc",
35600      "bitstr",
35601      "bmpstr",
35602      "charstr",
35603      "genstr",
35604      "graphstr",
35605      "ia5str",
35606      "iso646str",
35607      "numstr",
35608      "octstr",
35609      "printstr",
35610      "t61str",
35611      "unistr",
35612      "utf8str",
35613      "videostr"
35614    ];
35615    var methods = [
35616      "key",
35617      "obj",
35618      "use",
35619      "optional",
35620      "explicit",
35621      "implicit",
35622      "def",
35623      "choice",
35624      "any",
35625      "contains"
35626    ].concat(tags);
35627    var overrided = [
35628      "_peekTag",
35629      "_decodeTag",
35630      "_use",
35631      "_decodeStr",
35632      "_decodeObjid",
35633      "_decodeTime",
35634      "_decodeNull",
35635      "_decodeInt",
35636      "_decodeBool",
35637      "_decodeList",
35638      "_encodeComposite",
35639      "_encodeStr",
35640      "_encodeObjid",
35641      "_encodeTime",
35642      "_encodeNull",
35643      "_encodeInt",
35644      "_encodeBool"
35645    ];
35646    function Node(enc, parent) {
35647      var state2 = {};
35648      this._baseState = state2;
35649      state2.enc = enc;
35650      state2.parent = parent || null;
35651      state2.children = null;
35652      state2.tag = null;
35653      state2.args = null;
35654      state2.reverseArgs = null;
35655      state2.choice = null;
35656      state2.optional = false;
35657      state2.any = false;
35658      state2.obj = false;
35659      state2.use = null;
35660      state2.useDecoder = null;
35661      state2.key = null;
35662      state2["default"] = null;
35663      state2.explicit = null;
35664      state2.implicit = null;
35665      state2.contains = null;
35666      if (!state2.parent) {
35667        state2.children = [];
35668        this._wrap();
35669      }
35670    }
35671    node$1 = Node;
35672    var stateProps = [
35673      "enc",
35674      "parent",
35675      "children",
35676      "tag",
35677      "args",
35678      "reverseArgs",
35679      "choice",
35680      "optional",
35681      "any",
35682      "obj",
35683      "use",
35684      "alteredUse",
35685      "key",
35686      "default",
35687      "explicit",
35688      "implicit",
35689      "contains"
35690    ];
35691    Node.prototype.clone = function clone() {
35692      var state2 = this._baseState;
35693      var cstate = {};
35694      stateProps.forEach(function(prop) {
35695        cstate[prop] = state2[prop];
35696      });
35697      var res = new this.constructor(cstate.parent);
35698      res._baseState = cstate;
35699      return res;
35700    };
35701    Node.prototype._wrap = function wrap() {
35702      var state2 = this._baseState;
35703      methods.forEach(function(method) {
35704        this[method] = function _wrappedMethod() {
35705          var clone = new this.constructor(this);
35706          state2.children.push(clone);
35707          return clone[method].apply(clone, arguments);
35708        };
35709      }, this);
35710    };
35711    Node.prototype._init = function init(body) {
35712      var state2 = this._baseState;
35713      assert2(state2.parent === null);
35714      body.call(this);
35715      state2.children = state2.children.filter(function(child) {
35716        return child._baseState.parent === this;
35717      }, this);
35718      assert2.equal(state2.children.length, 1, "Root node can have only one child");
35719    };
35720    Node.prototype._useArgs = function useArgs(args) {
35721      var state2 = this._baseState;
35722      var children = args.filter(function(arg) {
35723        return arg instanceof this.constructor;
35724      }, this);
35725      args = args.filter(function(arg) {
35726        return !(arg instanceof this.constructor);
35727      }, this);
35728      if (children.length !== 0) {
35729        assert2(state2.children === null);
35730        state2.children = children;
35731        children.forEach(function(child) {
35732          child._baseState.parent = this;
35733        }, this);
35734      }
35735      if (args.length !== 0) {
35736        assert2(state2.args === null);
35737        state2.args = args;
35738        state2.reverseArgs = args.map(function(arg) {
35739          if (typeof arg !== "object" || arg.constructor !== Object)
35740            return arg;
35741          var res = {};
35742          Object.keys(arg).forEach(function(key2) {
35743            if (key2 == (key2 | 0))
35744              key2 |= 0;
35745            var value = arg[key2];
35746            res[value] = key2;
35747          });
35748          return res;
35749        });
35750      }
35751    };
35752    overrided.forEach(function(method) {
35753      Node.prototype[method] = function _overrided() {
35754        var state2 = this._baseState;
35755        throw new Error(method + " not implemented for encoding: " + state2.enc);
35756      };
35757    });
35758    tags.forEach(function(tag) {
35759      Node.prototype[tag] = function _tagMethod() {
35760        var state2 = this._baseState;
35761        var args = Array.prototype.slice.call(arguments);
35762        assert2(state2.tag === null);
35763        state2.tag = tag;
35764        this._useArgs(args);
35765        return this;
35766      };
35767    });
35768    Node.prototype.use = function use(item) {
35769      assert2(item);
35770      var state2 = this._baseState;
35771      assert2(state2.use === null);
35772      state2.use = item;
35773      return this;
35774    };
35775    Node.prototype.optional = function optional() {
35776      var state2 = this._baseState;
35777      state2.optional = true;
35778      return this;
35779    };
35780    Node.prototype.def = function def(val) {
35781      var state2 = this._baseState;
35782      assert2(state2["default"] === null);
35783      state2["default"] = val;
35784      state2.optional = true;
35785      return this;
35786    };
35787    Node.prototype.explicit = function explicit(num) {
35788      var state2 = this._baseState;
35789      assert2(state2.explicit === null && state2.implicit === null);
35790      state2.explicit = num;
35791      return this;
35792    };
35793    Node.prototype.implicit = function implicit(num) {
35794      var state2 = this._baseState;
35795      assert2(state2.explicit === null && state2.implicit === null);
35796      state2.implicit = num;
35797      return this;
35798    };
35799    Node.prototype.obj = function obj() {
35800      var state2 = this._baseState;
35801      var args = Array.prototype.slice.call(arguments);
35802      state2.obj = true;
35803      if (args.length !== 0)
35804        this._useArgs(args);
35805      return this;
35806    };
35807    Node.prototype.key = function key2(newKey) {
35808      var state2 = this._baseState;
35809      assert2(state2.key === null);
35810      state2.key = newKey;
35811      return this;
35812    };
35813    Node.prototype.any = function any() {
35814      var state2 = this._baseState;
35815      state2.any = true;
35816      return this;
35817    };
35818    Node.prototype.choice = function choice(obj) {
35819      var state2 = this._baseState;
35820      assert2(state2.choice === null);
35821      state2.choice = obj;
35822      this._useArgs(Object.keys(obj).map(function(key2) {
35823        return obj[key2];
35824      }));
35825      return this;
35826    };
35827    Node.prototype.contains = function contains(item) {
35828      var state2 = this._baseState;
35829      assert2(state2.use === null);
35830      state2.contains = item;
35831      return this;
35832    };
35833    Node.prototype._decode = function decode(input, options) {
35834      var state2 = this._baseState;
35835      if (state2.parent === null)
35836        return input.wrapResult(state2.children[0]._decode(input, options));
35837      var result = state2["default"];
35838      var present = true;
35839      var prevKey = null;
35840      if (state2.key !== null)
35841        prevKey = input.enterKey(state2.key);
35842      if (state2.optional) {
35843        var tag = null;
35844        if (state2.explicit !== null)
35845          tag = state2.explicit;
35846        else if (state2.implicit !== null)
35847          tag = state2.implicit;
35848        else if (state2.tag !== null)
35849          tag = state2.tag;
35850        if (tag === null && !state2.any) {
35851          var save = input.save();
35852          try {
35853            if (state2.choice === null)
35854              this._decodeGeneric(state2.tag, input, options);
35855            else
35856              this._decodeChoice(input, options);
35857            present = true;
35858          } catch (e) {
35859            present = false;
35860          }
35861          input.restore(save);
35862        } else {
35863          present = this._peekTag(input, tag, state2.any);
35864          if (input.isError(present))
35865            return present;
35866        }
35867      }
35868      var prevObj;
35869      if (state2.obj && present)
35870        prevObj = input.enterObject();
35871      if (present) {
35872        if (state2.explicit !== null) {
35873          var explicit = this._decodeTag(input, state2.explicit);
35874          if (input.isError(explicit))
35875            return explicit;
35876          input = explicit;
35877        }
35878        var start = input.offset;
35879        if (state2.use === null && state2.choice === null) {
35880          if (state2.any)
35881            var save = input.save();
35882          var body = this._decodeTag(
35883            input,
35884            state2.implicit !== null ? state2.implicit : state2.tag,
35885            state2.any
35886          );
35887          if (input.isError(body))
35888            return body;
35889          if (state2.any)
35890            result = input.raw(save);
35891          else
35892            input = body;
35893        }
35894        if (options && options.track && state2.tag !== null)
35895          options.track(input.path(), start, input.length, "tagged");
35896        if (options && options.track && state2.tag !== null)
35897          options.track(input.path(), input.offset, input.length, "content");
35898        if (state2.any)
35899          result = result;
35900        else if (state2.choice === null)
35901          result = this._decodeGeneric(state2.tag, input, options);
35902        else
35903          result = this._decodeChoice(input, options);
35904        if (input.isError(result))
35905          return result;
35906        if (!state2.any && state2.choice === null && state2.children !== null) {

vendor: 4,238 bytes, lines 35907-36013

35907          state2.children.forEach(function decodeChildren(child) {
35908            child._decode(input, options);
35909          });
35910        }
35911        if (state2.contains && (state2.tag === "octstr" || state2.tag === "bitstr")) {
35912          var data = new DecoderBuffer(result);
35913          result = this._getUse(state2.contains, input._reporterState.obj)._decode(data, options);
35914        }
35915      }
35916      if (state2.obj && present)
35917        result = input.leaveObject(prevObj);
35918      if (state2.key !== null && (result !== null || present === true))
35919        input.leaveKey(prevKey, state2.key, result);
35920      else if (prevKey !== null)
35921        input.exitKey(prevKey);
35922      return result;
35923    };
35924    Node.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {
35925      var state2 = this._baseState;
35926      if (tag === "seq" || tag === "set")
35927        return null;
35928      if (tag === "seqof" || tag === "setof")
35929        return this._decodeList(input, tag, state2.args[0], options);
35930      else if (/str$/.test(tag))
35931        return this._decodeStr(input, tag, options);
35932      else if (tag === "objid" && state2.args)
35933        return this._decodeObjid(input, state2.args[0], state2.args[1], options);
35934      else if (tag === "objid")
35935        return this._decodeObjid(input, null, null, options);
35936      else if (tag === "gentime" || tag === "utctime")
35937        return this._decodeTime(input, tag, options);
35938      else if (tag === "null_")
35939        return this._decodeNull(input, options);
35940      else if (tag === "bool")
35941        return this._decodeBool(input, options);
35942      else if (tag === "objDesc")
35943        return this._decodeStr(input, tag, options);
35944      else if (tag === "int" || tag === "enum")
35945        return this._decodeInt(input, state2.args && state2.args[0], options);
35946      if (state2.use !== null) {
35947        return this._getUse(state2.use, input._reporterState.obj)._decode(input, options);
35948      } else {
35949        return input.error("unknown tag: " + tag);
35950      }
35951    };
35952    Node.prototype._getUse = function _getUse(entity, obj) {
35953      var state2 = this._baseState;
35954      state2.useDecoder = this._use(entity, obj);
35955      assert2(state2.useDecoder._baseState.parent === null);
35956      state2.useDecoder = state2.useDecoder._baseState.children[0];
35957      if (state2.implicit !== state2.useDecoder._baseState.implicit) {
35958        state2.useDecoder = state2.useDecoder.clone();
35959        state2.useDecoder._baseState.implicit = state2.implicit;
35960      }
35961      return state2.useDecoder;
35962    };
35963    Node.prototype._decodeChoice = function decodeChoice(input, options) {
35964      var state2 = this._baseState;
35965      var result = null;
35966      var match = false;
35967      Object.keys(state2.choice).some(function(key2) {
35968        var save = input.save();
35969        var node2 = state2.choice[key2];
35970        try {
35971          var value = node2._decode(input, options);
35972          if (input.isError(value))
35973            return false;
35974          result = { type: key2, value };
35975          match = true;
35976        } catch (e) {
35977          input.restore(save);
35978          return false;
35979        }
35980        return true;
35981      }, this);
35982      if (!match)
35983        return input.error("Choice not matched");
35984      return result;
35985    };
35986    Node.prototype._createEncoderBuffer = function createEncoderBuffer(data) {
35987      return new EncoderBuffer(data, this.reporter);
35988    };
35989    Node.prototype._encode = function encode2(data, reporter2, parent) {
35990      var state2 = this._baseState;
35991      if (state2["default"] !== null && state2["default"] === data)
35992        return;
35993      var result = this._encodeValue(data, reporter2, parent);
35994      if (result === void 0)
35995        return;
35996      if (this._skipDefault(result, reporter2, parent))
35997        return;
35998      return result;
35999    };
36000    Node.prototype._encodeValue = function encode2(data, reporter2, parent) {
36001      var state2 = this._baseState;
36002      if (state2.parent === null)
36003        return state2.children[0]._encode(data, reporter2 || new Reporter());
36004      var result = null;
36005      this.reporter = reporter2;
36006      if (state2.optional && data === void 0) {
36007        if (state2["default"] !== null)
36008          data = state2["default"];
36009        else
36010          return;
36011      }
36012      var content = null;
36013      var primitive = false;

vendor: 5,988 bytes, lines 36014-36182

36014      if (state2.any) {
36015        result = this._createEncoderBuffer(data);
36016      } else if (state2.choice) {
36017        result = this._encodeChoice(data, reporter2);
36018      } else if (state2.contains) {
36019        content = this._getUse(state2.contains, parent)._encode(data, reporter2);
36020        primitive = true;
36021      } else if (state2.children) {
36022        content = state2.children.map(function(child2) {
36023          if (child2._baseState.tag === "null_")
36024            return child2._encode(null, reporter2, data);
36025          if (child2._baseState.key === null)
36026            return reporter2.error("Child should have a key");
36027          var prevKey = reporter2.enterKey(child2._baseState.key);
36028          if (typeof data !== "object")
36029            return reporter2.error("Child expected, but input is not object");
36030          var res = child2._encode(data[child2._baseState.key], reporter2, data);
36031          reporter2.leaveKey(prevKey);
36032          return res;
36033        }, this).filter(function(child2) {
36034          return child2;
36035        });
36036        content = this._createEncoderBuffer(content);
36037      } else {
36038        if (state2.tag === "seqof" || state2.tag === "setof") {
36039          if (!(state2.args && state2.args.length === 1))
36040            return reporter2.error("Too many args for : " + state2.tag);
36041          if (!Array.isArray(data))
36042            return reporter2.error("seqof/setof, but data is not Array");
36043          var child = this.clone();
36044          child._baseState.implicit = null;
36045          content = this._createEncoderBuffer(data.map(function(item) {
36046            var state3 = this._baseState;
36047            return this._getUse(state3.args[0], data)._encode(item, reporter2);
36048          }, child));
36049        } else if (state2.use !== null) {
36050          result = this._getUse(state2.use, parent)._encode(data, reporter2);
36051        } else {
36052          content = this._encodePrimitive(state2.tag, data);
36053          primitive = true;
36054        }
36055      }
36056      var result;
36057      if (!state2.any && state2.choice === null) {
36058        var tag = state2.implicit !== null ? state2.implicit : state2.tag;
36059        var cls = state2.implicit === null ? "universal" : "context";
36060        if (tag === null) {
36061          if (state2.use === null)
36062            reporter2.error("Tag could be omitted only for .use()");
36063        } else {
36064          if (state2.use === null)
36065            result = this._encodeComposite(tag, primitive, cls, content);
36066        }
36067      }
36068      if (state2.explicit !== null)
36069        result = this._encodeComposite(state2.explicit, false, "context", result);
36070      return result;
36071    };
36072    Node.prototype._encodeChoice = function encodeChoice(data, reporter2) {
36073      var state2 = this._baseState;
36074      var node2 = state2.choice[data.type];
36075      if (!node2) {
36076        assert2(
36077          false,
36078          data.type + " not found in " + JSON.stringify(Object.keys(state2.choice))
36079        );
36080      }
36081      return node2._encode(data.value, reporter2);
36082    };
36083    Node.prototype._encodePrimitive = function encodePrimitive(tag, data) {
36084      var state2 = this._baseState;
36085      if (/str$/.test(tag))
36086        return this._encodeStr(data, tag);
36087      else if (tag === "objid" && state2.args)
36088        return this._encodeObjid(data, state2.reverseArgs[0], state2.args[1]);
36089      else if (tag === "objid")
36090        return this._encodeObjid(data, null, null);
36091      else if (tag === "gentime" || tag === "utctime")
36092        return this._encodeTime(data, tag);
36093      else if (tag === "null_")
36094        return this._encodeNull();
36095      else if (tag === "int" || tag === "enum")
36096        return this._encodeInt(data, state2.args && state2.reverseArgs[0]);
36097      else if (tag === "bool")
36098        return this._encodeBool(data);
36099      else if (tag === "objDesc")
36100        return this._encodeStr(data, tag);
36101      else
36102        throw new Error("Unsupported tag: " + tag);
36103    };
36104    Node.prototype._isNumstr = function isNumstr(str) {
36105      return /^[0-9 ]*$/.test(str);
36106    };
36107    Node.prototype._isPrintstr = function isPrintstr(str) {
36108      return /^[A-Za-z0-9 '\(\)\+,\-\.\/:=\?]*$/.test(str);
36109    };
36110    return node$1;
36111  }
36112  var hasRequiredBase;
36113  function requireBase() {
36114    if (hasRequiredBase) return base;
36115    hasRequiredBase = 1;
36116    (function(exports$12) {
36117      var base2 = exports$12;
36118      base2.Reporter = requireReporter().Reporter;
36119      base2.DecoderBuffer = requireBuffer().DecoderBuffer;
36120      base2.EncoderBuffer = requireBuffer().EncoderBuffer;
36121      base2.Node = requireNode$1();
36122    })(base);
36123    return base;
36124  }
36125  var constants$1 = {};
36126  var der = {};
36127  var hasRequiredDer$2;
36128  function requireDer$2() {
36129    if (hasRequiredDer$2) return der;
36130    hasRequiredDer$2 = 1;
36131    (function(exports$12) {
36132      var constants2 = requireConstants$1();
36133      exports$12.tagClass = {
36134        0: "universal",
36135        1: "application",
36136        2: "context",
36137        3: "private"
36138      };
36139      exports$12.tagClassByName = constants2._reverse(exports$12.tagClass);
36140      exports$12.tag = {
36141        0: "end",
36142        1: "bool",
36143        2: "int",
36144        3: "bitstr",
36145        4: "octstr",
36146        5: "null_",
36147        6: "objid",
36148        7: "objDesc",
36149        8: "external",
36150        9: "real",
36151        10: "enum",
36152        11: "embed",
36153        12: "utf8str",
36154        13: "relativeOid",
36155        16: "seq",
36156        17: "set",
36157        18: "numstr",
36158        19: "printstr",
36159        20: "t61str",
36160        21: "videostr",
36161        22: "ia5str",
36162        23: "utctime",
36163        24: "gentime",
36164        25: "graphstr",
36165        26: "iso646str",
36166        27: "genstr",
36167        28: "unistr",
36168        29: "charstr",
36169        30: "bmpstr"
36170      };
36171      exports$12.tagByName = constants2._reverse(exports$12.tag);
36172    })(der);
36173    return der;
36174  }
36175  var hasRequiredConstants$1;
36176  function requireConstants$1() {
36177    if (hasRequiredConstants$1) return constants$1;
36178    hasRequiredConstants$1 = 1;
36179    (function(exports$12) {
36180      var constants2 = exports$12;
36181      constants2._reverse = function reverse(map) {
36182        var res = {};

vendor: 7,306 bytes, lines 36183-36391

36183        Object.keys(map).forEach(function(key2) {
36184          if ((key2 | 0) == key2)
36185            key2 = key2 | 0;
36186          var value = map[key2];
36187          res[value] = key2;
36188        });
36189        return res;
36190      };
36191      constants2.der = requireDer$2();
36192    })(constants$1);
36193    return constants$1;
36194  }
36195  var decoders = {};
36196  var der_1$1;
36197  var hasRequiredDer$1;
36198  function requireDer$1() {
36199    if (hasRequiredDer$1) return der_1$1;
36200    hasRequiredDer$1 = 1;
36201    var inherits2 = requireInherits();
36202    var asn12 = requireAsn1$1();
36203    var base2 = asn12.base;
36204    var bignum = asn12.bignum;
36205    var der2 = asn12.constants.der;
36206    function DERDecoder(entity) {
36207      this.enc = "der";
36208      this.name = entity.name;
36209      this.entity = entity;
36210      this.tree = new DERNode();
36211      this.tree._init(entity.body);
36212    }
36213    der_1$1 = DERDecoder;
36214    DERDecoder.prototype.decode = function decode(data, options) {
36215      if (!(data instanceof base2.DecoderBuffer))
36216        data = new base2.DecoderBuffer(data, options);
36217      return this.tree._decode(data, options);
36218    };
36219    function DERNode(parent) {
36220      base2.Node.call(this, "der", parent);
36221    }
36222    inherits2(DERNode, base2.Node);
36223    DERNode.prototype._peekTag = function peekTag(buffer2, tag, any) {
36224      if (buffer2.isEmpty())
36225        return false;
36226      var state2 = buffer2.save();
36227      var decodedTag = derDecodeTag(buffer2, 'Failed to peek tag: "' + tag + '"');
36228      if (buffer2.isError(decodedTag))
36229        return decodedTag;
36230      buffer2.restore(state2);
36231      return decodedTag.tag === tag || decodedTag.tagStr === tag || decodedTag.tagStr + "of" === tag || any;
36232    };
36233    DERNode.prototype._decodeTag = function decodeTag(buffer2, tag, any) {
36234      var decodedTag = derDecodeTag(
36235        buffer2,
36236        'Failed to decode tag of "' + tag + '"'
36237      );
36238      if (buffer2.isError(decodedTag))
36239        return decodedTag;
36240      var len2 = derDecodeLen(
36241        buffer2,
36242        decodedTag.primitive,
36243        'Failed to get length of "' + tag + '"'
36244      );
36245      if (buffer2.isError(len2))
36246        return len2;
36247      if (!any && decodedTag.tag !== tag && decodedTag.tagStr !== tag && decodedTag.tagStr + "of" !== tag) {
36248        return buffer2.error('Failed to match tag: "' + tag + '"');
36249      }
36250      if (decodedTag.primitive || len2 !== null)
36251        return buffer2.skip(len2, 'Failed to match body of: "' + tag + '"');
36252      var state2 = buffer2.save();
36253      var res = this._skipUntilEnd(
36254        buffer2,
36255        'Failed to skip indefinite length body: "' + this.tag + '"'
36256      );
36257      if (buffer2.isError(res))
36258        return res;
36259      len2 = buffer2.offset - state2.offset;
36260      buffer2.restore(state2);
36261      return buffer2.skip(len2, 'Failed to match body of: "' + tag + '"');
36262    };
36263    DERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer2, fail) {
36264      while (true) {
36265        var tag = derDecodeTag(buffer2, fail);
36266        if (buffer2.isError(tag))
36267          return tag;
36268        var len2 = derDecodeLen(buffer2, tag.primitive, fail);
36269        if (buffer2.isError(len2))
36270          return len2;
36271        var res;
36272        if (tag.primitive || len2 !== null)
36273          res = buffer2.skip(len2);
36274        else
36275          res = this._skipUntilEnd(buffer2, fail);
36276        if (buffer2.isError(res))
36277          return res;
36278        if (tag.tagStr === "end")
36279          break;
36280      }
36281    };
36282    DERNode.prototype._decodeList = function decodeList(buffer2, tag, decoder, options) {
36283      var result = [];
36284      while (!buffer2.isEmpty()) {
36285        var possibleEnd = this._peekTag(buffer2, "end");
36286        if (buffer2.isError(possibleEnd))
36287          return possibleEnd;
36288        var res = decoder.decode(buffer2, "der", options);
36289        if (buffer2.isError(res) && possibleEnd)
36290          break;
36291        result.push(res);
36292      }
36293      return result;
36294    };
36295    DERNode.prototype._decodeStr = function decodeStr(buffer2, tag) {
36296      if (tag === "bitstr") {
36297        var unused = buffer2.readUInt8();
36298        if (buffer2.isError(unused))
36299          return unused;
36300        return { unused, data: buffer2.raw() };
36301      } else if (tag === "bmpstr") {
36302        var raw = buffer2.raw();
36303        if (raw.length % 2 === 1)
36304          return buffer2.error("Decoding of string type: bmpstr length mismatch");
36305        var str = "";
36306        for (var i2 = 0; i2 < raw.length / 2; i2++) {
36307          str += String.fromCharCode(raw.readUInt16BE(i2 * 2));
36308        }
36309        return str;
36310      } else if (tag === "numstr") {
36311        var numstr = buffer2.raw().toString("ascii");
36312        if (!this._isNumstr(numstr)) {
36313          return buffer2.error("Decoding of string type: numstr unsupported characters");
36314        }
36315        return numstr;
36316      } else if (tag === "octstr") {
36317        return buffer2.raw();
36318      } else if (tag === "objDesc") {
36319        return buffer2.raw();
36320      } else if (tag === "printstr") {
36321        var printstr = buffer2.raw().toString("ascii");
36322        if (!this._isPrintstr(printstr)) {
36323          return buffer2.error("Decoding of string type: printstr unsupported characters");
36324        }
36325        return printstr;
36326      } else if (/str$/.test(tag)) {
36327        return buffer2.raw().toString();
36328      } else {
36329        return buffer2.error("Decoding of string type: " + tag + " unsupported");
36330      }
36331    };
36332    DERNode.prototype._decodeObjid = function decodeObjid(buffer2, values, relative) {
36333      var result;
36334      var identifiers = [];
36335      var ident = 0;
36336      while (!buffer2.isEmpty()) {
36337        var subident = buffer2.readUInt8();
36338        ident <<= 7;
36339        ident |= subident & 127;
36340        if ((subident & 128) === 0) {
36341          identifiers.push(ident);
36342          ident = 0;
36343        }
36344      }
36345      if (subident & 128)
36346        identifiers.push(ident);
36347      var first = identifiers[0] / 40 | 0;
36348      var second = identifiers[0] % 40;
36349      if (relative)
36350        result = identifiers;
36351      else
36352        result = [first, second].concat(identifiers.slice(1));
36353      if (values) {
36354        var tmp = values[result.join(" ")];
36355        if (tmp === void 0)
36356          tmp = values[result.join(".")];
36357        if (tmp !== void 0)
36358          result = tmp;
36359      }
36360      return result;
36361    };
36362    DERNode.prototype._decodeTime = function decodeTime(buffer2, tag) {
36363      var str = buffer2.raw().toString();
36364      if (tag === "gentime") {
36365        var year = str.slice(0, 4) | 0;
36366        var mon = str.slice(4, 6) | 0;
36367        var day = str.slice(6, 8) | 0;
36368        var hour = str.slice(8, 10) | 0;
36369        var min2 = str.slice(10, 12) | 0;
36370        var sec = str.slice(12, 14) | 0;
36371      } else if (tag === "utctime") {
36372        var year = str.slice(0, 2) | 0;
36373        var mon = str.slice(2, 4) | 0;
36374        var day = str.slice(4, 6) | 0;
36375        var hour = str.slice(6, 8) | 0;
36376        var min2 = str.slice(8, 10) | 0;
36377        var sec = str.slice(10, 12) | 0;
36378        if (year < 70)
36379          year = 2e3 + year;
36380        else
36381          year = 1900 + year;
36382      } else {
36383        return buffer2.error("Decoding " + tag + " time is not supported yet");
36384      }
36385      return Date.UTC(year, mon - 1, day, hour, min2, sec, 0);
36386    };
36387    DERNode.prototype._decodeNull = function decodeNull(buffer2) {
36388      return null;
36389    };
36390    DERNode.prototype._decodeBool = function decodeBool(buffer2) {
36391      var res = buffer2.readUInt8();

vendor: 4,096 bytes, lines 36392-36536

36392      if (buffer2.isError(res))
36393        return res;
36394      else
36395        return res !== 0;
36396    };
36397    DERNode.prototype._decodeInt = function decodeInt(buffer2, values) {
36398      var raw = buffer2.raw();
36399      var res = new bignum(raw);
36400      if (values)
36401        res = values[res.toString(10)] || res;
36402      return res;
36403    };
36404    DERNode.prototype._use = function use(entity, obj) {
36405      if (typeof entity === "function")
36406        entity = entity(obj);
36407      return entity._getDecoder("der").tree;
36408    };
36409    function derDecodeTag(buf, fail) {
36410      var tag = buf.readUInt8(fail);
36411      if (buf.isError(tag))
36412        return tag;
36413      var cls = der2.tagClass[tag >> 6];
36414      var primitive = (tag & 32) === 0;
36415      if ((tag & 31) === 31) {
36416        var oct = tag;
36417        tag = 0;
36418        while ((oct & 128) === 128) {
36419          oct = buf.readUInt8(fail);
36420          if (buf.isError(oct))
36421            return oct;
36422          tag <<= 7;
36423          tag |= oct & 127;
36424        }
36425      } else {
36426        tag &= 31;
36427      }
36428      var tagStr = der2.tag[tag];
36429      return {
36430        cls,
36431        primitive,
36432        tag,
36433        tagStr
36434      };
36435    }
36436    function derDecodeLen(buf, primitive, fail) {
36437      var len2 = buf.readUInt8(fail);
36438      if (buf.isError(len2))
36439        return len2;
36440      if (!primitive && len2 === 128)
36441        return null;
36442      if ((len2 & 128) === 0) {
36443        return len2;
36444      }
36445      var num = len2 & 127;
36446      if (num > 4)
36447        return buf.error("length octect is too long");
36448      len2 = 0;
36449      for (var i2 = 0; i2 < num; i2++) {
36450        len2 <<= 8;
36451        var j = buf.readUInt8(fail);
36452        if (buf.isError(j))
36453          return j;
36454        len2 |= j;
36455      }
36456      return len2;
36457    }
36458    return der_1$1;
36459  }
36460  var pem$1;
36461  var hasRequiredPem$1;
36462  function requirePem$1() {
36463    if (hasRequiredPem$1) return pem$1;
36464    hasRequiredPem$1 = 1;
36465    var inherits2 = requireInherits();
36466    var Buffer2 = requireDist().Buffer;
36467    var DERDecoder = requireDer$1();
36468    function PEMDecoder(entity) {
36469      DERDecoder.call(this, entity);
36470      this.enc = "pem";
36471    }
36472    inherits2(PEMDecoder, DERDecoder);
36473    pem$1 = PEMDecoder;
36474    PEMDecoder.prototype.decode = function decode(data, options) {
36475      var lines = data.toString().split(/[\r\n]+/g);
36476      var label = options.label.toUpperCase();
36477      var re = /^-----(BEGIN|END) ([^-]+)-----$/;
36478      var start = -1;
36479      var end = -1;
36480      for (var i2 = 0; i2 < lines.length; i2++) {
36481        var match = lines[i2].match(re);
36482        if (match === null)
36483          continue;
36484        if (match[2] !== label)
36485          continue;
36486        if (start === -1) {
36487          if (match[1] !== "BEGIN")
36488            break;
36489          start = i2;
36490        } else {
36491          if (match[1] !== "END")
36492            break;
36493          end = i2;
36494          break;
36495        }
36496      }
36497      if (start === -1 || end === -1)
36498        throw new Error("PEM section not found for: " + label);
36499      var base64 = lines.slice(start + 1, end).join("");
36500      base64.replace(/[^a-z0-9\+\/=]+/gi, "");
36501      var input = new Buffer2(base64, "base64");
36502      return DERDecoder.prototype.decode.call(this, input, options);
36503    };
36504    return pem$1;
36505  }
36506  var hasRequiredDecoders;
36507  function requireDecoders() {
36508    if (hasRequiredDecoders) return decoders;
36509    hasRequiredDecoders = 1;
36510    (function(exports$12) {
36511      var decoders2 = exports$12;
36512      decoders2.der = requireDer$1();
36513      decoders2.pem = requirePem$1();
36514    })(decoders);
36515    return decoders;
36516  }
36517  var encoders = {};
36518  var der_1;
36519  var hasRequiredDer;
36520  function requireDer() {
36521    if (hasRequiredDer) return der_1;
36522    hasRequiredDer = 1;
36523    var inherits2 = requireInherits();
36524    var Buffer2 = requireDist().Buffer;
36525    var asn12 = requireAsn1$1();
36526    var base2 = asn12.base;
36527    var der2 = asn12.constants.der;
36528    function DEREncoder(entity) {
36529      this.enc = "der";
36530      this.name = entity.name;
36531      this.entity = entity;
36532      this.tree = new DERNode();
36533      this.tree._init(entity.body);
36534    }
36535    der_1 = DEREncoder;
36536    DEREncoder.prototype.encode = function encode2(data, reporter2) {

vendor: 6,681 bytes, lines 36537-36718

36537      return this.tree._encode(data, reporter2).join();
36538    };
36539    function DERNode(parent) {
36540      base2.Node.call(this, "der", parent);
36541    }
36542    inherits2(DERNode, base2.Node);
36543    DERNode.prototype._encodeComposite = function encodeComposite(tag, primitive, cls, content) {
36544      var encodedTag = encodeTag(tag, primitive, cls, this.reporter);
36545      if (content.length < 128) {
36546        var header = new Buffer2(2);
36547        header[0] = encodedTag;
36548        header[1] = content.length;
36549        return this._createEncoderBuffer([header, content]);
36550      }
36551      var lenOctets = 1;
36552      for (var i2 = content.length; i2 >= 256; i2 >>= 8)
36553        lenOctets++;
36554      var header = new Buffer2(1 + 1 + lenOctets);
36555      header[0] = encodedTag;
36556      header[1] = 128 | lenOctets;
36557      for (var i2 = 1 + lenOctets, j = content.length; j > 0; i2--, j >>= 8)
36558        header[i2] = j & 255;
36559      return this._createEncoderBuffer([header, content]);
36560    };
36561    DERNode.prototype._encodeStr = function encodeStr(str, tag) {
36562      if (tag === "bitstr") {
36563        return this._createEncoderBuffer([str.unused | 0, str.data]);
36564      } else if (tag === "bmpstr") {
36565        var buf = new Buffer2(str.length * 2);
36566        for (var i2 = 0; i2 < str.length; i2++) {
36567          buf.writeUInt16BE(str.charCodeAt(i2), i2 * 2);
36568        }
36569        return this._createEncoderBuffer(buf);
36570      } else if (tag === "numstr") {
36571        if (!this._isNumstr(str)) {
36572          return this.reporter.error("Encoding of string type: numstr supports only digits and space");
36573        }
36574        return this._createEncoderBuffer(str);
36575      } else if (tag === "printstr") {
36576        if (!this._isPrintstr(str)) {
36577          return this.reporter.error("Encoding of string type: printstr supports only latin upper and lower case letters, digits, space, apostrophe, left and rigth parenthesis, plus sign, comma, hyphen, dot, slash, colon, equal sign, question mark");
36578        }
36579        return this._createEncoderBuffer(str);
36580      } else if (/str$/.test(tag)) {
36581        return this._createEncoderBuffer(str);
36582      } else if (tag === "objDesc") {
36583        return this._createEncoderBuffer(str);
36584      } else {
36585        return this.reporter.error("Encoding of string type: " + tag + " unsupported");
36586      }
36587    };
36588    DERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {
36589      if (typeof id === "string") {
36590        if (!values)
36591          return this.reporter.error("string objid given, but no values map found");
36592        if (!values.hasOwnProperty(id))
36593          return this.reporter.error("objid not found in values map");
36594        id = values[id].split(/[\s\.]+/g);
36595        for (var i2 = 0; i2 < id.length; i2++)
36596          id[i2] |= 0;
36597      } else if (Array.isArray(id)) {
36598        id = id.slice();
36599        for (var i2 = 0; i2 < id.length; i2++)
36600          id[i2] |= 0;
36601      }
36602      if (!Array.isArray(id)) {
36603        return this.reporter.error("objid() should be either array or string, got: " + JSON.stringify(id));
36604      }
36605      if (!relative) {
36606        if (id[1] >= 40)
36607          return this.reporter.error("Second objid identifier OOB");
36608        id.splice(0, 2, id[0] * 40 + id[1]);
36609      }
36610      var size = 0;
36611      for (var i2 = 0; i2 < id.length; i2++) {
36612        var ident = id[i2];
36613        for (size++; ident >= 128; ident >>= 7)
36614          size++;
36615      }
36616      var objid = new Buffer2(size);
36617      var offset = objid.length - 1;
36618      for (var i2 = id.length - 1; i2 >= 0; i2--) {
36619        var ident = id[i2];
36620        objid[offset--] = ident & 127;
36621        while ((ident >>= 7) > 0)
36622          objid[offset--] = 128 | ident & 127;
36623      }
36624      return this._createEncoderBuffer(objid);
36625    };
36626    function two(num) {
36627      if (num < 10)
36628        return "0" + num;
36629      else
36630        return num;
36631    }
36632    DERNode.prototype._encodeTime = function encodeTime(time, tag) {
36633      var str;
36634      var date = new Date(time);
36635      if (tag === "gentime") {
36636        str = [
36637          two(date.getFullYear()),
36638          two(date.getUTCMonth() + 1),
36639          two(date.getUTCDate()),
36640          two(date.getUTCHours()),
36641          two(date.getUTCMinutes()),
36642          two(date.getUTCSeconds()),
36643          "Z"
36644        ].join("");
36645      } else if (tag === "utctime") {
36646        str = [
36647          two(date.getFullYear() % 100),
36648          two(date.getUTCMonth() + 1),
36649          two(date.getUTCDate()),
36650          two(date.getUTCHours()),
36651          two(date.getUTCMinutes()),
36652          two(date.getUTCSeconds()),
36653          "Z"
36654        ].join("");
36655      } else {
36656        this.reporter.error("Encoding " + tag + " time is not supported yet");
36657      }
36658      return this._encodeStr(str, "octstr");
36659    };
36660    DERNode.prototype._encodeNull = function encodeNull() {
36661      return this._createEncoderBuffer("");
36662    };
36663    DERNode.prototype._encodeInt = function encodeInt(num, values) {
36664      if (typeof num === "string") {
36665        if (!values)
36666          return this.reporter.error("String int or enum given, but no values map");
36667        if (!values.hasOwnProperty(num)) {
36668          return this.reporter.error("Values map doesn't contain: " + JSON.stringify(num));
36669        }
36670        num = values[num];
36671      }
36672      if (typeof num !== "number" && !Buffer2.isBuffer(num)) {
36673        var numArray = num.toArray();
36674        if (!num.sign && numArray[0] & 128) {
36675          numArray.unshift(0);
36676        }
36677        num = new Buffer2(numArray);
36678      }
36679      if (Buffer2.isBuffer(num)) {
36680        var size = num.length;
36681        if (num.length === 0)
36682          size++;
36683        var out = new Buffer2(size);
36684        num.copy(out);
36685        if (num.length === 0)
36686          out[0] = 0;
36687        return this._createEncoderBuffer(out);
36688      }
36689      if (num < 128)
36690        return this._createEncoderBuffer(num);
36691      if (num < 256)
36692        return this._createEncoderBuffer([0, num]);
36693      var size = 1;
36694      for (var i2 = num; i2 >= 256; i2 >>= 8)
36695        size++;
36696      var out = new Array(size);
36697      for (var i2 = out.length - 1; i2 >= 0; i2--) {
36698        out[i2] = num & 255;
36699        num >>= 8;
36700      }
36701      if (out[0] & 128) {
36702        out.unshift(0);
36703      }
36704      return this._createEncoderBuffer(new Buffer2(out));
36705    };
36706    DERNode.prototype._encodeBool = function encodeBool(value) {
36707      return this._createEncoderBuffer(value ? 255 : 0);
36708    };
36709    DERNode.prototype._use = function use(entity, obj) {
36710      if (typeof entity === "function")
36711        entity = entity(obj);
36712      return entity._getEncoder("der").tree;
36713    };
36714    DERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter2, parent) {
36715      var state2 = this._baseState;
36716      var i2;
36717      if (state2["default"] === null)
36718        return false;

vendor: 5,009 bytes, lines 36719-36868

36719      var data = dataBuffer.join();
36720      if (state2.defaultBuffer === void 0)
36721        state2.defaultBuffer = this._encodeValue(state2["default"], reporter2, parent).join();
36722      if (data.length !== state2.defaultBuffer.length)
36723        return false;
36724      for (i2 = 0; i2 < data.length; i2++)
36725        if (data[i2] !== state2.defaultBuffer[i2])
36726          return false;
36727      return true;
36728    };
36729    function encodeTag(tag, primitive, cls, reporter2) {
36730      var res;
36731      if (tag === "seqof")
36732        tag = "seq";
36733      else if (tag === "setof")
36734        tag = "set";
36735      if (der2.tagByName.hasOwnProperty(tag))
36736        res = der2.tagByName[tag];
36737      else if (typeof tag === "number" && (tag | 0) === tag)
36738        res = tag;
36739      else
36740        return reporter2.error("Unknown tag: " + tag);
36741      if (res >= 31)
36742        return reporter2.error("Multi-octet tag encoding unsupported");
36743      if (!primitive)
36744        res |= 32;
36745      res |= der2.tagClassByName[cls || "universal"] << 6;
36746      return res;
36747    }
36748    return der_1;
36749  }
36750  var pem;
36751  var hasRequiredPem;
36752  function requirePem() {
36753    if (hasRequiredPem) return pem;
36754    hasRequiredPem = 1;
36755    var inherits2 = requireInherits();
36756    var DEREncoder = requireDer();
36757    function PEMEncoder(entity) {
36758      DEREncoder.call(this, entity);
36759      this.enc = "pem";
36760    }
36761    inherits2(PEMEncoder, DEREncoder);
36762    pem = PEMEncoder;
36763    PEMEncoder.prototype.encode = function encode2(data, options) {
36764      var buf = DEREncoder.prototype.encode.call(this, data);
36765      var p = buf.toString("base64");
36766      var out = ["-----BEGIN " + options.label + "-----"];
36767      for (var i2 = 0; i2 < p.length; i2 += 64)
36768        out.push(p.slice(i2, i2 + 64));
36769      out.push("-----END " + options.label + "-----");
36770      return out.join("\n");
36771    };
36772    return pem;
36773  }
36774  var hasRequiredEncoders;
36775  function requireEncoders() {
36776    if (hasRequiredEncoders) return encoders;
36777    hasRequiredEncoders = 1;
36778    (function(exports$12) {
36779      var encoders2 = exports$12;
36780      encoders2.der = requireDer();
36781      encoders2.pem = requirePem();
36782    })(encoders);
36783    return encoders;
36784  }
36785  var hasRequiredAsn1$1;
36786  function requireAsn1$1() {
36787    if (hasRequiredAsn1$1) return asn1;
36788    hasRequiredAsn1$1 = 1;
36789    (function(exports$12) {
36790      var asn12 = exports$12;
36791      asn12.bignum = requireBn$1();
36792      asn12.define = requireApi().define;
36793      asn12.base = requireBase();
36794      asn12.constants = requireConstants$1();
36795      asn12.decoders = requireDecoders();
36796      asn12.encoders = requireEncoders();
36797    })(asn1);
36798    return asn1;
36799  }
36800  var certificate;
36801  var hasRequiredCertificate;
36802  function requireCertificate() {
36803    if (hasRequiredCertificate) return certificate;
36804    hasRequiredCertificate = 1;
36805    var asn = requireAsn1$1();
36806    var Time = asn.define("Time", function() {
36807      this.choice({
36808        utcTime: this.utctime(),
36809        generalTime: this.gentime()
36810      });
36811    });
36812    var AttributeTypeValue = asn.define("AttributeTypeValue", function() {
36813      this.seq().obj(
36814        this.key("type").objid(),
36815        this.key("value").any()
36816      );
36817    });
36818    var AlgorithmIdentifier = asn.define("AlgorithmIdentifier", function() {
36819      this.seq().obj(
36820        this.key("algorithm").objid(),
36821        this.key("parameters").optional(),
36822        this.key("curve").objid().optional()
36823      );
36824    });
36825    var SubjectPublicKeyInfo = asn.define("SubjectPublicKeyInfo", function() {
36826      this.seq().obj(
36827        this.key("algorithm").use(AlgorithmIdentifier),
36828        this.key("subjectPublicKey").bitstr()
36829      );
36830    });
36831    var RelativeDistinguishedName = asn.define("RelativeDistinguishedName", function() {
36832      this.setof(AttributeTypeValue);
36833    });
36834    var RDNSequence = asn.define("RDNSequence", function() {
36835      this.seqof(RelativeDistinguishedName);
36836    });
36837    var Name = asn.define("Name", function() {
36838      this.choice({
36839        rdnSequence: this.use(RDNSequence)
36840      });
36841    });
36842    var Validity = asn.define("Validity", function() {
36843      this.seq().obj(
36844        this.key("notBefore").use(Time),
36845        this.key("notAfter").use(Time)
36846      );
36847    });
36848    var Extension = asn.define("Extension", function() {
36849      this.seq().obj(
36850        this.key("extnID").objid(),
36851        this.key("critical").bool().def(false),
36852        this.key("extnValue").octstr()
36853      );
36854    });
36855    var TBSCertificate = asn.define("TBSCertificate", function() {
36856      this.seq().obj(
36857        this.key("version").explicit(0)["int"]().optional(),
36858        this.key("serialNumber")["int"](),
36859        this.key("signature").use(AlgorithmIdentifier),
36860        this.key("issuer").use(Name),
36861        this.key("validity").use(Validity),
36862        this.key("subject").use(Name),
36863        this.key("subjectPublicKeyInfo").use(SubjectPublicKeyInfo),
36864        this.key("issuerUniqueID").implicit(1).bitstr().optional(),
36865        this.key("subjectUniqueID").implicit(2).bitstr().optional(),
36866        this.key("extensions").explicit(3).seqof(Extension).optional()
36867      );
36868    });

vendor: 4,195 bytes, lines 36869-36993

36869    var X509Certificate = asn.define("X509Certificate", function() {
36870      this.seq().obj(
36871        this.key("tbsCertificate").use(TBSCertificate),
36872        this.key("signatureAlgorithm").use(AlgorithmIdentifier),
36873        this.key("signatureValue").bitstr()
36874      );
36875    });
36876    certificate = X509Certificate;
36877    return certificate;
36878  }
36879  var hasRequiredAsn1;
36880  function requireAsn1() {
36881    if (hasRequiredAsn1) return asn1$1;
36882    hasRequiredAsn1 = 1;
36883    var asn12 = requireAsn1$1();
36884    asn1$1.certificate = requireCertificate();
36885    var RSAPrivateKey = asn12.define("RSAPrivateKey", function() {
36886      this.seq().obj(
36887        this.key("version")["int"](),
36888        this.key("modulus")["int"](),
36889        this.key("publicExponent")["int"](),
36890        this.key("privateExponent")["int"](),
36891        this.key("prime1")["int"](),
36892        this.key("prime2")["int"](),
36893        this.key("exponent1")["int"](),
36894        this.key("exponent2")["int"](),
36895        this.key("coefficient")["int"]()
36896      );
36897    });
36898    asn1$1.RSAPrivateKey = RSAPrivateKey;
36899    var RSAPublicKey = asn12.define("RSAPublicKey", function() {
36900      this.seq().obj(
36901        this.key("modulus")["int"](),
36902        this.key("publicExponent")["int"]()
36903      );
36904    });
36905    asn1$1.RSAPublicKey = RSAPublicKey;
36906    var AlgorithmIdentifier = asn12.define("AlgorithmIdentifier", function() {
36907      this.seq().obj(
36908        this.key("algorithm").objid(),
36909        this.key("none").null_().optional(),
36910        this.key("curve").objid().optional(),
36911        this.key("params").seq().obj(
36912          this.key("p")["int"](),
36913          this.key("q")["int"](),
36914          this.key("g")["int"]()
36915        ).optional()
36916      );
36917    });
36918    var PublicKey = asn12.define("SubjectPublicKeyInfo", function() {
36919      this.seq().obj(
36920        this.key("algorithm").use(AlgorithmIdentifier),
36921        this.key("subjectPublicKey").bitstr()
36922      );
36923    });
36924    asn1$1.PublicKey = PublicKey;
36925    var PrivateKeyInfo = asn12.define("PrivateKeyInfo", function() {
36926      this.seq().obj(
36927        this.key("version")["int"](),
36928        this.key("algorithm").use(AlgorithmIdentifier),
36929        this.key("subjectPrivateKey").octstr()
36930      );
36931    });
36932    asn1$1.PrivateKey = PrivateKeyInfo;
36933    var EncryptedPrivateKeyInfo = asn12.define("EncryptedPrivateKeyInfo", function() {
36934      this.seq().obj(
36935        this.key("algorithm").seq().obj(
36936          this.key("id").objid(),
36937          this.key("decrypt").seq().obj(
36938            this.key("kde").seq().obj(
36939              this.key("id").objid(),
36940              this.key("kdeparams").seq().obj(
36941                this.key("salt").octstr(),
36942                this.key("iters")["int"]()
36943              )
36944            ),
36945            this.key("cipher").seq().obj(
36946              this.key("algo").objid(),
36947              this.key("iv").octstr()
36948            )
36949          )
36950        ),
36951        this.key("subjectPrivateKey").octstr()
36952      );
36953    });
36954    asn1$1.EncryptedPrivateKey = EncryptedPrivateKeyInfo;
36955    var DSAPrivateKey = asn12.define("DSAPrivateKey", function() {
36956      this.seq().obj(
36957        this.key("version")["int"](),
36958        this.key("p")["int"](),
36959        this.key("q")["int"](),
36960        this.key("g")["int"](),
36961        this.key("pub_key")["int"](),
36962        this.key("priv_key")["int"]()
36963      );
36964    });
36965    asn1$1.DSAPrivateKey = DSAPrivateKey;
36966    asn1$1.DSAparam = asn12.define("DSAparam", function() {
36967      this["int"]();
36968    });
36969    var ECParameters = asn12.define("ECParameters", function() {
36970      this.choice({
36971        namedCurve: this.objid()
36972      });
36973    });
36974    var ECPrivateKey = asn12.define("ECPrivateKey", function() {
36975      this.seq().obj(
36976        this.key("version")["int"](),
36977        this.key("privateKey").octstr(),
36978        this.key("parameters").optional().explicit(0).use(ECParameters),
36979        this.key("publicKey").optional().explicit(1).bitstr()
36980      );
36981    });
36982    asn1$1.ECPrivateKey = ECPrivateKey;
36983    asn1$1.signature = asn12.define("signature", function() {
36984      this.seq().obj(
36985        this.key("r")["int"](),
36986        this.key("s")["int"]()
36987      );
36988    });
36989    return asn1$1;
36990  }
36991  const require$$1 = {
36992    "2.16.840.1.101.3.4.1.1": "aes-128-ecb",
36993    "2.16.840.1.101.3.4.1.2": "aes-128-cbc",

36994    "2.16.840.1.101.3.4.1.3": "aes-128-ofb",
36995    "2.16.840.1.101.3.4.1.4": "aes-128-cfb",
36996    "2.16.840.1.101.3.4.1.21": "aes-192-ecb",
36997    "2.16.840.1.101.3.4.1.22": "aes-192-cbc",
36998    "2.16.840.1.101.3.4.1.23": "aes-192-ofb",
36999    "2.16.840.1.101.3.4.1.24": "aes-192-cfb",
37000    "2.16.840.1.101.3.4.1.41": "aes-256-ecb",
37001    "2.16.840.1.101.3.4.1.42": "aes-256-cbc",
37002    "2.16.840.1.101.3.4.1.43": "aes-256-ofb",
37003    "2.16.840.1.101.3.4.1.44": "aes-256-cfb"
37004  };
37005  var toBuffer_1;
37006  var hasRequiredToBuffer;
37007  function requireToBuffer() {
37008    if (hasRequiredToBuffer) return toBuffer_1;
37009    hasRequiredToBuffer = 1;
37010    var Buffer2 = requireSafeBuffer$1().Buffer;
37011    var toBuffer2 = /* @__PURE__ */ requireToBuffer$2();
37012    var useUint8Array = typeof Uint8Array !== "undefined";
37013    var useArrayBuffer = useUint8Array && typeof ArrayBuffer !== "undefined";
37014    var isView = useArrayBuffer && ArrayBuffer.isView;
37015    toBuffer_1 = function(thing, encoding) {
37016      if (typeof thing === "string" || Buffer2.isBuffer(thing) || useUint8Array && thing instanceof Uint8Array || isView && isView(thing)) {
37017        return toBuffer2(thing, encoding);
37018      }
37019      throw new TypeError('The "data" argument must be a string, a Buffer, a Uint8Array, or a DataView');
37020    };
37021    return toBuffer_1;
37022  }
37023  var readable = { exports: {} };
37024  var processNextickArgs = { exports: {} };
37025  var hasRequiredProcessNextickArgs;
37026  function requireProcessNextickArgs() {
37027    if (hasRequiredProcessNextickArgs) return processNextickArgs.exports;
37028    hasRequiredProcessNextickArgs = 1;
37029    if (typeof process$1 === "undefined" || !process$1.version || process$1.version.indexOf("v0.") === 0 || process$1.version.indexOf("v1.") === 0 && process$1.version.indexOf("v1.8.") !== 0) {
37030      processNextickArgs.exports = { nextTick };
37031    } else {
37032      processNextickArgs.exports = process$1;
37033    }
37034    function nextTick(fn, arg1, arg2, arg3) {
37035      if (typeof fn !== "function") {
37036        throw new TypeError('"callback" argument must be a function');
37037      }
37038      var len2 = arguments.length;
37039      var args, i2;
37040      switch (len2) {
37041        case 0:
37042        case 1:
37043          return process$1.nextTick(fn);
37044        case 2:
37045          return process$1.nextTick(function afterTickOne() {
37046            fn.call(null, arg1);
37047          });
37048        case 3:
37049          return process$1.nextTick(function afterTickTwo() {
37050            fn.call(null, arg1, arg2);
37051          });
37052        case 4:
37053          return process$1.nextTick(function afterTickThree() {
37054            fn.call(null, arg1, arg2, arg3);
37055          });
37056        default:
37057          args = new Array(len2 - 1);
37058          i2 = 0;
37059          while (i2 < args.length) {
37060            args[i2++] = arguments[i2];
37061          }
37062          return process$1.nextTick(function afterTick() {
37063            fn.apply(null, args);
37064          });
37065      }
37066    }
37067    return processNextickArgs.exports;
37068  }
37069  var isarray;
37070  var hasRequiredIsarray;
37071  function requireIsarray() {
37072    if (hasRequiredIsarray) return isarray;
37073    hasRequiredIsarray = 1;
37074    var toString2 = {}.toString;
37075    isarray = Array.isArray || function(arr) {
37076      return toString2.call(arr) == "[object Array]";
37077    };
37078    return isarray;
37079  }
37080  var stream$1;
37081  var hasRequiredStream;
37082  function requireStream() {
37083    if (hasRequiredStream) return stream$1;
37084    hasRequiredStream = 1;
37085    stream$1 = requireStreamBrowserify();
37086    return stream$1;
37087  }
37088  var safeBuffer = { exports: {} };
37089  var hasRequiredSafeBuffer;
37090  function requireSafeBuffer() {
37091    if (hasRequiredSafeBuffer) return safeBuffer.exports;
37092    hasRequiredSafeBuffer = 1;
37093    (function(module, exports$12) {
37094      var buffer2 = requireDist();
37095      var Buffer2 = buffer2.Buffer;
37096      function copyProps(src2, dst) {
37097        for (var key2 in src2) {
37098          dst[key2] = src2[key2];
37099        }
37100      }
37101      if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
37102        module.exports = buffer2;
37103      } else {
37104        copyProps(buffer2, exports$12);
37105        exports$12.Buffer = SafeBuffer;
37106      }
37107      function SafeBuffer(arg, encodingOrOffset, length) {
37108        return Buffer2(arg, encodingOrOffset, length);
37109      }
37110      copyProps(Buffer2, SafeBuffer);
37111      SafeBuffer.from = function(arg, encodingOrOffset, length) {
37112        if (typeof arg === "number") {
37113          throw new TypeError("Argument must not be a number");
37114        }
37115        return Buffer2(arg, encodingOrOffset, length);
37116      };
37117      SafeBuffer.alloc = function(size, fill, encoding) {

vendor: 5,376 bytes, lines 37118-37288

37118        if (typeof size !== "number") {
37119          throw new TypeError("Argument must be a number");
37120        }
37121        var buf = Buffer2(size);
37122        if (fill !== void 0) {
37123          if (typeof encoding === "string") {
37124            buf.fill(fill, encoding);
37125          } else {
37126            buf.fill(fill);
37127          }
37128        } else {
37129          buf.fill(0);
37130        }
37131        return buf;
37132      };
37133      SafeBuffer.allocUnsafe = function(size) {
37134        if (typeof size !== "number") {
37135          throw new TypeError("Argument must be a number");
37136        }
37137        return Buffer2(size);
37138      };
37139      SafeBuffer.allocUnsafeSlow = function(size) {
37140        if (typeof size !== "number") {
37141          throw new TypeError("Argument must be a number");
37142        }
37143        return buffer2.SlowBuffer(size);
37144      };
37145    })(safeBuffer, safeBuffer.exports);
37146    return safeBuffer.exports;
37147  }
37148  var util$1 = {};
37149  var hasRequiredUtil;
37150  function requireUtil() {
37151    if (hasRequiredUtil) return util$1;
37152    hasRequiredUtil = 1;
37153    function isArray2(arg) {
37154      if (Array.isArray) {
37155        return Array.isArray(arg);
37156      }
37157      return objectToString(arg) === "[object Array]";
37158    }
37159    util$1.isArray = isArray2;
37160    function isBoolean2(arg) {
37161      return typeof arg === "boolean";
37162    }
37163    util$1.isBoolean = isBoolean2;
37164    function isNull(arg) {
37165      return arg === null;
37166    }
37167    util$1.isNull = isNull;
37168    function isNullOrUndefined(arg) {
37169      return arg == null;
37170    }
37171    util$1.isNullOrUndefined = isNullOrUndefined;
37172    function isNumber2(arg) {
37173      return typeof arg === "number";
37174    }
37175    util$1.isNumber = isNumber2;
37176    function isString2(arg) {
37177      return typeof arg === "string";
37178    }
37179    util$1.isString = isString2;
37180    function isSymbol(arg) {
37181      return typeof arg === "symbol";
37182    }
37183    util$1.isSymbol = isSymbol;
37184    function isUndefined2(arg) {
37185      return arg === void 0;
37186    }
37187    util$1.isUndefined = isUndefined2;
37188    function isRegExp2(re) {
37189      return objectToString(re) === "[object RegExp]";
37190    }
37191    util$1.isRegExp = isRegExp2;
37192    function isObject2(arg) {
37193      return typeof arg === "object" && arg !== null;
37194    }
37195    util$1.isObject = isObject2;
37196    function isDate2(d) {
37197      return objectToString(d) === "[object Date]";
37198    }
37199    util$1.isDate = isDate2;
37200    function isError(e) {
37201      return objectToString(e) === "[object Error]" || e instanceof Error;
37202    }
37203    util$1.isError = isError;
37204    function isFunction2(arg) {
37205      return typeof arg === "function";
37206    }
37207    util$1.isFunction = isFunction2;
37208    function isPrimitive(arg) {
37209      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
37210      typeof arg === "undefined";
37211    }
37212    util$1.isPrimitive = isPrimitive;
37213    util$1.isBuffer = requireDist().Buffer.isBuffer;
37214    function objectToString(o) {
37215      return Object.prototype.toString.call(o);
37216    }
37217    return util$1;
37218  }
37219  var BufferList = { exports: {} };
37220  var hasRequiredBufferList;
37221  function requireBufferList() {
37222    if (hasRequiredBufferList) return BufferList.exports;
37223    hasRequiredBufferList = 1;
37224    (function(module) {
37225      function _classCallCheck(instance, Constructor) {
37226        if (!(instance instanceof Constructor)) {
37227          throw new TypeError("Cannot call a class as a function");
37228        }
37229      }
37230      var Buffer2 = requireSafeBuffer().Buffer;
37231      var util2 = requireUtil$1();
37232      function copyBuffer(src2, target, offset) {
37233        src2.copy(target, offset);
37234      }
37235      module.exports = (function() {
37236        function BufferList2() {
37237          _classCallCheck(this, BufferList2);
37238          this.head = null;
37239          this.tail = null;
37240          this.length = 0;
37241        }
37242        BufferList2.prototype.push = function push(v) {
37243          var entry = { data: v, next: null };
37244          if (this.length > 0) this.tail.next = entry;
37245          else this.head = entry;
37246          this.tail = entry;
37247          ++this.length;
37248        };
37249        BufferList2.prototype.unshift = function unshift(v) {
37250          var entry = { data: v, next: this.head };
37251          if (this.length === 0) this.tail = entry;
37252          this.head = entry;
37253          ++this.length;
37254        };
37255        BufferList2.prototype.shift = function shift() {
37256          if (this.length === 0) return;
37257          var ret = this.head.data;
37258          if (this.length === 1) this.head = this.tail = null;
37259          else this.head = this.head.next;
37260          --this.length;
37261          return ret;
37262        };
37263        BufferList2.prototype.clear = function clear() {
37264          this.head = this.tail = null;
37265          this.length = 0;
37266        };
37267        BufferList2.prototype.join = function join(s) {
37268          if (this.length === 0) return "";
37269          var p = this.head;
37270          var ret = "" + p.data;
37271          while (p = p.next) {
37272            ret += s + p.data;
37273          }
37274          return ret;
37275        };
37276        BufferList2.prototype.concat = function concat(n) {
37277          if (this.length === 0) return Buffer2.alloc(0);
37278          var ret = Buffer2.allocUnsafe(n >>> 0);
37279          var p = this.head;
37280          var i2 = 0;
37281          while (p) {
37282            copyBuffer(p.data, ret, i2);
37283            i2 += p.data.length;
37284            p = p.next;
37285          }
37286          return ret;
37287        };
37288        return BufferList2;

37289      })();
37290      if (util2 && util2.inspect && util2.inspect.custom) {
37291        module.exports.prototype[util2.inspect.custom] = function() {
37292          var obj = util2.inspect({ length: this.length });
37293          return this.constructor.name + " " + obj;
37294        };
37295      }
37296    })(BufferList);
37297    return BufferList.exports;
37298  }
37299  var destroy_1;
37300  var hasRequiredDestroy;
37301  function requireDestroy() {
37302    if (hasRequiredDestroy) return destroy_1;
37303    hasRequiredDestroy = 1;
37304    var pna = requireProcessNextickArgs();
37305    function destroy(err, cb) {
37306      var _this = this;
37307      var readableDestroyed = this._readableState && this._readableState.destroyed;
37308      var writableDestroyed = this._writableState && this._writableState.destroyed;
37309      if (readableDestroyed || writableDestroyed) {
37310        if (cb) {
37311          cb(err);
37312        } else if (err) {
37313          if (!this._writableState) {
37314            pna.nextTick(emitErrorNT, this, err);
37315          } else if (!this._writableState.errorEmitted) {
37316            this._writableState.errorEmitted = true;
37317            pna.nextTick(emitErrorNT, this, err);
37318          }
37319        }
37320        return this;
37321      }
37322      if (this._readableState) {
37323        this._readableState.destroyed = true;
37324      }
37325      if (this._writableState) {
37326        this._writableState.destroyed = true;
37327      }
37328      this._destroy(err || null, function(err2) {
37329        if (!cb && err2) {
37330          if (!_this._writableState) {
37331            pna.nextTick(emitErrorNT, _this, err2);
37332          } else if (!_this._writableState.errorEmitted) {
37333            _this._writableState.errorEmitted = true;
37334            pna.nextTick(emitErrorNT, _this, err2);
37335          }
37336        } else if (cb) {
37337          cb(err2);
37338        }
37339      });
37340      return this;
37341    }
37342    function undestroy() {
37343      if (this._readableState) {
37344        this._readableState.destroyed = false;
37345        this._readableState.reading = false;
37346        this._readableState.ended = false;
37347        this._readableState.endEmitted = false;
37348      }
37349      if (this._writableState) {
37350        this._writableState.destroyed = false;
37351        this._writableState.ended = false;
37352        this._writableState.ending = false;
37353        this._writableState.finalCalled = false;
37354        this._writableState.prefinished = false;
37355        this._writableState.finished = false;
37356        this._writableState.errorEmitted = false;
37357      }
37358    }
37359    function emitErrorNT(self2, err) {
37360      self2.emit("error", err);
37361    }
37362    destroy_1 = {
37363      destroy,
37364      undestroy
37365    };
37366    return destroy_1;
37367  }
37368  var _stream_writable;
37369  var hasRequired_stream_writable;
37370  function require_stream_writable() {
37371    if (hasRequired_stream_writable) return _stream_writable;
37372    hasRequired_stream_writable = 1;
37373    var pna = requireProcessNextickArgs();
37374    _stream_writable = Writable;
37375    function CorkedRequest(state2) {
37376      var _this = this;
37377      this.next = null;
37378      this.entry = null;
37379      this.finish = function() {
37380        onCorkedFinish(_this, state2);
37381      };
37382    }
37383    var asyncWrite = !process$1.browser && ["v0.10", "v0.9."].indexOf(process$1.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
37384    var Duplex;
37385    Writable.WritableState = WritableState;
37386    var util2 = Object.create(requireUtil());
37387    util2.inherits = requireInherits();
37388    var internalUtil = {
37389      deprecate: requireNode$2()
37390    };
37391    var Stream = requireStream();
37392    var Buffer2 = requireSafeBuffer().Buffer;
37393    var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
37394    };
37395    function _uint8ArrayToBuffer(chunk) {
37396      return Buffer2.from(chunk);
37397    }
37398    function _isUint8Array(obj) {
37399      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
37400    }
37401    var destroyImpl = requireDestroy();
37402    util2.inherits(Writable, Stream);
37403    function nop() {
37404    }
37405    function WritableState(options, stream2) {
37406      Duplex = Duplex || require_stream_duplex();
37407      options = options || {};
37408      var isDuplex = stream2 instanceof Duplex;
37409      this.objectMode = !!options.objectMode;
37410      if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
37411      var hwm = options.highWaterMark;
37412      var writableHwm = options.writableHighWaterMark;
37413      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
37414      if (hwm || hwm === 0) this.highWaterMark = hwm;
37415      else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;
37416      else this.highWaterMark = defaultHwm;
37417      this.highWaterMark = Math.floor(this.highWaterMark);
37418      this.finalCalled = false;

vendor: 12,306 bytes, lines 37419-37773

37419      this.needDrain = false;
37420      this.ending = false;
37421      this.ended = false;
37422      this.finished = false;
37423      this.destroyed = false;
37424      var noDecode = options.decodeStrings === false;
37425      this.decodeStrings = !noDecode;
37426      this.defaultEncoding = options.defaultEncoding || "utf8";
37427      this.length = 0;
37428      this.writing = false;
37429      this.corked = 0;
37430      this.sync = true;
37431      this.bufferProcessing = false;
37432      this.onwrite = function(er) {
37433        onwrite(stream2, er);
37434      };
37435      this.writecb = null;
37436      this.writelen = 0;
37437      this.bufferedRequest = null;
37438      this.lastBufferedRequest = null;
37439      this.pendingcb = 0;
37440      this.prefinished = false;
37441      this.errorEmitted = false;
37442      this.bufferedRequestCount = 0;
37443      this.corkedRequestsFree = new CorkedRequest(this);
37444    }
37445    WritableState.prototype.getBuffer = function getBuffer() {
37446      var current = this.bufferedRequest;
37447      var out = [];
37448      while (current) {
37449        out.push(current);
37450        current = current.next;
37451      }
37452      return out;
37453    };
37454    (function() {
37455      try {
37456        Object.defineProperty(WritableState.prototype, "buffer", {
37457          get: internalUtil.deprecate(function() {
37458            return this.getBuffer();
37459          }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
37460        });
37461      } catch (_2) {
37462      }
37463    })();
37464    var realHasInstance;
37465    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
37466      realHasInstance = Function.prototype[Symbol.hasInstance];
37467      Object.defineProperty(Writable, Symbol.hasInstance, {
37468        value: function(object) {
37469          if (realHasInstance.call(this, object)) return true;
37470          if (this !== Writable) return false;
37471          return object && object._writableState instanceof WritableState;
37472        }
37473      });
37474    } else {
37475      realHasInstance = function(object) {
37476        return object instanceof this;
37477      };
37478    }
37479    function Writable(options) {
37480      Duplex = Duplex || require_stream_duplex();
37481      if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
37482        return new Writable(options);
37483      }
37484      this._writableState = new WritableState(options, this);
37485      this.writable = true;
37486      if (options) {
37487        if (typeof options.write === "function") this._write = options.write;
37488        if (typeof options.writev === "function") this._writev = options.writev;
37489        if (typeof options.destroy === "function") this._destroy = options.destroy;
37490        if (typeof options.final === "function") this._final = options.final;
37491      }
37492      Stream.call(this);
37493    }
37494    Writable.prototype.pipe = function() {
37495      this.emit("error", new Error("Cannot pipe, not readable"));
37496    };
37497    function writeAfterEnd(stream2, cb) {
37498      var er = new Error("write after end");
37499      stream2.emit("error", er);
37500      pna.nextTick(cb, er);
37501    }
37502    function validChunk(stream2, state2, chunk, cb) {
37503      var valid = true;
37504      var er = false;
37505      if (chunk === null) {
37506        er = new TypeError("May not write null values to stream");
37507      } else if (typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
37508        er = new TypeError("Invalid non-string/buffer chunk");
37509      }
37510      if (er) {
37511        stream2.emit("error", er);
37512        pna.nextTick(cb, er);
37513        valid = false;
37514      }
37515      return valid;
37516    }
37517    Writable.prototype.write = function(chunk, encoding, cb) {
37518      var state2 = this._writableState;
37519      var ret = false;
37520      var isBuf = !state2.objectMode && _isUint8Array(chunk);
37521      if (isBuf && !Buffer2.isBuffer(chunk)) {
37522        chunk = _uint8ArrayToBuffer(chunk);
37523      }
37524      if (typeof encoding === "function") {
37525        cb = encoding;
37526        encoding = null;
37527      }
37528      if (isBuf) encoding = "buffer";
37529      else if (!encoding) encoding = state2.defaultEncoding;
37530      if (typeof cb !== "function") cb = nop;
37531      if (state2.ended) writeAfterEnd(this, cb);
37532      else if (isBuf || validChunk(this, state2, chunk, cb)) {
37533        state2.pendingcb++;
37534        ret = writeOrBuffer(this, state2, isBuf, chunk, encoding, cb);
37535      }
37536      return ret;
37537    };
37538    Writable.prototype.cork = function() {
37539      var state2 = this._writableState;
37540      state2.corked++;
37541    };
37542    Writable.prototype.uncork = function() {
37543      var state2 = this._writableState;
37544      if (state2.corked) {
37545        state2.corked--;
37546        if (!state2.writing && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) clearBuffer(this, state2);
37547      }
37548    };
37549    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
37550      if (typeof encoding === "string") encoding = encoding.toLowerCase();
37551      if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
37552      this._writableState.defaultEncoding = encoding;
37553      return this;
37554    };
37555    function decodeChunk(state2, chunk, encoding) {
37556      if (!state2.objectMode && state2.decodeStrings !== false && typeof chunk === "string") {
37557        chunk = Buffer2.from(chunk, encoding);
37558      }
37559      return chunk;
37560    }
37561    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
37562      // making it explicit this property is not enumerable
37563      // because otherwise some prototype manipulation in
37564      // userland will fail
37565      enumerable: false,
37566      get: function() {
37567        return this._writableState.highWaterMark;
37568      }
37569    });
37570    function writeOrBuffer(stream2, state2, isBuf, chunk, encoding, cb) {
37571      if (!isBuf) {
37572        var newChunk = decodeChunk(state2, chunk, encoding);
37573        if (chunk !== newChunk) {
37574          isBuf = true;
37575          encoding = "buffer";
37576          chunk = newChunk;
37577        }
37578      }
37579      var len2 = state2.objectMode ? 1 : chunk.length;
37580      state2.length += len2;
37581      var ret = state2.length < state2.highWaterMark;
37582      if (!ret) state2.needDrain = true;
37583      if (state2.writing || state2.corked) {
37584        var last = state2.lastBufferedRequest;
37585        state2.lastBufferedRequest = {
37586          chunk,
37587          encoding,
37588          isBuf,
37589          callback: cb,
37590          next: null
37591        };
37592        if (last) {
37593          last.next = state2.lastBufferedRequest;
37594        } else {
37595          state2.bufferedRequest = state2.lastBufferedRequest;
37596        }
37597        state2.bufferedRequestCount += 1;
37598      } else {
37599        doWrite(stream2, state2, false, len2, chunk, encoding, cb);
37600      }
37601      return ret;
37602    }
37603    function doWrite(stream2, state2, writev, len2, chunk, encoding, cb) {
37604      state2.writelen = len2;
37605      state2.writecb = cb;
37606      state2.writing = true;
37607      state2.sync = true;
37608      if (writev) stream2._writev(chunk, state2.onwrite);
37609      else stream2._write(chunk, encoding, state2.onwrite);
37610      state2.sync = false;
37611    }
37612    function onwriteError(stream2, state2, sync2, er, cb) {
37613      --state2.pendingcb;
37614      if (sync2) {
37615        pna.nextTick(cb, er);
37616        pna.nextTick(finishMaybe, stream2, state2);
37617        stream2._writableState.errorEmitted = true;
37618        stream2.emit("error", er);
37619      } else {
37620        cb(er);
37621        stream2._writableState.errorEmitted = true;
37622        stream2.emit("error", er);
37623        finishMaybe(stream2, state2);
37624      }
37625    }
37626    function onwriteStateUpdate(state2) {
37627      state2.writing = false;
37628      state2.writecb = null;
37629      state2.length -= state2.writelen;
37630      state2.writelen = 0;
37631    }
37632    function onwrite(stream2, er) {
37633      var state2 = stream2._writableState;
37634      var sync2 = state2.sync;
37635      var cb = state2.writecb;
37636      onwriteStateUpdate(state2);
37637      if (er) onwriteError(stream2, state2, sync2, er, cb);
37638      else {
37639        var finished = needFinish(state2);
37640        if (!finished && !state2.corked && !state2.bufferProcessing && state2.bufferedRequest) {
37641          clearBuffer(stream2, state2);
37642        }
37643        if (sync2) {
37644          asyncWrite(afterWrite, stream2, state2, finished, cb);
37645        } else {
37646          afterWrite(stream2, state2, finished, cb);
37647        }
37648      }
37649    }
37650    function afterWrite(stream2, state2, finished, cb) {
37651      if (!finished) onwriteDrain(stream2, state2);
37652      state2.pendingcb--;
37653      cb();
37654      finishMaybe(stream2, state2);
37655    }
37656    function onwriteDrain(stream2, state2) {
37657      if (state2.length === 0 && state2.needDrain) {
37658        state2.needDrain = false;
37659        stream2.emit("drain");
37660      }
37661    }
37662    function clearBuffer(stream2, state2) {
37663      state2.bufferProcessing = true;
37664      var entry = state2.bufferedRequest;
37665      if (stream2._writev && entry && entry.next) {
37666        var l = state2.bufferedRequestCount;
37667        var buffer2 = new Array(l);
37668        var holder = state2.corkedRequestsFree;
37669        holder.entry = entry;
37670        var count = 0;
37671        var allBuffers = true;
37672        while (entry) {
37673          buffer2[count] = entry;
37674          if (!entry.isBuf) allBuffers = false;
37675          entry = entry.next;
37676          count += 1;
37677        }
37678        buffer2.allBuffers = allBuffers;
37679        doWrite(stream2, state2, true, state2.length, buffer2, "", holder.finish);
37680        state2.pendingcb++;
37681        state2.lastBufferedRequest = null;
37682        if (holder.next) {
37683          state2.corkedRequestsFree = holder.next;
37684          holder.next = null;
37685        } else {
37686          state2.corkedRequestsFree = new CorkedRequest(state2);
37687        }
37688        state2.bufferedRequestCount = 0;
37689      } else {
37690        while (entry) {
37691          var chunk = entry.chunk;
37692          var encoding = entry.encoding;
37693          var cb = entry.callback;
37694          var len2 = state2.objectMode ? 1 : chunk.length;
37695          doWrite(stream2, state2, false, len2, chunk, encoding, cb);
37696          entry = entry.next;
37697          state2.bufferedRequestCount--;
37698          if (state2.writing) {
37699            break;
37700          }
37701        }
37702        if (entry === null) state2.lastBufferedRequest = null;
37703      }
37704      state2.bufferedRequest = entry;
37705      state2.bufferProcessing = false;
37706    }
37707    Writable.prototype._write = function(chunk, encoding, cb) {
37708      cb(new Error("_write() is not implemented"));
37709    };
37710    Writable.prototype._writev = null;
37711    Writable.prototype.end = function(chunk, encoding, cb) {
37712      var state2 = this._writableState;
37713      if (typeof chunk === "function") {
37714        cb = chunk;
37715        chunk = null;
37716        encoding = null;
37717      } else if (typeof encoding === "function") {
37718        cb = encoding;
37719        encoding = null;
37720      }
37721      if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
37722      if (state2.corked) {
37723        state2.corked = 1;
37724        this.uncork();
37725      }
37726      if (!state2.ending) endWritable(this, state2, cb);
37727    };
37728    function needFinish(state2) {
37729      return state2.ending && state2.length === 0 && state2.bufferedRequest === null && !state2.finished && !state2.writing;
37730    }
37731    function callFinal(stream2, state2) {
37732      stream2._final(function(err) {
37733        state2.pendingcb--;
37734        if (err) {
37735          stream2.emit("error", err);
37736        }
37737        state2.prefinished = true;
37738        stream2.emit("prefinish");
37739        finishMaybe(stream2, state2);
37740      });
37741    }
37742    function prefinish(stream2, state2) {
37743      if (!state2.prefinished && !state2.finalCalled) {
37744        if (typeof stream2._final === "function") {
37745          state2.pendingcb++;
37746          state2.finalCalled = true;
37747          pna.nextTick(callFinal, stream2, state2);
37748        } else {
37749          state2.prefinished = true;
37750          stream2.emit("prefinish");
37751        }
37752      }
37753    }
37754    function finishMaybe(stream2, state2) {
37755      var need = needFinish(state2);
37756      if (need) {
37757        prefinish(stream2, state2);
37758        if (state2.pendingcb === 0) {
37759          state2.finished = true;
37760          stream2.emit("finish");
37761        }
37762      }
37763      return need;
37764    }
37765    function endWritable(stream2, state2, cb) {
37766      state2.ending = true;
37767      finishMaybe(stream2, state2);
37768      if (cb) {
37769        if (state2.finished) pna.nextTick(cb);
37770        else stream2.once("finish", cb);
37771      }
37772      state2.ended = true;
37773      stream2.writable = false;

37774    }
37775    function onCorkedFinish(corkReq, state2, err) {
37776      var entry = corkReq.entry;
37777      corkReq.entry = null;
37778      while (entry) {
37779        var cb = entry.callback;
37780        state2.pendingcb--;
37781        cb(err);
37782        entry = entry.next;
37783      }
37784      state2.corkedRequestsFree.next = corkReq;
37785    }
37786    Object.defineProperty(Writable.prototype, "destroyed", {
37787      get: function() {
37788        if (this._writableState === void 0) {
37789          return false;
37790        }
37791        return this._writableState.destroyed;
37792      },
37793      set: function(value) {
37794        if (!this._writableState) {
37795          return;
37796        }
37797        this._writableState.destroyed = value;
37798      }
37799    });
37800    Writable.prototype.destroy = destroyImpl.destroy;
37801    Writable.prototype._undestroy = destroyImpl.undestroy;
37802    Writable.prototype._destroy = function(err, cb) {
37803      this.end();
37804      cb(err);
37805    };
37806    return _stream_writable;
37807  }
37808  var _stream_duplex;
37809  var hasRequired_stream_duplex;
37810  function require_stream_duplex() {
37811    if (hasRequired_stream_duplex) return _stream_duplex;
37812    hasRequired_stream_duplex = 1;
37813    var pna = requireProcessNextickArgs();
37814    var objectKeys2 = Object.keys || function(obj) {
37815      var keys2 = [];
37816      for (var key2 in obj) {
37817        keys2.push(key2);
37818      }
37819      return keys2;
37820    };
37821    _stream_duplex = Duplex;
37822    var util2 = Object.create(requireUtil());
37823    util2.inherits = requireInherits();
37824    var Readable = require_stream_readable();
37825    var Writable = require_stream_writable();
37826    util2.inherits(Duplex, Readable);
37827    {
37828      var keys = objectKeys2(Writable.prototype);
37829      for (var v = 0; v < keys.length; v++) {
37830        var method = keys[v];
37831        if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
37832      }
37833    }
37834    function Duplex(options) {
37835      if (!(this instanceof Duplex)) return new Duplex(options);
37836      Readable.call(this, options);
37837      Writable.call(this, options);
37838      if (options && options.readable === false) this.readable = false;
37839      if (options && options.writable === false) this.writable = false;
37840      this.allowHalfOpen = true;
37841      if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
37842      this.once("end", onend);
37843    }
37844    Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
37845      // making it explicit this property is not enumerable
37846      // because otherwise some prototype manipulation in
37847      // userland will fail
37848      enumerable: false,
37849      get: function() {
37850        return this._writableState.highWaterMark;
37851      }
37852    });
37853    function onend() {
37854      if (this.allowHalfOpen || this._writableState.ended) return;
37855      pna.nextTick(onEndNT, this);
37856    }
37857    function onEndNT(self2) {
37858      self2.end();
37859    }
37860    Object.defineProperty(Duplex.prototype, "destroyed", {
37861      get: function() {
37862        if (this._readableState === void 0 || this._writableState === void 0) {
37863          return false;
37864        }
37865        return this._readableState.destroyed && this._writableState.destroyed;
37866      },
37867      set: function(value) {
37868        if (this._readableState === void 0 || this._writableState === void 0) {
37869          return;
37870        }
37871        this._readableState.destroyed = value;
37872        this._writableState.destroyed = value;
37873      }
37874    });
37875    Duplex.prototype._destroy = function(err, cb) {
37876      this.push(null);
37877      this.end();
37878      pna.nextTick(cb, err);
37879    };
37880    return _stream_duplex;
37881  }
37882  var _stream_readable;
37883  var hasRequired_stream_readable;
37884  function require_stream_readable() {
37885    if (hasRequired_stream_readable) return _stream_readable;
37886    hasRequired_stream_readable = 1;
37887    var pna = requireProcessNextickArgs();
37888    _stream_readable = Readable;
37889    var isArray2 = requireIsarray();
37890    var Duplex;
37891    Readable.ReadableState = ReadableState;
37892    requireEvents().EventEmitter;
37893    var EElistenerCount = function(emitter, type2) {
37894      return emitter.listeners(type2).length;
37895    };
37896    var Stream = requireStream();
37897    var Buffer2 = requireSafeBuffer().Buffer;
37898    var OurUint8Array = (typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}).Uint8Array || function() {
37899    };
37900    function _uint8ArrayToBuffer(chunk) {
37901      return Buffer2.from(chunk);
37902    }
37903    function _isUint8Array(obj) {
37904      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
37905    }
37906    var util2 = Object.create(requireUtil());
37907    util2.inherits = requireInherits();
37908    var debugUtil = requireUtil$1();
37909    var debug = void 0;
37910    if (debugUtil && debugUtil.debuglog) {
37911      debug = debugUtil.debuglog("stream");
37912    } else {
37913      debug = function() {
37914      };
37915    }
37916    var BufferList2 = requireBufferList();
37917    var destroyImpl = requireDestroy();
37918    var StringDecoder;
37919    util2.inherits(Readable, Stream);
37920    var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
37921    function prependListener(emitter, event, fn) {
37922      if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
37923      if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
37924      else if (isArray2(emitter._events[event])) emitter._events[event].unshift(fn);

vendor: 4,335 bytes, lines 37925-38036

37925      else emitter._events[event] = [fn, emitter._events[event]];
37926    }
37927    function ReadableState(options, stream2) {
37928      Duplex = Duplex || require_stream_duplex();
37929      options = options || {};
37930      var isDuplex = stream2 instanceof Duplex;
37931      this.objectMode = !!options.objectMode;
37932      if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
37933      var hwm = options.highWaterMark;
37934      var readableHwm = options.readableHighWaterMark;
37935      var defaultHwm = this.objectMode ? 16 : 16 * 1024;
37936      if (hwm || hwm === 0) this.highWaterMark = hwm;
37937      else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;
37938      else this.highWaterMark = defaultHwm;
37939      this.highWaterMark = Math.floor(this.highWaterMark);
37940      this.buffer = new BufferList2();
37941      this.length = 0;
37942      this.pipes = null;
37943      this.pipesCount = 0;
37944      this.flowing = null;
37945      this.ended = false;
37946      this.endEmitted = false;
37947      this.reading = false;
37948      this.sync = true;
37949      this.needReadable = false;
37950      this.emittedReadable = false;
37951      this.readableListening = false;
37952      this.resumeScheduled = false;
37953      this.destroyed = false;
37954      this.defaultEncoding = options.defaultEncoding || "utf8";
37955      this.awaitDrain = 0;
37956      this.readingMore = false;
37957      this.decoder = null;
37958      this.encoding = null;
37959      if (options.encoding) {
37960        if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
37961        this.decoder = new StringDecoder(options.encoding);
37962        this.encoding = options.encoding;
37963      }
37964    }
37965    function Readable(options) {
37966      Duplex = Duplex || require_stream_duplex();
37967      if (!(this instanceof Readable)) return new Readable(options);
37968      this._readableState = new ReadableState(options, this);
37969      this.readable = true;
37970      if (options) {
37971        if (typeof options.read === "function") this._read = options.read;
37972        if (typeof options.destroy === "function") this._destroy = options.destroy;
37973      }
37974      Stream.call(this);
37975    }
37976    Object.defineProperty(Readable.prototype, "destroyed", {
37977      get: function() {
37978        if (this._readableState === void 0) {
37979          return false;
37980        }
37981        return this._readableState.destroyed;
37982      },
37983      set: function(value) {
37984        if (!this._readableState) {
37985          return;
37986        }
37987        this._readableState.destroyed = value;
37988      }
37989    });
37990    Readable.prototype.destroy = destroyImpl.destroy;
37991    Readable.prototype._undestroy = destroyImpl.undestroy;
37992    Readable.prototype._destroy = function(err, cb) {
37993      this.push(null);
37994      cb(err);
37995    };
37996    Readable.prototype.push = function(chunk, encoding) {
37997      var state2 = this._readableState;
37998      var skipChunkCheck;
37999      if (!state2.objectMode) {
38000        if (typeof chunk === "string") {
38001          encoding = encoding || state2.defaultEncoding;
38002          if (encoding !== state2.encoding) {
38003            chunk = Buffer2.from(chunk, encoding);
38004            encoding = "";
38005          }
38006          skipChunkCheck = true;
38007        }
38008      } else {
38009        skipChunkCheck = true;
38010      }
38011      return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
38012    };
38013    Readable.prototype.unshift = function(chunk) {
38014      return readableAddChunk(this, chunk, null, true, false);
38015    };
38016    function readableAddChunk(stream2, chunk, encoding, addToFront, skipChunkCheck) {
38017      var state2 = stream2._readableState;
38018      if (chunk === null) {
38019        state2.reading = false;
38020        onEofChunk(stream2, state2);
38021      } else {
38022        var er;
38023        if (!skipChunkCheck) er = chunkInvalid(state2, chunk);
38024        if (er) {
38025          stream2.emit("error", er);
38026        } else if (state2.objectMode || chunk && chunk.length > 0) {
38027          if (typeof chunk !== "string" && !state2.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
38028            chunk = _uint8ArrayToBuffer(chunk);
38029          }
38030          if (addToFront) {
38031            if (state2.endEmitted) stream2.emit("error", new Error("stream.unshift() after end event"));
38032            else addChunk(stream2, state2, chunk, true);
38033          } else if (state2.ended) {
38034            stream2.emit("error", new Error("stream.push() after EOF"));
38035          } else {
38036            state2.reading = false;

vendor: 8,920 bytes, lines 38037-38298

38037            if (state2.decoder && !encoding) {
38038              chunk = state2.decoder.write(chunk);
38039              if (state2.objectMode || chunk.length !== 0) addChunk(stream2, state2, chunk, false);
38040              else maybeReadMore(stream2, state2);
38041            } else {
38042              addChunk(stream2, state2, chunk, false);
38043            }
38044          }
38045        } else if (!addToFront) {
38046          state2.reading = false;
38047        }
38048      }
38049      return needMoreData(state2);
38050    }
38051    function addChunk(stream2, state2, chunk, addToFront) {
38052      if (state2.flowing && state2.length === 0 && !state2.sync) {
38053        stream2.emit("data", chunk);
38054        stream2.read(0);
38055      } else {
38056        state2.length += state2.objectMode ? 1 : chunk.length;
38057        if (addToFront) state2.buffer.unshift(chunk);
38058        else state2.buffer.push(chunk);
38059        if (state2.needReadable) emitReadable(stream2);
38060      }
38061      maybeReadMore(stream2, state2);
38062    }
38063    function chunkInvalid(state2, chunk) {
38064      var er;
38065      if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state2.objectMode) {
38066        er = new TypeError("Invalid non-string/buffer chunk");
38067      }
38068      return er;
38069    }
38070    function needMoreData(state2) {
38071      return !state2.ended && (state2.needReadable || state2.length < state2.highWaterMark || state2.length === 0);
38072    }
38073    Readable.prototype.isPaused = function() {
38074      return this._readableState.flowing === false;
38075    };
38076    Readable.prototype.setEncoding = function(enc) {
38077      if (!StringDecoder) StringDecoder = requireString_decoder().StringDecoder;
38078      this._readableState.decoder = new StringDecoder(enc);
38079      this._readableState.encoding = enc;
38080      return this;
38081    };
38082    var MAX_HWM = 8388608;
38083    function computeNewHighWaterMark(n) {
38084      if (n >= MAX_HWM) {
38085        n = MAX_HWM;
38086      } else {
38087        n--;
38088        n |= n >>> 1;
38089        n |= n >>> 2;
38090        n |= n >>> 4;
38091        n |= n >>> 8;
38092        n |= n >>> 16;
38093        n++;
38094      }
38095      return n;
38096    }
38097    function howMuchToRead(n, state2) {
38098      if (n <= 0 || state2.length === 0 && state2.ended) return 0;
38099      if (state2.objectMode) return 1;
38100      if (n !== n) {
38101        if (state2.flowing && state2.length) return state2.buffer.head.data.length;
38102        else return state2.length;
38103      }
38104      if (n > state2.highWaterMark) state2.highWaterMark = computeNewHighWaterMark(n);
38105      if (n <= state2.length) return n;
38106      if (!state2.ended) {
38107        state2.needReadable = true;
38108        return 0;
38109      }
38110      return state2.length;
38111    }
38112    Readable.prototype.read = function(n) {
38113      debug("read", n);
38114      n = parseInt(n, 10);
38115      var state2 = this._readableState;
38116      var nOrig = n;
38117      if (n !== 0) state2.emittedReadable = false;
38118      if (n === 0 && state2.needReadable && (state2.length >= state2.highWaterMark || state2.ended)) {
38119        debug("read: emitReadable", state2.length, state2.ended);
38120        if (state2.length === 0 && state2.ended) endReadable(this);
38121        else emitReadable(this);
38122        return null;
38123      }
38124      n = howMuchToRead(n, state2);
38125      if (n === 0 && state2.ended) {
38126        if (state2.length === 0) endReadable(this);
38127        return null;
38128      }
38129      var doRead = state2.needReadable;
38130      debug("need readable", doRead);
38131      if (state2.length === 0 || state2.length - n < state2.highWaterMark) {
38132        doRead = true;
38133        debug("length less than watermark", doRead);
38134      }
38135      if (state2.ended || state2.reading) {
38136        doRead = false;
38137        debug("reading or ended", doRead);
38138      } else if (doRead) {
38139        debug("do read");
38140        state2.reading = true;
38141        state2.sync = true;
38142        if (state2.length === 0) state2.needReadable = true;
38143        this._read(state2.highWaterMark);
38144        state2.sync = false;
38145        if (!state2.reading) n = howMuchToRead(nOrig, state2);
38146      }
38147      var ret;
38148      if (n > 0) ret = fromList(n, state2);
38149      else ret = null;
38150      if (ret === null) {
38151        state2.needReadable = true;
38152        n = 0;
38153      } else {
38154        state2.length -= n;
38155      }
38156      if (state2.length === 0) {
38157        if (!state2.ended) state2.needReadable = true;
38158        if (nOrig !== n && state2.ended) endReadable(this);
38159      }
38160      if (ret !== null) this.emit("data", ret);
38161      return ret;
38162    };
38163    function onEofChunk(stream2, state2) {
38164      if (state2.ended) return;
38165      if (state2.decoder) {
38166        var chunk = state2.decoder.end();
38167        if (chunk && chunk.length) {
38168          state2.buffer.push(chunk);
38169          state2.length += state2.objectMode ? 1 : chunk.length;
38170        }
38171      }
38172      state2.ended = true;
38173      emitReadable(stream2);
38174    }
38175    function emitReadable(stream2) {
38176      var state2 = stream2._readableState;
38177      state2.needReadable = false;
38178      if (!state2.emittedReadable) {
38179        debug("emitReadable", state2.flowing);
38180        state2.emittedReadable = true;
38181        if (state2.sync) pna.nextTick(emitReadable_, stream2);
38182        else emitReadable_(stream2);
38183      }
38184    }
38185    function emitReadable_(stream2) {
38186      debug("emit readable");
38187      stream2.emit("readable");
38188      flow(stream2);
38189    }
38190    function maybeReadMore(stream2, state2) {
38191      if (!state2.readingMore) {
38192        state2.readingMore = true;
38193        pna.nextTick(maybeReadMore_, stream2, state2);
38194      }
38195    }
38196    function maybeReadMore_(stream2, state2) {
38197      var len2 = state2.length;
38198      while (!state2.reading && !state2.flowing && !state2.ended && state2.length < state2.highWaterMark) {
38199        debug("maybeReadMore read 0");
38200        stream2.read(0);
38201        if (len2 === state2.length)
38202          break;
38203        else len2 = state2.length;
38204      }
38205      state2.readingMore = false;
38206    }
38207    Readable.prototype._read = function(n) {
38208      this.emit("error", new Error("_read() is not implemented"));
38209    };
38210    Readable.prototype.pipe = function(dest, pipeOpts) {
38211      var src2 = this;
38212      var state2 = this._readableState;
38213      switch (state2.pipesCount) {
38214        case 0:
38215          state2.pipes = dest;
38216          break;
38217        case 1:
38218          state2.pipes = [state2.pipes, dest];
38219          break;
38220        default:
38221          state2.pipes.push(dest);
38222          break;
38223      }
38224      state2.pipesCount += 1;
38225      debug("pipe count=%d opts=%j", state2.pipesCount, pipeOpts);
38226      var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process$1.stdout && dest !== process$1.stderr;
38227      var endFn = doEnd ? onend : unpipe;
38228      if (state2.endEmitted) pna.nextTick(endFn);
38229      else src2.once("end", endFn);
38230      dest.on("unpipe", onunpipe);
38231      function onunpipe(readable2, unpipeInfo) {
38232        debug("onunpipe");
38233        if (readable2 === src2) {
38234          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
38235            unpipeInfo.hasUnpiped = true;
38236            cleanup();
38237          }
38238        }
38239      }
38240      function onend() {
38241        debug("onend");
38242        dest.end();
38243      }
38244      var ondrain = pipeOnDrain(src2);
38245      dest.on("drain", ondrain);
38246      var cleanedUp = false;
38247      function cleanup() {
38248        debug("cleanup");
38249        dest.removeListener("close", onclose);
38250        dest.removeListener("finish", onfinish);
38251        dest.removeListener("drain", ondrain);
38252        dest.removeListener("error", onerror);
38253        dest.removeListener("unpipe", onunpipe);
38254        src2.removeListener("end", onend);
38255        src2.removeListener("end", unpipe);
38256        src2.removeListener("data", ondata);
38257        cleanedUp = true;
38258        if (state2.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
38259      }
38260      var increasedAwaitDrain = false;
38261      src2.on("data", ondata);
38262      function ondata(chunk) {
38263        debug("ondata");
38264        increasedAwaitDrain = false;
38265        var ret = dest.write(chunk);
38266        if (false === ret && !increasedAwaitDrain) {
38267          if ((state2.pipesCount === 1 && state2.pipes === dest || state2.pipesCount > 1 && indexOf2(state2.pipes, dest) !== -1) && !cleanedUp) {
38268            debug("false write response, pause", state2.awaitDrain);
38269            state2.awaitDrain++;
38270            increasedAwaitDrain = true;
38271          }
38272          src2.pause();
38273        }
38274      }
38275      function onerror(er) {
38276        debug("onerror", er);
38277        unpipe();
38278        dest.removeListener("error", onerror);
38279        if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
38280      }
38281      prependListener(dest, "error", onerror);
38282      function onclose() {
38283        dest.removeListener("finish", onfinish);
38284        unpipe();
38285      }
38286      dest.once("close", onclose);
38287      function onfinish() {
38288        debug("onfinish");
38289        dest.removeListener("close", onclose);
38290        unpipe();
38291      }
38292      dest.once("finish", onfinish);
38293      function unpipe() {
38294        debug("unpipe");
38295        src2.unpipe(dest);
38296      }
38297      dest.emit("pipe", src2);
38298      if (!state2.flowing) {

vendor: 4,967 bytes, lines 38299-38449

38299        debug("pipe resume");
38300        src2.resume();
38301      }
38302      return dest;
38303    };
38304    function pipeOnDrain(src2) {
38305      return function() {
38306        var state2 = src2._readableState;
38307        debug("pipeOnDrain", state2.awaitDrain);
38308        if (state2.awaitDrain) state2.awaitDrain--;
38309        if (state2.awaitDrain === 0 && EElistenerCount(src2, "data")) {
38310          state2.flowing = true;
38311          flow(src2);
38312        }
38313      };
38314    }
38315    Readable.prototype.unpipe = function(dest) {
38316      var state2 = this._readableState;
38317      var unpipeInfo = { hasUnpiped: false };
38318      if (state2.pipesCount === 0) return this;
38319      if (state2.pipesCount === 1) {
38320        if (dest && dest !== state2.pipes) return this;
38321        if (!dest) dest = state2.pipes;
38322        state2.pipes = null;
38323        state2.pipesCount = 0;
38324        state2.flowing = false;
38325        if (dest) dest.emit("unpipe", this, unpipeInfo);
38326        return this;
38327      }
38328      if (!dest) {
38329        var dests = state2.pipes;
38330        var len2 = state2.pipesCount;
38331        state2.pipes = null;
38332        state2.pipesCount = 0;
38333        state2.flowing = false;
38334        for (var i2 = 0; i2 < len2; i2++) {
38335          dests[i2].emit("unpipe", this, { hasUnpiped: false });
38336        }
38337        return this;
38338      }
38339      var index = indexOf2(state2.pipes, dest);
38340      if (index === -1) return this;
38341      state2.pipes.splice(index, 1);
38342      state2.pipesCount -= 1;
38343      if (state2.pipesCount === 1) state2.pipes = state2.pipes[0];
38344      dest.emit("unpipe", this, unpipeInfo);
38345      return this;
38346    };
38347    Readable.prototype.on = function(ev, fn) {
38348      var res = Stream.prototype.on.call(this, ev, fn);
38349      if (ev === "data") {
38350        if (this._readableState.flowing !== false) this.resume();
38351      } else if (ev === "readable") {
38352        var state2 = this._readableState;
38353        if (!state2.endEmitted && !state2.readableListening) {
38354          state2.readableListening = state2.needReadable = true;
38355          state2.emittedReadable = false;
38356          if (!state2.reading) {
38357            pna.nextTick(nReadingNextTick, this);
38358          } else if (state2.length) {
38359            emitReadable(this);
38360          }
38361        }
38362      }
38363      return res;
38364    };
38365    Readable.prototype.addListener = Readable.prototype.on;
38366    function nReadingNextTick(self2) {
38367      debug("readable nexttick read 0");
38368      self2.read(0);
38369    }
38370    Readable.prototype.resume = function() {
38371      var state2 = this._readableState;
38372      if (!state2.flowing) {
38373        debug("resume");
38374        state2.flowing = true;
38375        resume(this, state2);
38376      }
38377      return this;
38378    };
38379    function resume(stream2, state2) {
38380      if (!state2.resumeScheduled) {
38381        state2.resumeScheduled = true;
38382        pna.nextTick(resume_, stream2, state2);
38383      }
38384    }
38385    function resume_(stream2, state2) {
38386      if (!state2.reading) {
38387        debug("resume read 0");
38388        stream2.read(0);
38389      }
38390      state2.resumeScheduled = false;
38391      state2.awaitDrain = 0;
38392      stream2.emit("resume");
38393      flow(stream2);
38394      if (state2.flowing && !state2.reading) stream2.read(0);
38395    }
38396    Readable.prototype.pause = function() {
38397      debug("call pause flowing=%j", this._readableState.flowing);
38398      if (false !== this._readableState.flowing) {
38399        debug("pause");
38400        this._readableState.flowing = false;
38401        this.emit("pause");
38402      }
38403      return this;
38404    };
38405    function flow(stream2) {
38406      var state2 = stream2._readableState;
38407      debug("flow", state2.flowing);
38408      while (state2.flowing && stream2.read() !== null) {
38409      }
38410    }
38411    Readable.prototype.wrap = function(stream2) {
38412      var _this = this;
38413      var state2 = this._readableState;
38414      var paused = false;
38415      stream2.on("end", function() {
38416        debug("wrapped end");
38417        if (state2.decoder && !state2.ended) {
38418          var chunk = state2.decoder.end();
38419          if (chunk && chunk.length) _this.push(chunk);
38420        }
38421        _this.push(null);
38422      });
38423      stream2.on("data", function(chunk) {
38424        debug("wrapped data");
38425        if (state2.decoder) chunk = state2.decoder.write(chunk);
38426        if (state2.objectMode && (chunk === null || chunk === void 0)) return;
38427        else if (!state2.objectMode && (!chunk || !chunk.length)) return;
38428        var ret = _this.push(chunk);
38429        if (!ret) {
38430          paused = true;
38431          stream2.pause();
38432        }
38433      });
38434      for (var i2 in stream2) {
38435        if (this[i2] === void 0 && typeof stream2[i2] === "function") {
38436          this[i2] = /* @__PURE__ */ (function(method) {
38437            return function() {
38438              return stream2[method].apply(stream2, arguments);
38439            };
38440          })(i2);
38441        }
38442      }
38443      for (var n = 0; n < kProxyEvents.length; n++) {
38444        stream2.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
38445      }
38446      this._read = function(n2) {
38447        debug("wrapped _read", n2);
38448        if (paused) {
38449          paused = false;

vendor: 4,285 bytes, lines 38450-38591

38450          stream2.resume();
38451        }
38452      };
38453      return this;
38454    };
38455    Object.defineProperty(Readable.prototype, "readableHighWaterMark", {
38456      // making it explicit this property is not enumerable
38457      // because otherwise some prototype manipulation in
38458      // userland will fail
38459      enumerable: false,
38460      get: function() {
38461        return this._readableState.highWaterMark;
38462      }
38463    });
38464    Readable._fromList = fromList;
38465    function fromList(n, state2) {
38466      if (state2.length === 0) return null;
38467      var ret;
38468      if (state2.objectMode) ret = state2.buffer.shift();
38469      else if (!n || n >= state2.length) {
38470        if (state2.decoder) ret = state2.buffer.join("");
38471        else if (state2.buffer.length === 1) ret = state2.buffer.head.data;
38472        else ret = state2.buffer.concat(state2.length);
38473        state2.buffer.clear();
38474      } else {
38475        ret = fromListPartial(n, state2.buffer, state2.decoder);
38476      }
38477      return ret;
38478    }
38479    function fromListPartial(n, list, hasStrings) {
38480      var ret;
38481      if (n < list.head.data.length) {
38482        ret = list.head.data.slice(0, n);
38483        list.head.data = list.head.data.slice(n);
38484      } else if (n === list.head.data.length) {
38485        ret = list.shift();
38486      } else {
38487        ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
38488      }
38489      return ret;
38490    }
38491    function copyFromBufferString(n, list) {
38492      var p = list.head;
38493      var c = 1;
38494      var ret = p.data;
38495      n -= ret.length;
38496      while (p = p.next) {
38497        var str = p.data;
38498        var nb = n > str.length ? str.length : n;
38499        if (nb === str.length) ret += str;
38500        else ret += str.slice(0, n);
38501        n -= nb;
38502        if (n === 0) {
38503          if (nb === str.length) {
38504            ++c;
38505            if (p.next) list.head = p.next;
38506            else list.head = list.tail = null;
38507          } else {
38508            list.head = p;
38509            p.data = str.slice(nb);
38510          }
38511          break;
38512        }
38513        ++c;
38514      }
38515      list.length -= c;
38516      return ret;
38517    }
38518    function copyFromBuffer(n, list) {
38519      var ret = Buffer2.allocUnsafe(n);
38520      var p = list.head;
38521      var c = 1;
38522      p.data.copy(ret);
38523      n -= p.data.length;
38524      while (p = p.next) {
38525        var buf = p.data;
38526        var nb = n > buf.length ? buf.length : n;
38527        buf.copy(ret, ret.length - n, 0, nb);
38528        n -= nb;
38529        if (n === 0) {
38530          if (nb === buf.length) {
38531            ++c;
38532            if (p.next) list.head = p.next;
38533            else list.head = list.tail = null;
38534          } else {
38535            list.head = p;
38536            p.data = buf.slice(nb);
38537          }
38538          break;
38539        }
38540        ++c;
38541      }
38542      list.length -= c;
38543      return ret;
38544    }
38545    function endReadable(stream2) {
38546      var state2 = stream2._readableState;
38547      if (state2.length > 0) throw new Error('"endReadable()" called on non-empty stream');
38548      if (!state2.endEmitted) {
38549        state2.ended = true;
38550        pna.nextTick(endReadableNT, state2, stream2);
38551      }
38552    }
38553    function endReadableNT(state2, stream2) {
38554      if (!state2.endEmitted && state2.length === 0) {
38555        state2.endEmitted = true;
38556        stream2.readable = false;
38557        stream2.emit("end");
38558      }
38559    }
38560    function indexOf2(xs, x) {
38561      for (var i2 = 0, l = xs.length; i2 < l; i2++) {
38562        if (xs[i2] === x) return i2;
38563      }
38564      return -1;
38565    }
38566    return _stream_readable;
38567  }
38568  var _stream_transform;
38569  var hasRequired_stream_transform;
38570  function require_stream_transform() {
38571    if (hasRequired_stream_transform) return _stream_transform;
38572    hasRequired_stream_transform = 1;
38573    _stream_transform = Transform;
38574    var Duplex = require_stream_duplex();
38575    var util2 = Object.create(requireUtil());
38576    util2.inherits = requireInherits();
38577    util2.inherits(Transform, Duplex);
38578    function afterTransform(er, data) {
38579      var ts = this._transformState;
38580      ts.transforming = false;
38581      var cb = ts.writecb;
38582      if (!cb) {
38583        return this.emit("error", new Error("write callback called multiple times"));
38584      }
38585      ts.writechunk = null;
38586      ts.writecb = null;
38587      if (data != null)
38588        this.push(data);
38589      cb(er);
38590      var rs = this._readableState;
38591      rs.reading = false;

38592      if (rs.needReadable || rs.length < rs.highWaterMark) {
38593        this._read(rs.highWaterMark);
38594      }
38595    }
38596    function Transform(options) {
38597      if (!(this instanceof Transform)) return new Transform(options);
38598      Duplex.call(this, options);
38599      this._transformState = {
38600        afterTransform: afterTransform.bind(this),
38601        needTransform: false,
38602        transforming: false,
38603        writecb: null,
38604        writechunk: null,
38605        writeencoding: null
38606      };
38607      this._readableState.needReadable = true;
38608      this._readableState.sync = false;
38609      if (options) {
38610        if (typeof options.transform === "function") this._transform = options.transform;
38611        if (typeof options.flush === "function") this._flush = options.flush;
38612      }
38613      this.on("prefinish", prefinish);
38614    }
38615    function prefinish() {
38616      var _this = this;
38617      if (typeof this._flush === "function") {
38618        this._flush(function(er, data) {
38619          done(_this, er, data);
38620        });
38621      } else {
38622        done(this, null, null);
38623      }
38624    }
38625    Transform.prototype.push = function(chunk, encoding) {
38626      this._transformState.needTransform = false;
38627      return Duplex.prototype.push.call(this, chunk, encoding);
38628    };
38629    Transform.prototype._transform = function(chunk, encoding, cb) {
38630      throw new Error("_transform() is not implemented");
38631    };
38632    Transform.prototype._write = function(chunk, encoding, cb) {
38633      var ts = this._transformState;
38634      ts.writecb = cb;
38635      ts.writechunk = chunk;
38636      ts.writeencoding = encoding;
38637      if (!ts.transforming) {
38638        var rs = this._readableState;
38639        if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
38640      }
38641    };
38642    Transform.prototype._read = function(n) {
38643      var ts = this._transformState;
38644      if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
38645        ts.transforming = true;
38646        this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
38647      } else {
38648        ts.needTransform = true;
38649      }
38650    };
38651    Transform.prototype._destroy = function(err, cb) {
38652      var _this2 = this;
38653      Duplex.prototype._destroy.call(this, err, function(err2) {
38654        cb(err2);
38655        _this2.emit("close");
38656      });
38657    };
38658    function done(stream2, er, data) {
38659      if (er) return stream2.emit("error", er);
38660      if (data != null)
38661        stream2.push(data);
38662      if (stream2._writableState.length) throw new Error("Calling transform done when ws.length != 0");
38663      if (stream2._transformState.transforming) throw new Error("Calling transform done when still transforming");
38664      return stream2.push(null);
38665    }
38666    return _stream_transform;
38667  }
38668  var _stream_passthrough;
38669  var hasRequired_stream_passthrough;
38670  function require_stream_passthrough() {
38671    if (hasRequired_stream_passthrough) return _stream_passthrough;
38672    hasRequired_stream_passthrough = 1;
38673    _stream_passthrough = PassThrough;
38674    var Transform = require_stream_transform();
38675    var util2 = Object.create(requireUtil());
38676    util2.inherits = requireInherits();
38677    util2.inherits(PassThrough, Transform);
38678    function PassThrough(options) {
38679      if (!(this instanceof PassThrough)) return new PassThrough(options);
38680      Transform.call(this, options);
38681    }
38682    PassThrough.prototype._transform = function(chunk, encoding, cb) {
38683      cb(null, chunk);
38684    };
38685    return _stream_passthrough;
38686  }
38687  var hasRequiredReadable;
38688  function requireReadable() {
38689    if (hasRequiredReadable) return readable.exports;
38690    hasRequiredReadable = 1;
38691    (function(module, exports$12) {
38692      var define_process_env_default2 = {};
38693      var Stream = requireStreamBrowserify();
38694      if (define_process_env_default2.READABLE_STREAM === "disable" && Stream) {
38695        module.exports = Stream;
38696        exports$12 = module.exports = Stream.Readable;
38697        exports$12.Readable = Stream.Readable;
38698        exports$12.Writable = Stream.Writable;
38699        exports$12.Duplex = Stream.Duplex;
38700        exports$12.Transform = Stream.Transform;
38701        exports$12.PassThrough = Stream.PassThrough;
38702        exports$12.Stream = Stream;
38703      } else {
38704        exports$12 = module.exports = require_stream_readable();
38705        exports$12.Stream = Stream || exports$12;
38706        exports$12.Readable = exports$12;
38707        exports$12.Writable = require_stream_writable();
38708        exports$12.Duplex = require_stream_duplex();
38709        exports$12.Transform = require_stream_transform();
38710        exports$12.PassThrough = require_stream_passthrough();
38711      }
38712    })(readable, readable.exports);
38713    return readable.exports;
38714  }
38715  var hashBase;
38716  var hasRequiredHashBase;
38717  function requireHashBase() {
38718    if (hasRequiredHashBase) return hashBase;
38719    hasRequiredHashBase = 1;
38720    var Buffer2 = requireSafeBuffer$1().Buffer;
38721    var toBuffer2 = requireToBuffer();
38722    var Transform = requireReadable().Transform;
38723    var inherits2 = requireInherits();
38724    function HashBase(blockSize) {
38725      Transform.call(this);
38726      this._block = Buffer2.allocUnsafe(blockSize);
38727      this._blockSize = blockSize;
38728      this._blockOffset = 0;
38729      this._length = [0, 0, 0, 0];
38730      this._finalized = false;

vendor: 4,124 bytes, lines 38731-38854

38731    }
38732    inherits2(HashBase, Transform);
38733    HashBase.prototype._transform = function(chunk, encoding, callback) {
38734      var error = null;
38735      try {
38736        this.update(chunk, encoding);
38737      } catch (err) {
38738        error = err;
38739      }
38740      callback(error);
38741    };
38742    HashBase.prototype._flush = function(callback) {
38743      var error = null;
38744      try {
38745        this.push(this.digest());
38746      } catch (err) {
38747        error = err;
38748      }
38749      callback(error);
38750    };
38751    HashBase.prototype.update = function(data, encoding) {
38752      if (this._finalized) {
38753        throw new Error("Digest already called");
38754      }
38755      var dataBuffer = toBuffer2(data, encoding);
38756      var block = this._block;
38757      var offset = 0;
38758      while (this._blockOffset + dataBuffer.length - offset >= this._blockSize) {
38759        for (var i2 = this._blockOffset; i2 < this._blockSize; ) {
38760          block[i2] = dataBuffer[offset];
38761          i2 += 1;
38762          offset += 1;
38763        }
38764        this._update();
38765        this._blockOffset = 0;
38766      }
38767      while (offset < dataBuffer.length) {
38768        block[this._blockOffset] = dataBuffer[offset];
38769        this._blockOffset += 1;
38770        offset += 1;
38771      }
38772      for (var j = 0, carry = dataBuffer.length * 8; carry > 0; ++j) {
38773        this._length[j] += carry;
38774        carry = this._length[j] / 4294967296 | 0;
38775        if (carry > 0) {
38776          this._length[j] -= 4294967296 * carry;
38777        }
38778      }
38779      return this;
38780    };
38781    HashBase.prototype._update = function() {
38782      throw new Error("_update is not implemented");
38783    };
38784    HashBase.prototype.digest = function(encoding) {
38785      if (this._finalized) {
38786        throw new Error("Digest already called");
38787      }
38788      this._finalized = true;
38789      var digest = this._digest();
38790      if (encoding !== void 0) {
38791        digest = digest.toString(encoding);
38792      }
38793      this._block.fill(0);
38794      this._blockOffset = 0;
38795      for (var i2 = 0; i2 < 4; ++i2) {
38796        this._length[i2] = 0;
38797      }
38798      return digest;
38799    };
38800    HashBase.prototype._digest = function() {
38801      throw new Error("_digest is not implemented");
38802    };
38803    hashBase = HashBase;
38804    return hashBase;
38805  }
38806  var md5_js;
38807  var hasRequiredMd5_js;
38808  function requireMd5_js() {
38809    if (hasRequiredMd5_js) return md5_js;
38810    hasRequiredMd5_js = 1;
38811    var inherits2 = requireInherits();
38812    var HashBase = requireHashBase();
38813    var Buffer2 = requireSafeBuffer$1().Buffer;
38814    var ARRAY16 = new Array(16);
38815    function MD5() {
38816      HashBase.call(this, 64);
38817      this._a = 1732584193;
38818      this._b = 4023233417;
38819      this._c = 2562383102;
38820      this._d = 271733878;
38821    }
38822    inherits2(MD5, HashBase);
38823    MD5.prototype._update = function() {
38824      var M = ARRAY16;
38825      for (var i2 = 0; i2 < 16; ++i2) M[i2] = this._block.readInt32LE(i2 * 4);
38826      var a = this._a;
38827      var b = this._b;
38828      var c = this._c;
38829      var d = this._d;
38830      a = fnF(a, b, c, d, M[0], 3614090360, 7);
38831      d = fnF(d, a, b, c, M[1], 3905402710, 12);
38832      c = fnF(c, d, a, b, M[2], 606105819, 17);
38833      b = fnF(b, c, d, a, M[3], 3250441966, 22);
38834      a = fnF(a, b, c, d, M[4], 4118548399, 7);
38835      d = fnF(d, a, b, c, M[5], 1200080426, 12);
38836      c = fnF(c, d, a, b, M[6], 2821735955, 17);
38837      b = fnF(b, c, d, a, M[7], 4249261313, 22);
38838      a = fnF(a, b, c, d, M[8], 1770035416, 7);
38839      d = fnF(d, a, b, c, M[9], 2336552879, 12);
38840      c = fnF(c, d, a, b, M[10], 4294925233, 17);
38841      b = fnF(b, c, d, a, M[11], 2304563134, 22);
38842      a = fnF(a, b, c, d, M[12], 1804603682, 7);
38843      d = fnF(d, a, b, c, M[13], 4254626195, 12);
38844      c = fnF(c, d, a, b, M[14], 2792965006, 17);
38845      b = fnF(b, c, d, a, M[15], 1236535329, 22);
38846      a = fnG(a, b, c, d, M[1], 4129170786, 5);
38847      d = fnG(d, a, b, c, M[6], 3225465664, 9);
38848      c = fnG(c, d, a, b, M[11], 643717713, 14);
38849      b = fnG(b, c, d, a, M[0], 3921069994, 20);
38850      a = fnG(a, b, c, d, M[5], 3593408605, 5);
38851      d = fnG(d, a, b, c, M[10], 38016083, 9);
38852      c = fnG(c, d, a, b, M[15], 3634488961, 14);
38853      b = fnG(b, c, d, a, M[4], 3889429448, 20);
38854      a = fnG(a, b, c, d, M[9], 568446438, 5);

vendor: 6,814 bytes, lines 38855-39019

38855      d = fnG(d, a, b, c, M[14], 3275163606, 9);
38856      c = fnG(c, d, a, b, M[3], 4107603335, 14);
38857      b = fnG(b, c, d, a, M[8], 1163531501, 20);
38858      a = fnG(a, b, c, d, M[13], 2850285829, 5);
38859      d = fnG(d, a, b, c, M[2], 4243563512, 9);
38860      c = fnG(c, d, a, b, M[7], 1735328473, 14);
38861      b = fnG(b, c, d, a, M[12], 2368359562, 20);
38862      a = fnH(a, b, c, d, M[5], 4294588738, 4);
38863      d = fnH(d, a, b, c, M[8], 2272392833, 11);
38864      c = fnH(c, d, a, b, M[11], 1839030562, 16);
38865      b = fnH(b, c, d, a, M[14], 4259657740, 23);
38866      a = fnH(a, b, c, d, M[1], 2763975236, 4);
38867      d = fnH(d, a, b, c, M[4], 1272893353, 11);
38868      c = fnH(c, d, a, b, M[7], 4139469664, 16);
38869      b = fnH(b, c, d, a, M[10], 3200236656, 23);
38870      a = fnH(a, b, c, d, M[13], 681279174, 4);
38871      d = fnH(d, a, b, c, M[0], 3936430074, 11);
38872      c = fnH(c, d, a, b, M[3], 3572445317, 16);
38873      b = fnH(b, c, d, a, M[6], 76029189, 23);
38874      a = fnH(a, b, c, d, M[9], 3654602809, 4);
38875      d = fnH(d, a, b, c, M[12], 3873151461, 11);
38876      c = fnH(c, d, a, b, M[15], 530742520, 16);
38877      b = fnH(b, c, d, a, M[2], 3299628645, 23);
38878      a = fnI(a, b, c, d, M[0], 4096336452, 6);
38879      d = fnI(d, a, b, c, M[7], 1126891415, 10);
38880      c = fnI(c, d, a, b, M[14], 2878612391, 15);
38881      b = fnI(b, c, d, a, M[5], 4237533241, 21);
38882      a = fnI(a, b, c, d, M[12], 1700485571, 6);
38883      d = fnI(d, a, b, c, M[3], 2399980690, 10);
38884      c = fnI(c, d, a, b, M[10], 4293915773, 15);
38885      b = fnI(b, c, d, a, M[1], 2240044497, 21);
38886      a = fnI(a, b, c, d, M[8], 1873313359, 6);
38887      d = fnI(d, a, b, c, M[15], 4264355552, 10);
38888      c = fnI(c, d, a, b, M[6], 2734768916, 15);
38889      b = fnI(b, c, d, a, M[13], 1309151649, 21);
38890      a = fnI(a, b, c, d, M[4], 4149444226, 6);
38891      d = fnI(d, a, b, c, M[11], 3174756917, 10);
38892      c = fnI(c, d, a, b, M[2], 718787259, 15);
38893      b = fnI(b, c, d, a, M[9], 3951481745, 21);
38894      this._a = this._a + a | 0;
38895      this._b = this._b + b | 0;
38896      this._c = this._c + c | 0;
38897      this._d = this._d + d | 0;
38898    };
38899    MD5.prototype._digest = function() {
38900      this._block[this._blockOffset++] = 128;
38901      if (this._blockOffset > 56) {
38902        this._block.fill(0, this._blockOffset, 64);
38903        this._update();
38904        this._blockOffset = 0;
38905      }
38906      this._block.fill(0, this._blockOffset, 56);
38907      this._block.writeUInt32LE(this._length[0], 56);
38908      this._block.writeUInt32LE(this._length[1], 60);
38909      this._update();
38910      var buffer2 = Buffer2.allocUnsafe(16);
38911      buffer2.writeInt32LE(this._a, 0);
38912      buffer2.writeInt32LE(this._b, 4);
38913      buffer2.writeInt32LE(this._c, 8);
38914      buffer2.writeInt32LE(this._d, 12);
38915      return buffer2;
38916    };
38917    function rotl(x, n) {
38918      return x << n | x >>> 32 - n;
38919    }
38920    function fnF(a, b, c, d, m, k, s) {
38921      return rotl(a + (b & c | ~b & d) + m + k | 0, s) + b | 0;
38922    }
38923    function fnG(a, b, c, d, m, k, s) {
38924      return rotl(a + (b & d | c & ~d) + m + k | 0, s) + b | 0;
38925    }
38926    function fnH(a, b, c, d, m, k, s) {
38927      return rotl(a + (b ^ c ^ d) + m + k | 0, s) + b | 0;
38928    }
38929    function fnI(a, b, c, d, m, k, s) {
38930      return rotl(a + (c ^ (b | ~d)) + m + k | 0, s) + b | 0;
38931    }
38932    md5_js = MD5;
38933    return md5_js;
38934  }
38935  var evp_bytestokey;
38936  var hasRequiredEvp_bytestokey;
38937  function requireEvp_bytestokey() {
38938    if (hasRequiredEvp_bytestokey) return evp_bytestokey;
38939    hasRequiredEvp_bytestokey = 1;
38940    var Buffer2 = requireSafeBuffer$1().Buffer;
38941    var MD5 = requireMd5_js();
38942    function EVP_BytesToKey(password, salt, keyBits, ivLen) {
38943      if (!Buffer2.isBuffer(password)) password = Buffer2.from(password, "binary");
38944      if (salt) {
38945        if (!Buffer2.isBuffer(salt)) salt = Buffer2.from(salt, "binary");
38946        if (salt.length !== 8) throw new RangeError("salt should be Buffer with 8 byte length");
38947      }
38948      var keyLen = keyBits / 8;
38949      var key2 = Buffer2.alloc(keyLen);
38950      var iv = Buffer2.alloc(ivLen || 0);
38951      var tmp = Buffer2.alloc(0);
38952      while (keyLen > 0 || ivLen > 0) {
38953        var hash2 = new MD5();
38954        hash2.update(tmp);
38955        hash2.update(password);
38956        if (salt) hash2.update(salt);
38957        tmp = hash2.digest();
38958        var used = 0;
38959        if (keyLen > 0) {
38960          var keyStart = key2.length - keyLen;
38961          used = Math.min(keyLen, tmp.length);
38962          tmp.copy(key2, keyStart, 0, used);
38963          keyLen -= used;
38964        }
38965        if (used < tmp.length && ivLen > 0) {
38966          var ivStart = iv.length - ivLen;
38967          var length = Math.min(ivLen, tmp.length - used);
38968          tmp.copy(iv, ivStart, used, used + length);
38969          ivLen -= length;
38970        }
38971      }
38972      tmp.fill(0);
38973      return { key: key2, iv };
38974    }
38975    evp_bytestokey = EVP_BytesToKey;
38976    return evp_bytestokey;
38977  }
38978  var browserifyAes = {};
38979  var hasRequiredBrowserifyAes;
38980  function requireBrowserifyAes() {
38981    if (hasRequiredBrowserifyAes) return browserifyAes;
38982    hasRequiredBrowserifyAes = 1;
38983    var crypto2 = requireCryptoBrowserify();
38984    browserifyAes.createCipher = browserifyAes.Cipher = crypto2.createCipher;
38985    browserifyAes.createCipheriv = browserifyAes.Cipheriv = crypto2.createCipheriv;
38986    browserifyAes.createDecipher = browserifyAes.Decipher = crypto2.createDecipher;
38987    browserifyAes.createDecipheriv = browserifyAes.Decipheriv = crypto2.createDecipheriv;
38988    browserifyAes.listCiphers = browserifyAes.getCiphers = crypto2.getCiphers;
38989    return browserifyAes;
38990  }
38991  var fixProc;
38992  var hasRequiredFixProc;
38993  function requireFixProc() {
38994    if (hasRequiredFixProc) return fixProc;
38995    hasRequiredFixProc = 1;
38996    var findProc = /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m;
38997    var startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m;
38998    var fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m;
38999    var evp = requireEvp_bytestokey();
39000    var ciphers = requireBrowserifyAes();
39001    var Buffer2 = requireSafeBuffer$1().Buffer;
39002    fixProc = function(okey, password) {
39003      var key2 = okey.toString();
39004      var match = key2.match(findProc);
39005      var decrypted;
39006      if (!match) {
39007        var match2 = key2.match(fullRegex);
39008        decrypted = Buffer2.from(match2[2].replace(/[\r\n]/g, ""), "base64");
39009      } else {
39010        var suite = "aes" + match[1];
39011        var iv = Buffer2.from(match[2], "hex");
39012        var cipherText = Buffer2.from(match[3].replace(/[\r\n]/g, ""), "base64");
39013        var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key;
39014        var out = [];
39015        var cipher = ciphers.createDecipheriv(suite, cipherKey, iv);
39016        out.push(cipher.update(cipherText));
39017        out.push(cipher["final"]());
39018        decrypted = Buffer2.concat(out);
39019      }

39020      var tag = key2.match(startRegex)[1];
39021      return {
39022        tag,
39023        data: decrypted
39024      };
39025    };
39026    return fixProc;
39027  }
39028  var parseAsn1;
39029  var hasRequiredParseAsn1;
39030  function requireParseAsn1() {
39031    if (hasRequiredParseAsn1) return parseAsn1;
39032    hasRequiredParseAsn1 = 1;
39033    var asn12 = requireAsn1();
39034    var aesid = require$$1;
39035    var fixProc2 = requireFixProc();
39036    var ciphers = requireBrowserifyAes();
39037    var pbkdf2Sync = requirePbkdf2().pbkdf2Sync;
39038    var Buffer2 = requireSafeBuffer$1().Buffer;
39039    function decrypt(data, password) {
39040      var salt = data.algorithm.decrypt.kde.kdeparams.salt;
39041      var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10);
39042      var algo = aesid[data.algorithm.decrypt.cipher.algo.join(".")];
39043      var iv = data.algorithm.decrypt.cipher.iv;
39044      var cipherText = data.subjectPrivateKey;
39045      var keylen = parseInt(algo.split("-")[1], 10) / 8;
39046      var key2 = pbkdf2Sync(password, salt, iters, keylen, "sha1");
39047      var cipher = ciphers.createDecipheriv(algo, key2, iv);
39048      var out = [];
39049      out.push(cipher.update(cipherText));
39050      out.push(cipher["final"]());
39051      return Buffer2.concat(out);
39052    }
39053    function parseKeys(buffer2) {
39054      var password;
39055      if (typeof buffer2 === "object" && !Buffer2.isBuffer(buffer2)) {
39056        password = buffer2.passphrase;
39057        buffer2 = buffer2.key;
39058      }
39059      if (typeof buffer2 === "string") {
39060        buffer2 = Buffer2.from(buffer2);
39061      }
39062      var stripped = fixProc2(buffer2, password);
39063      var type2 = stripped.tag;
39064      var data = stripped.data;
39065      var subtype, ndata;
39066      switch (type2) {
39067        case "CERTIFICATE":
39068          ndata = asn12.certificate.decode(data, "der").tbsCertificate.subjectPublicKeyInfo;
39069        // falls through
39070        case "PUBLIC KEY":
39071          if (!ndata) {
39072            ndata = asn12.PublicKey.decode(data, "der");
39073          }
39074          subtype = ndata.algorithm.algorithm.join(".");
39075          switch (subtype) {
39076            case "1.2.840.113549.1.1.1":
39077              return asn12.RSAPublicKey.decode(ndata.subjectPublicKey.data, "der");
39078            case "1.2.840.10045.2.1":
39079              ndata.subjectPrivateKey = ndata.subjectPublicKey;
39080              return {
39081                type: "ec",
39082                data: ndata
39083              };
39084            case "1.2.840.10040.4.1":
39085              ndata.algorithm.params.pub_key = asn12.DSAparam.decode(ndata.subjectPublicKey.data, "der");
39086              return {
39087                type: "dsa",
39088                data: ndata.algorithm.params
39089              };
39090            default:
39091              throw new Error("unknown key id " + subtype);
39092          }
39093        // throw new Error('unknown key type ' + type)
39094        case "ENCRYPTED PRIVATE KEY":
39095          data = asn12.EncryptedPrivateKey.decode(data, "der");
39096          data = decrypt(data, password);
39097        // falls through
39098        case "PRIVATE KEY":
39099          ndata = asn12.PrivateKey.decode(data, "der");
39100          subtype = ndata.algorithm.algorithm.join(".");
39101          switch (subtype) {
39102            case "1.2.840.113549.1.1.1":
39103              return asn12.RSAPrivateKey.decode(ndata.subjectPrivateKey, "der");
39104            case "1.2.840.10045.2.1":
39105              return {
39106                curve: ndata.algorithm.curve,
39107                privateKey: asn12.ECPrivateKey.decode(ndata.subjectPrivateKey, "der").privateKey
39108              };
39109            case "1.2.840.10040.4.1":
39110              ndata.algorithm.params.priv_key = asn12.DSAparam.decode(ndata.subjectPrivateKey, "der");
39111              return {
39112                type: "dsa",
39113                params: ndata.algorithm.params
39114              };
39115            default:
39116              throw new Error("unknown key id " + subtype);
39117          }
39118        // throw new Error('unknown key type ' + type)
39119        case "RSA PUBLIC KEY":
39120          return asn12.RSAPublicKey.decode(data, "der");
39121        case "RSA PRIVATE KEY":
39122          return asn12.RSAPrivateKey.decode(data, "der");
39123        case "DSA PRIVATE KEY":
39124          return {
39125            type: "dsa",
39126            params: asn12.DSAPrivateKey.decode(data, "der")
39127          };
39128        case "EC PRIVATE KEY":
39129          data = asn12.ECPrivateKey.decode(data, "der");
39130          return {
39131            curve: data.parameters.value,
39132            privateKey: data.privateKey
39133          };
39134        default:
39135          throw new Error("unknown key type " + type2);
39136      }
39137    }
39138    parseKeys.signature = asn12.signature;
39139    parseAsn1 = parseKeys;
39140    return parseAsn1;
39141  }
39142  var mgf;
39143  var hasRequiredMgf;
39144  function requireMgf() {
39145    if (hasRequiredMgf) return mgf;
39146    hasRequiredMgf = 1;
39147    var createHash2 = requireCreateHash();
39148    var Buffer2 = requireSafeBuffer$1().Buffer;
39149    mgf = function(seed, len2) {
39150      var t = Buffer2.alloc(0);
39151      var i2 = 0;
39152      var c;
39153      while (t.length < len2) {
39154        c = i2ops(i2++);
39155        t = Buffer2.concat([t, createHash2("sha1").update(seed).update(c).digest()]);
39156      }
39157      return t.slice(0, len2);
39158    };
39159    function i2ops(c) {
39160      var out = Buffer2.allocUnsafe(4);
39161      out.writeUInt32BE(c, 0);
39162      return out;
39163    }
39164    return mgf;
39165  }
39166  var xor;
39167  var hasRequiredXor;
39168  function requireXor() {
39169    if (hasRequiredXor) return xor;
39170    hasRequiredXor = 1;
39171    xor = function xor2(a, b) {
39172      var len2 = a.length;
39173      var i2 = -1;
39174      while (++i2 < len2) {
39175        a[i2] ^= b[i2];
39176      }
39177      return a;
39178    };
39179    return xor;
39180  }
39181  var withPublic_1;
39182  var hasRequiredWithPublic;
39183  function requireWithPublic() {
39184    if (hasRequiredWithPublic) return withPublic_1;
39185    hasRequiredWithPublic = 1;
39186    var BN = requireBn$1();
39187    var Buffer2 = requireSafeBuffer$1().Buffer;
39188    function withPublic(paddedMsg, key2) {
39189      return Buffer2.from(paddedMsg.toRed(BN.mont(key2.modulus)).redPow(new BN(key2.publicExponent)).fromRed().toArray());
39190    }
39191    withPublic_1 = withPublic;
39192    return withPublic_1;
39193  }
39194  var bn$1 = { exports: {} };
39195  var bn = bn$1.exports;
39196  var hasRequiredBn;
39197  function requireBn() {
39198    if (hasRequiredBn) return bn$1.exports;
39199    hasRequiredBn = 1;
39200    (function(module) {
39201      (function(module2, exports$12) {
39202        function assert2(val, msg) {
39203          if (!val) throw new Error(msg || "Assertion failed");
39204        }

vendor: 43,026 bytes, lines 39205-40461

39205        function inherits2(ctor, superCtor) {
39206          ctor.super_ = superCtor;
39207          var TempCtor = function() {
39208          };
39209          TempCtor.prototype = superCtor.prototype;
39210          ctor.prototype = new TempCtor();
39211          ctor.prototype.constructor = ctor;
39212        }
39213        function BN(number, base2, endian) {
39214          if (BN.isBN(number)) {
39215            return number;
39216          }
39217          this.negative = 0;
39218          this.words = null;
39219          this.length = 0;
39220          this.red = null;
39221          if (number !== null) {
39222            if (base2 === "le" || base2 === "be") {
39223              endian = base2;
39224              base2 = 10;
39225            }
39226            this._init(number || 0, base2 || 10, endian || "be");
39227          }
39228        }
39229        if (typeof module2 === "object") {
39230          module2.exports = BN;
39231        } else {
39232          exports$12.BN = BN;
39233        }
39234        BN.BN = BN;
39235        BN.wordSize = 26;
39236        var Buffer2;
39237        try {
39238          if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
39239            Buffer2 = window.Buffer;
39240          } else {
39241            Buffer2 = requireDist().Buffer;
39242          }
39243        } catch (e) {
39244        }
39245        BN.isBN = function isBN(num) {
39246          if (num instanceof BN) {
39247            return true;
39248          }
39249          return num !== null && typeof num === "object" && num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);
39250        };
39251        BN.max = function max2(left, right) {
39252          if (left.cmp(right) > 0) return left;
39253          return right;
39254        };
39255        BN.min = function min2(left, right) {
39256          if (left.cmp(right) < 0) return left;
39257          return right;
39258        };
39259        BN.prototype._init = function init(number, base2, endian) {
39260          if (typeof number === "number") {
39261            return this._initNumber(number, base2, endian);
39262          }
39263          if (typeof number === "object") {
39264            return this._initArray(number, base2, endian);
39265          }
39266          if (base2 === "hex") {
39267            base2 = 16;
39268          }
39269          assert2(base2 === (base2 | 0) && base2 >= 2 && base2 <= 36);
39270          number = number.toString().replace(/\s+/g, "");
39271          var start = 0;
39272          if (number[0] === "-") {
39273            start++;
39274            this.negative = 1;
39275          }
39276          if (start < number.length) {
39277            if (base2 === 16) {
39278              this._parseHex(number, start, endian);
39279            } else {
39280              this._parseBase(number, base2, start);
39281              if (endian === "le") {
39282                this._initArray(this.toArray(), base2, endian);
39283              }
39284            }
39285          }
39286        };
39287        BN.prototype._initNumber = function _initNumber(number, base2, endian) {
39288          if (number < 0) {
39289            this.negative = 1;
39290            number = -number;
39291          }
39292          if (number < 67108864) {
39293            this.words = [number & 67108863];
39294            this.length = 1;
39295          } else if (number < 4503599627370496) {
39296            this.words = [
39297              number & 67108863,
39298              number / 67108864 & 67108863
39299            ];
39300            this.length = 2;
39301          } else {
39302            assert2(number < 9007199254740992);
39303            this.words = [
39304              number & 67108863,
39305              number / 67108864 & 67108863,
39306              1
39307            ];
39308            this.length = 3;
39309          }
39310          if (endian !== "le") return;
39311          this._initArray(this.toArray(), base2, endian);
39312        };
39313        BN.prototype._initArray = function _initArray(number, base2, endian) {
39314          assert2(typeof number.length === "number");
39315          if (number.length <= 0) {
39316            this.words = [0];
39317            this.length = 1;
39318            return this;
39319          }
39320          this.length = Math.ceil(number.length / 3);
39321          this.words = new Array(this.length);
39322          for (var i2 = 0; i2 < this.length; i2++) {
39323            this.words[i2] = 0;
39324          }
39325          var j, w;
39326          var off = 0;
39327          if (endian === "be") {
39328            for (i2 = number.length - 1, j = 0; i2 >= 0; i2 -= 3) {
39329              w = number[i2] | number[i2 - 1] << 8 | number[i2 - 2] << 16;
39330              this.words[j] |= w << off & 67108863;
39331              this.words[j + 1] = w >>> 26 - off & 67108863;
39332              off += 24;
39333              if (off >= 26) {
39334                off -= 26;
39335                j++;
39336              }
39337            }
39338          } else if (endian === "le") {
39339            for (i2 = 0, j = 0; i2 < number.length; i2 += 3) {
39340              w = number[i2] | number[i2 + 1] << 8 | number[i2 + 2] << 16;
39341              this.words[j] |= w << off & 67108863;
39342              this.words[j + 1] = w >>> 26 - off & 67108863;
39343              off += 24;
39344              if (off >= 26) {
39345                off -= 26;
39346                j++;
39347              }
39348            }
39349          }
39350          return this._strip();
39351        };
39352        function parseHex4Bits(string, index) {
39353          var c = string.charCodeAt(index);
39354          if (c >= 48 && c <= 57) {
39355            return c - 48;
39356          } else if (c >= 65 && c <= 70) {
39357            return c - 55;
39358          } else if (c >= 97 && c <= 102) {
39359            return c - 87;
39360          } else {
39361            assert2(false, "Invalid character in " + string);
39362          }
39363        }
39364        function parseHexByte(string, lowerBound, index) {
39365          var r = parseHex4Bits(string, index);
39366          if (index - 1 >= lowerBound) {
39367            r |= parseHex4Bits(string, index - 1) << 4;
39368          }
39369          return r;
39370        }
39371        BN.prototype._parseHex = function _parseHex(number, start, endian) {
39372          this.length = Math.ceil((number.length - start) / 6);
39373          this.words = new Array(this.length);
39374          for (var i2 = 0; i2 < this.length; i2++) {
39375            this.words[i2] = 0;
39376          }
39377          var off = 0;
39378          var j = 0;
39379          var w;
39380          if (endian === "be") {
39381            for (i2 = number.length - 1; i2 >= start; i2 -= 2) {
39382              w = parseHexByte(number, start, i2) << off;
39383              this.words[j] |= w & 67108863;
39384              if (off >= 18) {
39385                off -= 18;
39386                j += 1;
39387                this.words[j] |= w >>> 26;
39388              } else {
39389                off += 8;
39390              }
39391            }
39392          } else {
39393            var parseLength = number.length - start;
39394            for (i2 = parseLength % 2 === 0 ? start + 1 : start; i2 < number.length; i2 += 2) {
39395              w = parseHexByte(number, start, i2) << off;
39396              this.words[j] |= w & 67108863;
39397              if (off >= 18) {
39398                off -= 18;
39399                j += 1;
39400                this.words[j] |= w >>> 26;
39401              } else {
39402                off += 8;
39403              }
39404            }
39405          }
39406          this._strip();
39407        };
39408        function parseBase(str, start, end, mul) {
39409          var r = 0;
39410          var b = 0;
39411          var len2 = Math.min(str.length, end);
39412          for (var i2 = start; i2 < len2; i2++) {
39413            var c = str.charCodeAt(i2) - 48;
39414            r *= mul;
39415            if (c >= 49) {
39416              b = c - 49 + 10;
39417            } else if (c >= 17) {
39418              b = c - 17 + 10;
39419            } else {
39420              b = c;
39421            }
39422            assert2(c >= 0 && b < mul, "Invalid character");
39423            r += b;
39424          }
39425          return r;
39426        }
39427        BN.prototype._parseBase = function _parseBase(number, base2, start) {
39428          this.words = [0];
39429          this.length = 1;
39430          for (var limbLen = 0, limbPow = 1; limbPow <= 67108863; limbPow *= base2) {
39431            limbLen++;
39432          }
39433          limbLen--;
39434          limbPow = limbPow / base2 | 0;
39435          var total = number.length - start;
39436          var mod = total % limbLen;
39437          var end = Math.min(total, total - mod) + start;
39438          var word = 0;
39439          for (var i2 = start; i2 < end; i2 += limbLen) {
39440            word = parseBase(number, i2, i2 + limbLen, base2);
39441            this.imuln(limbPow);
39442            if (this.words[0] + word < 67108864) {
39443              this.words[0] += word;
39444            } else {
39445              this._iaddn(word);
39446            }
39447          }
39448          if (mod !== 0) {
39449            var pow2 = 1;
39450            word = parseBase(number, i2, number.length, base2);
39451            for (i2 = 0; i2 < mod; i2++) {
39452              pow2 *= base2;
39453            }
39454            this.imuln(pow2);
39455            if (this.words[0] + word < 67108864) {
39456              this.words[0] += word;
39457            } else {
39458              this._iaddn(word);
39459            }
39460          }
39461          this._strip();
39462        };
39463        BN.prototype.copy = function copy(dest) {
39464          dest.words = new Array(this.length);
39465          for (var i2 = 0; i2 < this.length; i2++) {
39466            dest.words[i2] = this.words[i2];
39467          }
39468          dest.length = this.length;
39469          dest.negative = this.negative;
39470          dest.red = this.red;
39471        };
39472        function move(dest, src2) {
39473          dest.words = src2.words;
39474          dest.length = src2.length;
39475          dest.negative = src2.negative;
39476          dest.red = src2.red;
39477        }
39478        BN.prototype._move = function _move(dest) {
39479          move(dest, this);
39480        };
39481        BN.prototype.clone = function clone() {
39482          var r = new BN(null);
39483          this.copy(r);
39484          return r;
39485        };
39486        BN.prototype._expand = function _expand(size) {
39487          while (this.length < size) {
39488            this.words[this.length++] = 0;
39489          }
39490          return this;
39491        };
39492        BN.prototype._strip = function strip() {
39493          while (this.length > 1 && this.words[this.length - 1] === 0) {
39494            this.length--;
39495          }
39496          return this._normSign();
39497        };
39498        BN.prototype._normSign = function _normSign() {
39499          if (this.length === 1 && this.words[0] === 0) {
39500            this.negative = 0;
39501          }
39502          return this;
39503        };
39504        if (typeof Symbol !== "undefined" && typeof Symbol.for === "function") {
39505          try {
39506            BN.prototype[Symbol.for("nodejs.util.inspect.custom")] = inspect;
39507          } catch (e) {
39508            BN.prototype.inspect = inspect;
39509          }
39510        } else {
39511          BN.prototype.inspect = inspect;
39512        }
39513        function inspect() {
39514          return (this.red ? "<BN-R: " : "<BN: ") + this.toString(16) + ">";
39515        }
39516        var zeros = [
39517          "",
39518          "0",
39519          "00",
39520          "000",
39521          "0000",
39522          "00000",
39523          "000000",
39524          "0000000",
39525          "00000000",
39526          "000000000",
39527          "0000000000",
39528          "00000000000",
39529          "000000000000",
39530          "0000000000000",
39531          "00000000000000",
39532          "000000000000000",
39533          "0000000000000000",
39534          "00000000000000000",
39535          "000000000000000000",
39536          "0000000000000000000",
39537          "00000000000000000000",
39538          "000000000000000000000",
39539          "0000000000000000000000",
39540          "00000000000000000000000",
39541          "000000000000000000000000",
39542          "0000000000000000000000000"
39543        ];
39544        var groupSizes = [
39545          0,
39546          0,
39547          25,
39548          16,
39549          12,
39550          11,
39551          10,
39552          9,
39553          8,
39554          8,
39555          7,
39556          7,
39557          7,
39558          7,
39559          6,
39560          6,
39561          6,
39562          6,
39563          6,
39564          6,
39565          6,
39566          5,
39567          5,
39568          5,
39569          5,
39570          5,
39571          5,
39572          5,
39573          5,
39574          5,
39575          5,
39576          5,
39577          5,
39578          5,
39579          5,
39580          5,
39581          5
39582        ];
39583        var groupBases = [
39584          0,
39585          0,
39586          33554432,
39587          43046721,
39588          16777216,
39589          48828125,
39590          60466176,
39591          40353607,
39592          16777216,
39593          43046721,
39594          1e7,
39595          19487171,
39596          35831808,
39597          62748517,
39598          7529536,
39599          11390625,
39600          16777216,
39601          24137569,
39602          34012224,
39603          47045881,
39604          64e6,
39605          4084101,
39606          5153632,
39607          6436343,
39608          7962624,
39609          9765625,
39610          11881376,
39611          14348907,
39612          17210368,
39613          20511149,
39614          243e5,
39615          28629151,
39616          33554432,
39617          39135393,
39618          45435424,
39619          52521875,
39620          60466176
39621        ];
39622        BN.prototype.toString = function toString2(base2, padding) {
39623          base2 = base2 || 10;
39624          padding = padding | 0 || 1;
39625          var out;
39626          if (base2 === 16 || base2 === "hex") {
39627            out = "";
39628            var off = 0;
39629            var carry = 0;
39630            for (var i2 = 0; i2 < this.length; i2++) {
39631              var w = this.words[i2];
39632              var word = ((w << off | carry) & 16777215).toString(16);
39633              carry = w >>> 24 - off & 16777215;
39634              off += 2;
39635              if (off >= 26) {
39636                off -= 26;
39637                i2--;
39638              }
39639              if (carry !== 0 || i2 !== this.length - 1) {
39640                out = zeros[6 - word.length] + word + out;
39641              } else {
39642                out = word + out;
39643              }
39644            }
39645            if (carry !== 0) {
39646              out = carry.toString(16) + out;
39647            }
39648            while (out.length % padding !== 0) {
39649              out = "0" + out;
39650            }
39651            if (this.negative !== 0) {
39652              out = "-" + out;
39653            }
39654            return out;
39655          }
39656          if (base2 === (base2 | 0) && base2 >= 2 && base2 <= 36) {
39657            var groupSize = groupSizes[base2];
39658            var groupBase = groupBases[base2];
39659            out = "";
39660            var c = this.clone();
39661            c.negative = 0;
39662            while (!c.isZero()) {
39663              var r = c.modrn(groupBase).toString(base2);
39664              c = c.idivn(groupBase);
39665              if (!c.isZero()) {
39666                out = zeros[groupSize - r.length] + r + out;
39667              } else {
39668                out = r + out;
39669              }
39670            }
39671            if (this.isZero()) {
39672              out = "0" + out;
39673            }
39674            while (out.length % padding !== 0) {
39675              out = "0" + out;
39676            }
39677            if (this.negative !== 0) {
39678              out = "-" + out;
39679            }
39680            return out;
39681          }
39682          assert2(false, "Base should be between 2 and 36");
39683        };
39684        BN.prototype.toNumber = function toNumber() {
39685          var ret = this.words[0];
39686          if (this.length === 2) {
39687            ret += this.words[1] * 67108864;
39688          } else if (this.length === 3 && this.words[2] === 1) {
39689            ret += 4503599627370496 + this.words[1] * 67108864;
39690          } else if (this.length > 2) {
39691            assert2(false, "Number can only safely store up to 53 bits");
39692          }
39693          return this.negative !== 0 ? -ret : ret;
39694        };
39695        BN.prototype.toJSON = function toJSON() {
39696          return this.toString(16, 2);
39697        };
39698        if (Buffer2) {
39699          BN.prototype.toBuffer = function toBuffer2(endian, length) {
39700            return this.toArrayLike(Buffer2, endian, length);
39701          };
39702        }
39703        BN.prototype.toArray = function toArray2(endian, length) {
39704          return this.toArrayLike(Array, endian, length);
39705        };
39706        var allocate = function allocate2(ArrayType, size) {
39707          if (ArrayType.allocUnsafe) {
39708            return ArrayType.allocUnsafe(size);
39709          }
39710          return new ArrayType(size);
39711        };
39712        BN.prototype.toArrayLike = function toArrayLike(ArrayType, endian, length) {
39713          this._strip();
39714          var byteLength2 = this.byteLength();
39715          var reqLength = length || Math.max(1, byteLength2);
39716          assert2(byteLength2 <= reqLength, "byte array longer than desired length");
39717          assert2(reqLength > 0, "Requested array length <= 0");
39718          var res = allocate(ArrayType, reqLength);
39719          var postfix = endian === "le" ? "LE" : "BE";
39720          this["_toArrayLike" + postfix](res, byteLength2);
39721          return res;
39722        };
39723        BN.prototype._toArrayLikeLE = function _toArrayLikeLE(res, byteLength2) {
39724          var position = 0;
39725          var carry = 0;
39726          for (var i2 = 0, shift = 0; i2 < this.length; i2++) {
39727            var word = this.words[i2] << shift | carry;
39728            res[position++] = word & 255;
39729            if (position < res.length) {
39730              res[position++] = word >> 8 & 255;
39731            }
39732            if (position < res.length) {
39733              res[position++] = word >> 16 & 255;
39734            }
39735            if (shift === 6) {
39736              if (position < res.length) {
39737                res[position++] = word >> 24 & 255;
39738              }
39739              carry = 0;
39740              shift = 0;
39741            } else {
39742              carry = word >>> 24;
39743              shift += 2;
39744            }
39745          }
39746          if (position < res.length) {
39747            res[position++] = carry;
39748            while (position < res.length) {
39749              res[position++] = 0;
39750            }
39751          }
39752        };
39753        BN.prototype._toArrayLikeBE = function _toArrayLikeBE(res, byteLength2) {
39754          var position = res.length - 1;
39755          var carry = 0;
39756          for (var i2 = 0, shift = 0; i2 < this.length; i2++) {
39757            var word = this.words[i2] << shift | carry;
39758            res[position--] = word & 255;
39759            if (position >= 0) {
39760              res[position--] = word >> 8 & 255;
39761            }
39762            if (position >= 0) {
39763              res[position--] = word >> 16 & 255;
39764            }
39765            if (shift === 6) {
39766              if (position >= 0) {
39767                res[position--] = word >> 24 & 255;
39768              }
39769              carry = 0;
39770              shift = 0;
39771            } else {
39772              carry = word >>> 24;
39773              shift += 2;
39774            }
39775          }
39776          if (position >= 0) {
39777            res[position--] = carry;
39778            while (position >= 0) {
39779              res[position--] = 0;
39780            }
39781          }
39782        };
39783        if (Math.clz32) {
39784          BN.prototype._countBits = function _countBits(w) {
39785            return 32 - Math.clz32(w);
39786          };
39787        } else {
39788          BN.prototype._countBits = function _countBits(w) {
39789            var t = w;
39790            var r = 0;
39791            if (t >= 4096) {
39792              r += 13;
39793              t >>>= 13;
39794            }
39795            if (t >= 64) {
39796              r += 7;
39797              t >>>= 7;
39798            }
39799            if (t >= 8) {
39800              r += 4;
39801              t >>>= 4;
39802            }
39803            if (t >= 2) {
39804              r += 2;
39805              t >>>= 2;
39806            }
39807            return r + t;
39808          };
39809        }
39810        BN.prototype._zeroBits = function _zeroBits(w) {
39811          if (w === 0) return 26;
39812          var t = w;
39813          var r = 0;
39814          if ((t & 8191) === 0) {
39815            r += 13;
39816            t >>>= 13;
39817          }
39818          if ((t & 127) === 0) {
39819            r += 7;
39820            t >>>= 7;
39821          }
39822          if ((t & 15) === 0) {
39823            r += 4;
39824            t >>>= 4;
39825          }
39826          if ((t & 3) === 0) {
39827            r += 2;
39828            t >>>= 2;
39829          }
39830          if ((t & 1) === 0) {
39831            r++;
39832          }
39833          return r;
39834        };
39835        BN.prototype.bitLength = function bitLength() {
39836          var w = this.words[this.length - 1];
39837          var hi = this._countBits(w);
39838          return (this.length - 1) * 26 + hi;
39839        };
39840        function toBitArray(num) {
39841          var w = new Array(num.bitLength());
39842          for (var bit = 0; bit < w.length; bit++) {
39843            var off = bit / 26 | 0;
39844            var wbit = bit % 26;
39845            w[bit] = num.words[off] >>> wbit & 1;
39846          }
39847          return w;
39848        }
39849        BN.prototype.zeroBits = function zeroBits() {
39850          if (this.isZero()) return 0;
39851          var r = 0;
39852          for (var i2 = 0; i2 < this.length; i2++) {
39853            var b = this._zeroBits(this.words[i2]);
39854            r += b;
39855            if (b !== 26) break;
39856          }
39857          return r;
39858        };
39859        BN.prototype.byteLength = function byteLength2() {
39860          return Math.ceil(this.bitLength() / 8);
39861        };
39862        BN.prototype.toTwos = function toTwos(width) {
39863          if (this.negative !== 0) {
39864            return this.abs().inotn(width).iaddn(1);
39865          }
39866          return this.clone();
39867        };
39868        BN.prototype.fromTwos = function fromTwos(width) {
39869          if (this.testn(width - 1)) {
39870            return this.notn(width).iaddn(1).ineg();
39871          }
39872          return this.clone();
39873        };
39874        BN.prototype.isNeg = function isNeg() {
39875          return this.negative !== 0;
39876        };
39877        BN.prototype.neg = function neg() {
39878          return this.clone().ineg();
39879        };
39880        BN.prototype.ineg = function ineg() {
39881          if (!this.isZero()) {
39882            this.negative ^= 1;
39883          }
39884          return this;
39885        };
39886        BN.prototype.iuor = function iuor(num) {
39887          while (this.length < num.length) {
39888            this.words[this.length++] = 0;
39889          }
39890          for (var i2 = 0; i2 < num.length; i2++) {
39891            this.words[i2] = this.words[i2] | num.words[i2];
39892          }
39893          return this._strip();
39894        };
39895        BN.prototype.ior = function ior(num) {
39896          assert2((this.negative | num.negative) === 0);
39897          return this.iuor(num);
39898        };
39899        BN.prototype.or = function or(num) {
39900          if (this.length > num.length) return this.clone().ior(num);
39901          return num.clone().ior(this);
39902        };
39903        BN.prototype.uor = function uor(num) {
39904          if (this.length > num.length) return this.clone().iuor(num);
39905          return num.clone().iuor(this);
39906        };
39907        BN.prototype.iuand = function iuand(num) {
39908          var b;
39909          if (this.length > num.length) {
39910            b = num;
39911          } else {
39912            b = this;
39913          }
39914          for (var i2 = 0; i2 < b.length; i2++) {
39915            this.words[i2] = this.words[i2] & num.words[i2];
39916          }
39917          this.length = b.length;
39918          return this._strip();
39919        };
39920        BN.prototype.iand = function iand(num) {
39921          assert2((this.negative | num.negative) === 0);
39922          return this.iuand(num);
39923        };
39924        BN.prototype.and = function and(num) {
39925          if (this.length > num.length) return this.clone().iand(num);
39926          return num.clone().iand(this);
39927        };
39928        BN.prototype.uand = function uand(num) {
39929          if (this.length > num.length) return this.clone().iuand(num);
39930          return num.clone().iuand(this);
39931        };
39932        BN.prototype.iuxor = function iuxor(num) {
39933          var a;
39934          var b;
39935          if (this.length > num.length) {
39936            a = this;
39937            b = num;
39938          } else {
39939            a = num;
39940            b = this;
39941          }
39942          for (var i2 = 0; i2 < b.length; i2++) {
39943            this.words[i2] = a.words[i2] ^ b.words[i2];
39944          }
39945          if (this !== a) {
39946            for (; i2 < a.length; i2++) {
39947              this.words[i2] = a.words[i2];
39948            }
39949          }
39950          this.length = a.length;
39951          return this._strip();
39952        };
39953        BN.prototype.ixor = function ixor(num) {
39954          assert2((this.negative | num.negative) === 0);
39955          return this.iuxor(num);
39956        };
39957        BN.prototype.xor = function xor2(num) {
39958          if (this.length > num.length) return this.clone().ixor(num);
39959          return num.clone().ixor(this);
39960        };
39961        BN.prototype.uxor = function uxor(num) {
39962          if (this.length > num.length) return this.clone().iuxor(num);
39963          return num.clone().iuxor(this);
39964        };
39965        BN.prototype.inotn = function inotn(width) {
39966          assert2(typeof width === "number" && width >= 0);
39967          var bytesNeeded = Math.ceil(width / 26) | 0;
39968          var bitsLeft = width % 26;
39969          this._expand(bytesNeeded);
39970          if (bitsLeft > 0) {
39971            bytesNeeded--;
39972          }
39973          for (var i2 = 0; i2 < bytesNeeded; i2++) {
39974            this.words[i2] = ~this.words[i2] & 67108863;
39975          }
39976          if (bitsLeft > 0) {
39977            this.words[i2] = ~this.words[i2] & 67108863 >> 26 - bitsLeft;
39978          }
39979          return this._strip();
39980        };
39981        BN.prototype.notn = function notn(width) {
39982          return this.clone().inotn(width);
39983        };
39984        BN.prototype.setn = function setn(bit, val) {
39985          assert2(typeof bit === "number" && bit >= 0);
39986          var off = bit / 26 | 0;
39987          var wbit = bit % 26;
39988          this._expand(off + 1);
39989          if (val) {
39990            this.words[off] = this.words[off] | 1 << wbit;
39991          } else {
39992            this.words[off] = this.words[off] & ~(1 << wbit);
39993          }
39994          return this._strip();
39995        };
39996        BN.prototype.iadd = function iadd(num) {
39997          var r;
39998          if (this.negative !== 0 && num.negative === 0) {
39999            this.negative = 0;
40000            r = this.isub(num);
40001            this.negative ^= 1;
40002            return this._normSign();
40003          } else if (this.negative === 0 && num.negative !== 0) {
40004            num.negative = 0;
40005            r = this.isub(num);
40006            num.negative = 1;
40007            return r._normSign();
40008          }
40009          var a, b;
40010          if (this.length > num.length) {
40011            a = this;
40012            b = num;
40013          } else {
40014            a = num;
40015            b = this;
40016          }
40017          var carry = 0;
40018          for (var i2 = 0; i2 < b.length; i2++) {
40019            r = (a.words[i2] | 0) + (b.words[i2] | 0) + carry;
40020            this.words[i2] = r & 67108863;
40021            carry = r >>> 26;
40022          }
40023          for (; carry !== 0 && i2 < a.length; i2++) {
40024            r = (a.words[i2] | 0) + carry;
40025            this.words[i2] = r & 67108863;
40026            carry = r >>> 26;
40027          }
40028          this.length = a.length;
40029          if (carry !== 0) {
40030            this.words[this.length] = carry;
40031            this.length++;
40032          } else if (a !== this) {
40033            for (; i2 < a.length; i2++) {
40034              this.words[i2] = a.words[i2];
40035            }
40036          }
40037          return this;
40038        };
40039        BN.prototype.add = function add(num) {
40040          var res;
40041          if (num.negative !== 0 && this.negative === 0) {
40042            num.negative = 0;
40043            res = this.sub(num);
40044            num.negative ^= 1;
40045            return res;
40046          } else if (num.negative === 0 && this.negative !== 0) {
40047            this.negative = 0;
40048            res = num.sub(this);
40049            this.negative = 1;
40050            return res;
40051          }
40052          if (this.length > num.length) return this.clone().iadd(num);
40053          return num.clone().iadd(this);
40054        };
40055        BN.prototype.isub = function isub(num) {
40056          if (num.negative !== 0) {
40057            num.negative = 0;
40058            var r = this.iadd(num);
40059            num.negative = 1;
40060            return r._normSign();
40061          } else if (this.negative !== 0) {
40062            this.negative = 0;
40063            this.iadd(num);
40064            this.negative = 1;
40065            return this._normSign();
40066          }
40067          var cmp = this.cmp(num);
40068          if (cmp === 0) {
40069            this.negative = 0;
40070            this.length = 1;
40071            this.words[0] = 0;
40072            return this;
40073          }
40074          var a, b;
40075          if (cmp > 0) {
40076            a = this;
40077            b = num;
40078          } else {
40079            a = num;
40080            b = this;
40081          }
40082          var carry = 0;
40083          for (var i2 = 0; i2 < b.length; i2++) {
40084            r = (a.words[i2] | 0) - (b.words[i2] | 0) + carry;
40085            carry = r >> 26;
40086            this.words[i2] = r & 67108863;
40087          }
40088          for (; carry !== 0 && i2 < a.length; i2++) {
40089            r = (a.words[i2] | 0) + carry;
40090            carry = r >> 26;
40091            this.words[i2] = r & 67108863;
40092          }
40093          if (carry === 0 && i2 < a.length && a !== this) {
40094            for (; i2 < a.length; i2++) {
40095              this.words[i2] = a.words[i2];
40096            }
40097          }
40098          this.length = Math.max(this.length, i2);
40099          if (a !== this) {
40100            this.negative = 1;
40101          }
40102          return this._strip();
40103        };
40104        BN.prototype.sub = function sub(num) {
40105          return this.clone().isub(num);
40106        };
40107        function smallMulTo(self2, num, out) {
40108          out.negative = num.negative ^ self2.negative;
40109          var len2 = self2.length + num.length | 0;
40110          out.length = len2;
40111          len2 = len2 - 1 | 0;
40112          var a = self2.words[0] | 0;
40113          var b = num.words[0] | 0;
40114          var r = a * b;
40115          var lo = r & 67108863;
40116          var carry = r / 67108864 | 0;
40117          out.words[0] = lo;
40118          for (var k = 1; k < len2; k++) {
40119            var ncarry = carry >>> 26;
40120            var rword = carry & 67108863;
40121            var maxJ = Math.min(k, num.length - 1);
40122            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
40123              var i2 = k - j | 0;
40124              a = self2.words[i2] | 0;
40125              b = num.words[j] | 0;
40126              r = a * b + rword;
40127              ncarry += r / 67108864 | 0;
40128              rword = r & 67108863;
40129            }
40130            out.words[k] = rword | 0;
40131            carry = ncarry | 0;
40132          }
40133          if (carry !== 0) {
40134            out.words[k] = carry | 0;
40135          } else {
40136            out.length--;
40137          }
40138          return out._strip();
40139        }
40140        var comb10MulTo = function comb10MulTo2(self2, num, out) {
40141          var a = self2.words;
40142          var b = num.words;
40143          var o = out.words;
40144          var c = 0;
40145          var lo;
40146          var mid;
40147          var hi;
40148          var a0 = a[0] | 0;
40149          var al0 = a0 & 8191;
40150          var ah0 = a0 >>> 13;
40151          var a1 = a[1] | 0;
40152          var al1 = a1 & 8191;
40153          var ah1 = a1 >>> 13;
40154          var a2 = a[2] | 0;
40155          var al2 = a2 & 8191;
40156          var ah2 = a2 >>> 13;
40157          var a3 = a[3] | 0;
40158          var al3 = a3 & 8191;
40159          var ah3 = a3 >>> 13;
40160          var a4 = a[4] | 0;
40161          var al4 = a4 & 8191;
40162          var ah4 = a4 >>> 13;
40163          var a5 = a[5] | 0;
40164          var al5 = a5 & 8191;
40165          var ah5 = a5 >>> 13;
40166          var a6 = a[6] | 0;
40167          var al6 = a6 & 8191;
40168          var ah6 = a6 >>> 13;
40169          var a7 = a[7] | 0;
40170          var al7 = a7 & 8191;
40171          var ah7 = a7 >>> 13;
40172          var a8 = a[8] | 0;
40173          var al8 = a8 & 8191;
40174          var ah8 = a8 >>> 13;
40175          var a9 = a[9] | 0;
40176          var al9 = a9 & 8191;
40177          var ah9 = a9 >>> 13;
40178          var b0 = b[0] | 0;
40179          var bl0 = b0 & 8191;
40180          var bh0 = b0 >>> 13;
40181          var b1 = b[1] | 0;
40182          var bl1 = b1 & 8191;
40183          var bh1 = b1 >>> 13;
40184          var b2 = b[2] | 0;
40185          var bl2 = b2 & 8191;
40186          var bh2 = b2 >>> 13;
40187          var b3 = b[3] | 0;
40188          var bl3 = b3 & 8191;
40189          var bh3 = b3 >>> 13;
40190          var b4 = b[4] | 0;
40191          var bl4 = b4 & 8191;
40192          var bh4 = b4 >>> 13;
40193          var b5 = b[5] | 0;
40194          var bl5 = b5 & 8191;
40195          var bh5 = b5 >>> 13;
40196          var b6 = b[6] | 0;
40197          var bl6 = b6 & 8191;
40198          var bh6 = b6 >>> 13;
40199          var b7 = b[7] | 0;
40200          var bl7 = b7 & 8191;
40201          var bh7 = b7 >>> 13;
40202          var b8 = b[8] | 0;
40203          var bl8 = b8 & 8191;
40204          var bh8 = b8 >>> 13;
40205          var b9 = b[9] | 0;
40206          var bl9 = b9 & 8191;
40207          var bh9 = b9 >>> 13;
40208          out.negative = self2.negative ^ num.negative;
40209          out.length = 19;
40210          lo = Math.imul(al0, bl0);
40211          mid = Math.imul(al0, bh0);
40212          mid = mid + Math.imul(ah0, bl0) | 0;
40213          hi = Math.imul(ah0, bh0);
40214          var w0 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40215          c = (hi + (mid >>> 13) | 0) + (w0 >>> 26) | 0;
40216          w0 &= 67108863;
40217          lo = Math.imul(al1, bl0);
40218          mid = Math.imul(al1, bh0);
40219          mid = mid + Math.imul(ah1, bl0) | 0;
40220          hi = Math.imul(ah1, bh0);
40221          lo = lo + Math.imul(al0, bl1) | 0;
40222          mid = mid + Math.imul(al0, bh1) | 0;
40223          mid = mid + Math.imul(ah0, bl1) | 0;
40224          hi = hi + Math.imul(ah0, bh1) | 0;
40225          var w1 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40226          c = (hi + (mid >>> 13) | 0) + (w1 >>> 26) | 0;
40227          w1 &= 67108863;
40228          lo = Math.imul(al2, bl0);
40229          mid = Math.imul(al2, bh0);
40230          mid = mid + Math.imul(ah2, bl0) | 0;
40231          hi = Math.imul(ah2, bh0);
40232          lo = lo + Math.imul(al1, bl1) | 0;
40233          mid = mid + Math.imul(al1, bh1) | 0;
40234          mid = mid + Math.imul(ah1, bl1) | 0;
40235          hi = hi + Math.imul(ah1, bh1) | 0;
40236          lo = lo + Math.imul(al0, bl2) | 0;
40237          mid = mid + Math.imul(al0, bh2) | 0;
40238          mid = mid + Math.imul(ah0, bl2) | 0;
40239          hi = hi + Math.imul(ah0, bh2) | 0;
40240          var w2 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40241          c = (hi + (mid >>> 13) | 0) + (w2 >>> 26) | 0;
40242          w2 &= 67108863;
40243          lo = Math.imul(al3, bl0);
40244          mid = Math.imul(al3, bh0);
40245          mid = mid + Math.imul(ah3, bl0) | 0;
40246          hi = Math.imul(ah3, bh0);
40247          lo = lo + Math.imul(al2, bl1) | 0;
40248          mid = mid + Math.imul(al2, bh1) | 0;
40249          mid = mid + Math.imul(ah2, bl1) | 0;
40250          hi = hi + Math.imul(ah2, bh1) | 0;
40251          lo = lo + Math.imul(al1, bl2) | 0;
40252          mid = mid + Math.imul(al1, bh2) | 0;
40253          mid = mid + Math.imul(ah1, bl2) | 0;
40254          hi = hi + Math.imul(ah1, bh2) | 0;
40255          lo = lo + Math.imul(al0, bl3) | 0;
40256          mid = mid + Math.imul(al0, bh3) | 0;
40257          mid = mid + Math.imul(ah0, bl3) | 0;
40258          hi = hi + Math.imul(ah0, bh3) | 0;
40259          var w3 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40260          c = (hi + (mid >>> 13) | 0) + (w3 >>> 26) | 0;
40261          w3 &= 67108863;
40262          lo = Math.imul(al4, bl0);
40263          mid = Math.imul(al4, bh0);
40264          mid = mid + Math.imul(ah4, bl0) | 0;
40265          hi = Math.imul(ah4, bh0);
40266          lo = lo + Math.imul(al3, bl1) | 0;
40267          mid = mid + Math.imul(al3, bh1) | 0;
40268          mid = mid + Math.imul(ah3, bl1) | 0;
40269          hi = hi + Math.imul(ah3, bh1) | 0;
40270          lo = lo + Math.imul(al2, bl2) | 0;
40271          mid = mid + Math.imul(al2, bh2) | 0;
40272          mid = mid + Math.imul(ah2, bl2) | 0;
40273          hi = hi + Math.imul(ah2, bh2) | 0;
40274          lo = lo + Math.imul(al1, bl3) | 0;
40275          mid = mid + Math.imul(al1, bh3) | 0;
40276          mid = mid + Math.imul(ah1, bl3) | 0;
40277          hi = hi + Math.imul(ah1, bh3) | 0;
40278          lo = lo + Math.imul(al0, bl4) | 0;
40279          mid = mid + Math.imul(al0, bh4) | 0;
40280          mid = mid + Math.imul(ah0, bl4) | 0;
40281          hi = hi + Math.imul(ah0, bh4) | 0;
40282          var w4 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40283          c = (hi + (mid >>> 13) | 0) + (w4 >>> 26) | 0;
40284          w4 &= 67108863;
40285          lo = Math.imul(al5, bl0);
40286          mid = Math.imul(al5, bh0);
40287          mid = mid + Math.imul(ah5, bl0) | 0;
40288          hi = Math.imul(ah5, bh0);
40289          lo = lo + Math.imul(al4, bl1) | 0;
40290          mid = mid + Math.imul(al4, bh1) | 0;
40291          mid = mid + Math.imul(ah4, bl1) | 0;
40292          hi = hi + Math.imul(ah4, bh1) | 0;
40293          lo = lo + Math.imul(al3, bl2) | 0;
40294          mid = mid + Math.imul(al3, bh2) | 0;
40295          mid = mid + Math.imul(ah3, bl2) | 0;
40296          hi = hi + Math.imul(ah3, bh2) | 0;
40297          lo = lo + Math.imul(al2, bl3) | 0;
40298          mid = mid + Math.imul(al2, bh3) | 0;
40299          mid = mid + Math.imul(ah2, bl3) | 0;
40300          hi = hi + Math.imul(ah2, bh3) | 0;
40301          lo = lo + Math.imul(al1, bl4) | 0;
40302          mid = mid + Math.imul(al1, bh4) | 0;
40303          mid = mid + Math.imul(ah1, bl4) | 0;
40304          hi = hi + Math.imul(ah1, bh4) | 0;
40305          lo = lo + Math.imul(al0, bl5) | 0;
40306          mid = mid + Math.imul(al0, bh5) | 0;
40307          mid = mid + Math.imul(ah0, bl5) | 0;
40308          hi = hi + Math.imul(ah0, bh5) | 0;
40309          var w5 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40310          c = (hi + (mid >>> 13) | 0) + (w5 >>> 26) | 0;
40311          w5 &= 67108863;
40312          lo = Math.imul(al6, bl0);
40313          mid = Math.imul(al6, bh0);
40314          mid = mid + Math.imul(ah6, bl0) | 0;
40315          hi = Math.imul(ah6, bh0);
40316          lo = lo + Math.imul(al5, bl1) | 0;
40317          mid = mid + Math.imul(al5, bh1) | 0;
40318          mid = mid + Math.imul(ah5, bl1) | 0;
40319          hi = hi + Math.imul(ah5, bh1) | 0;
40320          lo = lo + Math.imul(al4, bl2) | 0;
40321          mid = mid + Math.imul(al4, bh2) | 0;
40322          mid = mid + Math.imul(ah4, bl2) | 0;
40323          hi = hi + Math.imul(ah4, bh2) | 0;
40324          lo = lo + Math.imul(al3, bl3) | 0;
40325          mid = mid + Math.imul(al3, bh3) | 0;
40326          mid = mid + Math.imul(ah3, bl3) | 0;
40327          hi = hi + Math.imul(ah3, bh3) | 0;
40328          lo = lo + Math.imul(al2, bl4) | 0;
40329          mid = mid + Math.imul(al2, bh4) | 0;
40330          mid = mid + Math.imul(ah2, bl4) | 0;
40331          hi = hi + Math.imul(ah2, bh4) | 0;
40332          lo = lo + Math.imul(al1, bl5) | 0;
40333          mid = mid + Math.imul(al1, bh5) | 0;
40334          mid = mid + Math.imul(ah1, bl5) | 0;
40335          hi = hi + Math.imul(ah1, bh5) | 0;
40336          lo = lo + Math.imul(al0, bl6) | 0;
40337          mid = mid + Math.imul(al0, bh6) | 0;
40338          mid = mid + Math.imul(ah0, bl6) | 0;
40339          hi = hi + Math.imul(ah0, bh6) | 0;
40340          var w6 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40341          c = (hi + (mid >>> 13) | 0) + (w6 >>> 26) | 0;
40342          w6 &= 67108863;
40343          lo = Math.imul(al7, bl0);
40344          mid = Math.imul(al7, bh0);
40345          mid = mid + Math.imul(ah7, bl0) | 0;
40346          hi = Math.imul(ah7, bh0);
40347          lo = lo + Math.imul(al6, bl1) | 0;
40348          mid = mid + Math.imul(al6, bh1) | 0;
40349          mid = mid + Math.imul(ah6, bl1) | 0;
40350          hi = hi + Math.imul(ah6, bh1) | 0;
40351          lo = lo + Math.imul(al5, bl2) | 0;
40352          mid = mid + Math.imul(al5, bh2) | 0;
40353          mid = mid + Math.imul(ah5, bl2) | 0;
40354          hi = hi + Math.imul(ah5, bh2) | 0;
40355          lo = lo + Math.imul(al4, bl3) | 0;
40356          mid = mid + Math.imul(al4, bh3) | 0;
40357          mid = mid + Math.imul(ah4, bl3) | 0;
40358          hi = hi + Math.imul(ah4, bh3) | 0;
40359          lo = lo + Math.imul(al3, bl4) | 0;
40360          mid = mid + Math.imul(al3, bh4) | 0;
40361          mid = mid + Math.imul(ah3, bl4) | 0;
40362          hi = hi + Math.imul(ah3, bh4) | 0;
40363          lo = lo + Math.imul(al2, bl5) | 0;
40364          mid = mid + Math.imul(al2, bh5) | 0;
40365          mid = mid + Math.imul(ah2, bl5) | 0;
40366          hi = hi + Math.imul(ah2, bh5) | 0;
40367          lo = lo + Math.imul(al1, bl6) | 0;
40368          mid = mid + Math.imul(al1, bh6) | 0;
40369          mid = mid + Math.imul(ah1, bl6) | 0;
40370          hi = hi + Math.imul(ah1, bh6) | 0;
40371          lo = lo + Math.imul(al0, bl7) | 0;
40372          mid = mid + Math.imul(al0, bh7) | 0;
40373          mid = mid + Math.imul(ah0, bl7) | 0;
40374          hi = hi + Math.imul(ah0, bh7) | 0;
40375          var w7 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40376          c = (hi + (mid >>> 13) | 0) + (w7 >>> 26) | 0;
40377          w7 &= 67108863;
40378          lo = Math.imul(al8, bl0);
40379          mid = Math.imul(al8, bh0);
40380          mid = mid + Math.imul(ah8, bl0) | 0;
40381          hi = Math.imul(ah8, bh0);
40382          lo = lo + Math.imul(al7, bl1) | 0;
40383          mid = mid + Math.imul(al7, bh1) | 0;
40384          mid = mid + Math.imul(ah7, bl1) | 0;
40385          hi = hi + Math.imul(ah7, bh1) | 0;
40386          lo = lo + Math.imul(al6, bl2) | 0;
40387          mid = mid + Math.imul(al6, bh2) | 0;
40388          mid = mid + Math.imul(ah6, bl2) | 0;
40389          hi = hi + Math.imul(ah6, bh2) | 0;
40390          lo = lo + Math.imul(al5, bl3) | 0;
40391          mid = mid + Math.imul(al5, bh3) | 0;
40392          mid = mid + Math.imul(ah5, bl3) | 0;
40393          hi = hi + Math.imul(ah5, bh3) | 0;
40394          lo = lo + Math.imul(al4, bl4) | 0;
40395          mid = mid + Math.imul(al4, bh4) | 0;
40396          mid = mid + Math.imul(ah4, bl4) | 0;
40397          hi = hi + Math.imul(ah4, bh4) | 0;
40398          lo = lo + Math.imul(al3, bl5) | 0;
40399          mid = mid + Math.imul(al3, bh5) | 0;
40400          mid = mid + Math.imul(ah3, bl5) | 0;
40401          hi = hi + Math.imul(ah3, bh5) | 0;
40402          lo = lo + Math.imul(al2, bl6) | 0;
40403          mid = mid + Math.imul(al2, bh6) | 0;
40404          mid = mid + Math.imul(ah2, bl6) | 0;
40405          hi = hi + Math.imul(ah2, bh6) | 0;
40406          lo = lo + Math.imul(al1, bl7) | 0;
40407          mid = mid + Math.imul(al1, bh7) | 0;
40408          mid = mid + Math.imul(ah1, bl7) | 0;
40409          hi = hi + Math.imul(ah1, bh7) | 0;
40410          lo = lo + Math.imul(al0, bl8) | 0;
40411          mid = mid + Math.imul(al0, bh8) | 0;
40412          mid = mid + Math.imul(ah0, bl8) | 0;
40413          hi = hi + Math.imul(ah0, bh8) | 0;
40414          var w8 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40415          c = (hi + (mid >>> 13) | 0) + (w8 >>> 26) | 0;
40416          w8 &= 67108863;
40417          lo = Math.imul(al9, bl0);
40418          mid = Math.imul(al9, bh0);
40419          mid = mid + Math.imul(ah9, bl0) | 0;
40420          hi = Math.imul(ah9, bh0);
40421          lo = lo + Math.imul(al8, bl1) | 0;
40422          mid = mid + Math.imul(al8, bh1) | 0;
40423          mid = mid + Math.imul(ah8, bl1) | 0;
40424          hi = hi + Math.imul(ah8, bh1) | 0;
40425          lo = lo + Math.imul(al7, bl2) | 0;
40426          mid = mid + Math.imul(al7, bh2) | 0;
40427          mid = mid + Math.imul(ah7, bl2) | 0;
40428          hi = hi + Math.imul(ah7, bh2) | 0;
40429          lo = lo + Math.imul(al6, bl3) | 0;
40430          mid = mid + Math.imul(al6, bh3) | 0;
40431          mid = mid + Math.imul(ah6, bl3) | 0;
40432          hi = hi + Math.imul(ah6, bh3) | 0;
40433          lo = lo + Math.imul(al5, bl4) | 0;
40434          mid = mid + Math.imul(al5, bh4) | 0;
40435          mid = mid + Math.imul(ah5, bl4) | 0;
40436          hi = hi + Math.imul(ah5, bh4) | 0;
40437          lo = lo + Math.imul(al4, bl5) | 0;
40438          mid = mid + Math.imul(al4, bh5) | 0;
40439          mid = mid + Math.imul(ah4, bl5) | 0;
40440          hi = hi + Math.imul(ah4, bh5) | 0;
40441          lo = lo + Math.imul(al3, bl6) | 0;
40442          mid = mid + Math.imul(al3, bh6) | 0;
40443          mid = mid + Math.imul(ah3, bl6) | 0;
40444          hi = hi + Math.imul(ah3, bh6) | 0;
40445          lo = lo + Math.imul(al2, bl7) | 0;
40446          mid = mid + Math.imul(al2, bh7) | 0;
40447          mid = mid + Math.imul(ah2, bl7) | 0;
40448          hi = hi + Math.imul(ah2, bh7) | 0;
40449          lo = lo + Math.imul(al1, bl8) | 0;
40450          mid = mid + Math.imul(al1, bh8) | 0;
40451          mid = mid + Math.imul(ah1, bl8) | 0;
40452          hi = hi + Math.imul(ah1, bh8) | 0;
40453          lo = lo + Math.imul(al0, bl9) | 0;
40454          mid = mid + Math.imul(al0, bh9) | 0;
40455          mid = mid + Math.imul(ah0, bl9) | 0;
40456          hi = hi + Math.imul(ah0, bh9) | 0;
40457          var w9 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40458          c = (hi + (mid >>> 13) | 0) + (w9 >>> 26) | 0;
40459          w9 &= 67108863;
40460          lo = Math.imul(al9, bl1);
40461          mid = Math.imul(al9, bh1);

vendor: 21,690 bytes, lines 40462-41034

40462          mid = mid + Math.imul(ah9, bl1) | 0;
40463          hi = Math.imul(ah9, bh1);
40464          lo = lo + Math.imul(al8, bl2) | 0;
40465          mid = mid + Math.imul(al8, bh2) | 0;
40466          mid = mid + Math.imul(ah8, bl2) | 0;
40467          hi = hi + Math.imul(ah8, bh2) | 0;
40468          lo = lo + Math.imul(al7, bl3) | 0;
40469          mid = mid + Math.imul(al7, bh3) | 0;
40470          mid = mid + Math.imul(ah7, bl3) | 0;
40471          hi = hi + Math.imul(ah7, bh3) | 0;
40472          lo = lo + Math.imul(al6, bl4) | 0;
40473          mid = mid + Math.imul(al6, bh4) | 0;
40474          mid = mid + Math.imul(ah6, bl4) | 0;
40475          hi = hi + Math.imul(ah6, bh4) | 0;
40476          lo = lo + Math.imul(al5, bl5) | 0;
40477          mid = mid + Math.imul(al5, bh5) | 0;
40478          mid = mid + Math.imul(ah5, bl5) | 0;
40479          hi = hi + Math.imul(ah5, bh5) | 0;
40480          lo = lo + Math.imul(al4, bl6) | 0;
40481          mid = mid + Math.imul(al4, bh6) | 0;
40482          mid = mid + Math.imul(ah4, bl6) | 0;
40483          hi = hi + Math.imul(ah4, bh6) | 0;
40484          lo = lo + Math.imul(al3, bl7) | 0;
40485          mid = mid + Math.imul(al3, bh7) | 0;
40486          mid = mid + Math.imul(ah3, bl7) | 0;
40487          hi = hi + Math.imul(ah3, bh7) | 0;
40488          lo = lo + Math.imul(al2, bl8) | 0;
40489          mid = mid + Math.imul(al2, bh8) | 0;
40490          mid = mid + Math.imul(ah2, bl8) | 0;
40491          hi = hi + Math.imul(ah2, bh8) | 0;
40492          lo = lo + Math.imul(al1, bl9) | 0;
40493          mid = mid + Math.imul(al1, bh9) | 0;
40494          mid = mid + Math.imul(ah1, bl9) | 0;
40495          hi = hi + Math.imul(ah1, bh9) | 0;
40496          var w10 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40497          c = (hi + (mid >>> 13) | 0) + (w10 >>> 26) | 0;
40498          w10 &= 67108863;
40499          lo = Math.imul(al9, bl2);
40500          mid = Math.imul(al9, bh2);
40501          mid = mid + Math.imul(ah9, bl2) | 0;
40502          hi = Math.imul(ah9, bh2);
40503          lo = lo + Math.imul(al8, bl3) | 0;
40504          mid = mid + Math.imul(al8, bh3) | 0;
40505          mid = mid + Math.imul(ah8, bl3) | 0;
40506          hi = hi + Math.imul(ah8, bh3) | 0;
40507          lo = lo + Math.imul(al7, bl4) | 0;
40508          mid = mid + Math.imul(al7, bh4) | 0;
40509          mid = mid + Math.imul(ah7, bl4) | 0;
40510          hi = hi + Math.imul(ah7, bh4) | 0;
40511          lo = lo + Math.imul(al6, bl5) | 0;
40512          mid = mid + Math.imul(al6, bh5) | 0;
40513          mid = mid + Math.imul(ah6, bl5) | 0;
40514          hi = hi + Math.imul(ah6, bh5) | 0;
40515          lo = lo + Math.imul(al5, bl6) | 0;
40516          mid = mid + Math.imul(al5, bh6) | 0;
40517          mid = mid + Math.imul(ah5, bl6) | 0;
40518          hi = hi + Math.imul(ah5, bh6) | 0;
40519          lo = lo + Math.imul(al4, bl7) | 0;
40520          mid = mid + Math.imul(al4, bh7) | 0;
40521          mid = mid + Math.imul(ah4, bl7) | 0;
40522          hi = hi + Math.imul(ah4, bh7) | 0;
40523          lo = lo + Math.imul(al3, bl8) | 0;
40524          mid = mid + Math.imul(al3, bh8) | 0;
40525          mid = mid + Math.imul(ah3, bl8) | 0;
40526          hi = hi + Math.imul(ah3, bh8) | 0;
40527          lo = lo + Math.imul(al2, bl9) | 0;
40528          mid = mid + Math.imul(al2, bh9) | 0;
40529          mid = mid + Math.imul(ah2, bl9) | 0;
40530          hi = hi + Math.imul(ah2, bh9) | 0;
40531          var w11 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40532          c = (hi + (mid >>> 13) | 0) + (w11 >>> 26) | 0;
40533          w11 &= 67108863;
40534          lo = Math.imul(al9, bl3);
40535          mid = Math.imul(al9, bh3);
40536          mid = mid + Math.imul(ah9, bl3) | 0;
40537          hi = Math.imul(ah9, bh3);
40538          lo = lo + Math.imul(al8, bl4) | 0;
40539          mid = mid + Math.imul(al8, bh4) | 0;
40540          mid = mid + Math.imul(ah8, bl4) | 0;
40541          hi = hi + Math.imul(ah8, bh4) | 0;
40542          lo = lo + Math.imul(al7, bl5) | 0;
40543          mid = mid + Math.imul(al7, bh5) | 0;
40544          mid = mid + Math.imul(ah7, bl5) | 0;
40545          hi = hi + Math.imul(ah7, bh5) | 0;
40546          lo = lo + Math.imul(al6, bl6) | 0;
40547          mid = mid + Math.imul(al6, bh6) | 0;
40548          mid = mid + Math.imul(ah6, bl6) | 0;
40549          hi = hi + Math.imul(ah6, bh6) | 0;
40550          lo = lo + Math.imul(al5, bl7) | 0;
40551          mid = mid + Math.imul(al5, bh7) | 0;
40552          mid = mid + Math.imul(ah5, bl7) | 0;
40553          hi = hi + Math.imul(ah5, bh7) | 0;
40554          lo = lo + Math.imul(al4, bl8) | 0;
40555          mid = mid + Math.imul(al4, bh8) | 0;
40556          mid = mid + Math.imul(ah4, bl8) | 0;
40557          hi = hi + Math.imul(ah4, bh8) | 0;
40558          lo = lo + Math.imul(al3, bl9) | 0;
40559          mid = mid + Math.imul(al3, bh9) | 0;
40560          mid = mid + Math.imul(ah3, bl9) | 0;
40561          hi = hi + Math.imul(ah3, bh9) | 0;
40562          var w12 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40563          c = (hi + (mid >>> 13) | 0) + (w12 >>> 26) | 0;
40564          w12 &= 67108863;
40565          lo = Math.imul(al9, bl4);
40566          mid = Math.imul(al9, bh4);
40567          mid = mid + Math.imul(ah9, bl4) | 0;
40568          hi = Math.imul(ah9, bh4);
40569          lo = lo + Math.imul(al8, bl5) | 0;
40570          mid = mid + Math.imul(al8, bh5) | 0;
40571          mid = mid + Math.imul(ah8, bl5) | 0;
40572          hi = hi + Math.imul(ah8, bh5) | 0;
40573          lo = lo + Math.imul(al7, bl6) | 0;
40574          mid = mid + Math.imul(al7, bh6) | 0;
40575          mid = mid + Math.imul(ah7, bl6) | 0;
40576          hi = hi + Math.imul(ah7, bh6) | 0;
40577          lo = lo + Math.imul(al6, bl7) | 0;
40578          mid = mid + Math.imul(al6, bh7) | 0;
40579          mid = mid + Math.imul(ah6, bl7) | 0;
40580          hi = hi + Math.imul(ah6, bh7) | 0;
40581          lo = lo + Math.imul(al5, bl8) | 0;
40582          mid = mid + Math.imul(al5, bh8) | 0;
40583          mid = mid + Math.imul(ah5, bl8) | 0;
40584          hi = hi + Math.imul(ah5, bh8) | 0;
40585          lo = lo + Math.imul(al4, bl9) | 0;
40586          mid = mid + Math.imul(al4, bh9) | 0;
40587          mid = mid + Math.imul(ah4, bl9) | 0;
40588          hi = hi + Math.imul(ah4, bh9) | 0;
40589          var w13 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40590          c = (hi + (mid >>> 13) | 0) + (w13 >>> 26) | 0;
40591          w13 &= 67108863;
40592          lo = Math.imul(al9, bl5);
40593          mid = Math.imul(al9, bh5);
40594          mid = mid + Math.imul(ah9, bl5) | 0;
40595          hi = Math.imul(ah9, bh5);
40596          lo = lo + Math.imul(al8, bl6) | 0;
40597          mid = mid + Math.imul(al8, bh6) | 0;
40598          mid = mid + Math.imul(ah8, bl6) | 0;
40599          hi = hi + Math.imul(ah8, bh6) | 0;
40600          lo = lo + Math.imul(al7, bl7) | 0;
40601          mid = mid + Math.imul(al7, bh7) | 0;
40602          mid = mid + Math.imul(ah7, bl7) | 0;
40603          hi = hi + Math.imul(ah7, bh7) | 0;
40604          lo = lo + Math.imul(al6, bl8) | 0;
40605          mid = mid + Math.imul(al6, bh8) | 0;
40606          mid = mid + Math.imul(ah6, bl8) | 0;
40607          hi = hi + Math.imul(ah6, bh8) | 0;
40608          lo = lo + Math.imul(al5, bl9) | 0;
40609          mid = mid + Math.imul(al5, bh9) | 0;
40610          mid = mid + Math.imul(ah5, bl9) | 0;
40611          hi = hi + Math.imul(ah5, bh9) | 0;
40612          var w14 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40613          c = (hi + (mid >>> 13) | 0) + (w14 >>> 26) | 0;
40614          w14 &= 67108863;
40615          lo = Math.imul(al9, bl6);
40616          mid = Math.imul(al9, bh6);
40617          mid = mid + Math.imul(ah9, bl6) | 0;
40618          hi = Math.imul(ah9, bh6);
40619          lo = lo + Math.imul(al8, bl7) | 0;
40620          mid = mid + Math.imul(al8, bh7) | 0;
40621          mid = mid + Math.imul(ah8, bl7) | 0;
40622          hi = hi + Math.imul(ah8, bh7) | 0;
40623          lo = lo + Math.imul(al7, bl8) | 0;
40624          mid = mid + Math.imul(al7, bh8) | 0;
40625          mid = mid + Math.imul(ah7, bl8) | 0;
40626          hi = hi + Math.imul(ah7, bh8) | 0;
40627          lo = lo + Math.imul(al6, bl9) | 0;
40628          mid = mid + Math.imul(al6, bh9) | 0;
40629          mid = mid + Math.imul(ah6, bl9) | 0;
40630          hi = hi + Math.imul(ah6, bh9) | 0;
40631          var w15 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40632          c = (hi + (mid >>> 13) | 0) + (w15 >>> 26) | 0;
40633          w15 &= 67108863;
40634          lo = Math.imul(al9, bl7);
40635          mid = Math.imul(al9, bh7);
40636          mid = mid + Math.imul(ah9, bl7) | 0;
40637          hi = Math.imul(ah9, bh7);
40638          lo = lo + Math.imul(al8, bl8) | 0;
40639          mid = mid + Math.imul(al8, bh8) | 0;
40640          mid = mid + Math.imul(ah8, bl8) | 0;
40641          hi = hi + Math.imul(ah8, bh8) | 0;
40642          lo = lo + Math.imul(al7, bl9) | 0;
40643          mid = mid + Math.imul(al7, bh9) | 0;
40644          mid = mid + Math.imul(ah7, bl9) | 0;
40645          hi = hi + Math.imul(ah7, bh9) | 0;
40646          var w16 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40647          c = (hi + (mid >>> 13) | 0) + (w16 >>> 26) | 0;
40648          w16 &= 67108863;
40649          lo = Math.imul(al9, bl8);
40650          mid = Math.imul(al9, bh8);
40651          mid = mid + Math.imul(ah9, bl8) | 0;
40652          hi = Math.imul(ah9, bh8);
40653          lo = lo + Math.imul(al8, bl9) | 0;
40654          mid = mid + Math.imul(al8, bh9) | 0;
40655          mid = mid + Math.imul(ah8, bl9) | 0;
40656          hi = hi + Math.imul(ah8, bh9) | 0;
40657          var w17 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40658          c = (hi + (mid >>> 13) | 0) + (w17 >>> 26) | 0;
40659          w17 &= 67108863;
40660          lo = Math.imul(al9, bl9);
40661          mid = Math.imul(al9, bh9);
40662          mid = mid + Math.imul(ah9, bl9) | 0;
40663          hi = Math.imul(ah9, bh9);
40664          var w18 = (c + lo | 0) + ((mid & 8191) << 13) | 0;
40665          c = (hi + (mid >>> 13) | 0) + (w18 >>> 26) | 0;
40666          w18 &= 67108863;
40667          o[0] = w0;
40668          o[1] = w1;
40669          o[2] = w2;
40670          o[3] = w3;
40671          o[4] = w4;
40672          o[5] = w5;
40673          o[6] = w6;
40674          o[7] = w7;
40675          o[8] = w8;
40676          o[9] = w9;
40677          o[10] = w10;
40678          o[11] = w11;
40679          o[12] = w12;
40680          o[13] = w13;
40681          o[14] = w14;
40682          o[15] = w15;
40683          o[16] = w16;
40684          o[17] = w17;
40685          o[18] = w18;
40686          if (c !== 0) {
40687            o[19] = c;
40688            out.length++;
40689          }
40690          return out;
40691        };
40692        if (!Math.imul) {
40693          comb10MulTo = smallMulTo;
40694        }
40695        function bigMulTo(self2, num, out) {
40696          out.negative = num.negative ^ self2.negative;
40697          out.length = self2.length + num.length;
40698          var carry = 0;
40699          var hncarry = 0;
40700          for (var k = 0; k < out.length - 1; k++) {
40701            var ncarry = hncarry;
40702            hncarry = 0;
40703            var rword = carry & 67108863;
40704            var maxJ = Math.min(k, num.length - 1);
40705            for (var j = Math.max(0, k - self2.length + 1); j <= maxJ; j++) {
40706              var i2 = k - j;
40707              var a = self2.words[i2] | 0;
40708              var b = num.words[j] | 0;
40709              var r = a * b;
40710              var lo = r & 67108863;
40711              ncarry = ncarry + (r / 67108864 | 0) | 0;
40712              lo = lo + rword | 0;
40713              rword = lo & 67108863;
40714              ncarry = ncarry + (lo >>> 26) | 0;
40715              hncarry += ncarry >>> 26;
40716              ncarry &= 67108863;
40717            }
40718            out.words[k] = rword;
40719            carry = ncarry;
40720            ncarry = hncarry;
40721          }
40722          if (carry !== 0) {
40723            out.words[k] = carry;
40724          } else {
40725            out.length--;
40726          }
40727          return out._strip();
40728        }
40729        function jumboMulTo(self2, num, out) {
40730          return bigMulTo(self2, num, out);
40731        }
40732        BN.prototype.mulTo = function mulTo(num, out) {
40733          var res;
40734          var len2 = this.length + num.length;
40735          if (this.length === 10 && num.length === 10) {
40736            res = comb10MulTo(this, num, out);
40737          } else if (len2 < 63) {
40738            res = smallMulTo(this, num, out);
40739          } else if (len2 < 1024) {
40740            res = bigMulTo(this, num, out);
40741          } else {
40742            res = jumboMulTo(this, num, out);
40743          }
40744          return res;
40745        };
40746        BN.prototype.mul = function mul(num) {
40747          var out = new BN(null);
40748          out.words = new Array(this.length + num.length);
40749          return this.mulTo(num, out);
40750        };
40751        BN.prototype.mulf = function mulf(num) {
40752          var out = new BN(null);
40753          out.words = new Array(this.length + num.length);
40754          return jumboMulTo(this, num, out);
40755        };
40756        BN.prototype.imul = function imul(num) {
40757          return this.clone().mulTo(num, this);
40758        };
40759        BN.prototype.imuln = function imuln(num) {
40760          var isNegNum = num < 0;
40761          if (isNegNum) num = -num;
40762          assert2(typeof num === "number");
40763          assert2(num < 67108864);
40764          var carry = 0;
40765          for (var i2 = 0; i2 < this.length; i2++) {
40766            var w = (this.words[i2] | 0) * num;
40767            var lo = (w & 67108863) + (carry & 67108863);
40768            carry >>= 26;
40769            carry += w / 67108864 | 0;
40770            carry += lo >>> 26;
40771            this.words[i2] = lo & 67108863;
40772          }
40773          if (carry !== 0) {
40774            this.words[i2] = carry;
40775            this.length++;
40776          }
40777          this.length = num === 0 ? 1 : this.length;
40778          return isNegNum ? this.ineg() : this;
40779        };
40780        BN.prototype.muln = function muln(num) {
40781          return this.clone().imuln(num);
40782        };
40783        BN.prototype.sqr = function sqr() {
40784          return this.mul(this);
40785        };
40786        BN.prototype.isqr = function isqr() {
40787          return this.imul(this.clone());
40788        };
40789        BN.prototype.pow = function pow2(num) {
40790          var w = toBitArray(num);
40791          if (w.length === 0) return new BN(1);
40792          var res = this;
40793          for (var i2 = 0; i2 < w.length; i2++, res = res.sqr()) {
40794            if (w[i2] !== 0) break;
40795          }
40796          if (++i2 < w.length) {
40797            for (var q = res.sqr(); i2 < w.length; i2++, q = q.sqr()) {
40798              if (w[i2] === 0) continue;
40799              res = res.mul(q);
40800            }
40801          }
40802          return res;
40803        };
40804        BN.prototype.iushln = function iushln(bits) {
40805          assert2(typeof bits === "number" && bits >= 0);
40806          var r = bits % 26;
40807          var s = (bits - r) / 26;
40808          var carryMask = 67108863 >>> 26 - r << 26 - r;
40809          var i2;
40810          if (r !== 0) {
40811            var carry = 0;
40812            for (i2 = 0; i2 < this.length; i2++) {
40813              var newCarry = this.words[i2] & carryMask;
40814              var c = (this.words[i2] | 0) - newCarry << r;
40815              this.words[i2] = c | carry;
40816              carry = newCarry >>> 26 - r;
40817            }
40818            if (carry) {
40819              this.words[i2] = carry;
40820              this.length++;
40821            }
40822          }
40823          if (s !== 0) {
40824            for (i2 = this.length - 1; i2 >= 0; i2--) {
40825              this.words[i2 + s] = this.words[i2];
40826            }
40827            for (i2 = 0; i2 < s; i2++) {
40828              this.words[i2] = 0;
40829            }
40830            this.length += s;
40831          }
40832          return this._strip();
40833        };
40834        BN.prototype.ishln = function ishln(bits) {
40835          assert2(this.negative === 0);
40836          return this.iushln(bits);
40837        };
40838        BN.prototype.iushrn = function iushrn(bits, hint, extended) {
40839          assert2(typeof bits === "number" && bits >= 0);
40840          var h;
40841          if (hint) {
40842            h = (hint - hint % 26) / 26;
40843          } else {
40844            h = 0;
40845          }
40846          var r = bits % 26;
40847          var s = Math.min((bits - r) / 26, this.length);
40848          var mask = 67108863 ^ 67108863 >>> r << r;
40849          var maskedWords = extended;
40850          h -= s;
40851          h = Math.max(0, h);
40852          if (maskedWords) {
40853            for (var i2 = 0; i2 < s; i2++) {
40854              maskedWords.words[i2] = this.words[i2];
40855            }
40856            maskedWords.length = s;
40857          }
40858          if (s === 0) ;
40859          else if (this.length > s) {
40860            this.length -= s;
40861            for (i2 = 0; i2 < this.length; i2++) {
40862              this.words[i2] = this.words[i2 + s];
40863            }
40864          } else {
40865            this.words[0] = 0;
40866            this.length = 1;
40867          }
40868          var carry = 0;
40869          for (i2 = this.length - 1; i2 >= 0 && (carry !== 0 || i2 >= h); i2--) {
40870            var word = this.words[i2] | 0;
40871            this.words[i2] = carry << 26 - r | word >>> r;
40872            carry = word & mask;
40873          }
40874          if (maskedWords && carry !== 0) {
40875            maskedWords.words[maskedWords.length++] = carry;
40876          }
40877          if (this.length === 0) {
40878            this.words[0] = 0;
40879            this.length = 1;
40880          }
40881          return this._strip();
40882        };
40883        BN.prototype.ishrn = function ishrn(bits, hint, extended) {
40884          assert2(this.negative === 0);
40885          return this.iushrn(bits, hint, extended);
40886        };
40887        BN.prototype.shln = function shln(bits) {
40888          return this.clone().ishln(bits);
40889        };
40890        BN.prototype.ushln = function ushln(bits) {
40891          return this.clone().iushln(bits);
40892        };
40893        BN.prototype.shrn = function shrn(bits) {
40894          return this.clone().ishrn(bits);
40895        };
40896        BN.prototype.ushrn = function ushrn(bits) {
40897          return this.clone().iushrn(bits);
40898        };
40899        BN.prototype.testn = function testn(bit) {
40900          assert2(typeof bit === "number" && bit >= 0);
40901          var r = bit % 26;
40902          var s = (bit - r) / 26;
40903          var q = 1 << r;
40904          if (this.length <= s) return false;
40905          var w = this.words[s];
40906          return !!(w & q);
40907        };
40908        BN.prototype.imaskn = function imaskn(bits) {
40909          assert2(typeof bits === "number" && bits >= 0);
40910          var r = bits % 26;
40911          var s = (bits - r) / 26;
40912          assert2(this.negative === 0, "imaskn works only with positive numbers");
40913          if (this.length <= s) {
40914            return this;
40915          }
40916          if (r !== 0) {
40917            s++;
40918          }
40919          this.length = Math.min(s, this.length);
40920          if (r !== 0) {
40921            var mask = 67108863 ^ 67108863 >>> r << r;
40922            this.words[this.length - 1] &= mask;
40923          }
40924          if (this.length === 0) {
40925            this.words[0] = 0;
40926            this.length = 1;
40927          }
40928          return this._strip();
40929        };
40930        BN.prototype.maskn = function maskn(bits) {
40931          return this.clone().imaskn(bits);
40932        };
40933        BN.prototype.iaddn = function iaddn(num) {
40934          assert2(typeof num === "number");
40935          assert2(num < 67108864);
40936          if (num < 0) return this.isubn(-num);
40937          if (this.negative !== 0) {
40938            if (this.length === 1 && (this.words[0] | 0) <= num) {
40939              this.words[0] = num - (this.words[0] | 0);
40940              this.negative = 0;
40941              return this;
40942            }
40943            this.negative = 0;
40944            this.isubn(num);
40945            this.negative = 1;
40946            return this;
40947          }
40948          return this._iaddn(num);
40949        };
40950        BN.prototype._iaddn = function _iaddn(num) {
40951          this.words[0] += num;
40952          for (var i2 = 0; i2 < this.length && this.words[i2] >= 67108864; i2++) {
40953            this.words[i2] -= 67108864;
40954            if (i2 === this.length - 1) {
40955              this.words[i2 + 1] = 1;
40956            } else {
40957              this.words[i2 + 1]++;
40958            }
40959          }
40960          this.length = Math.max(this.length, i2 + 1);
40961          return this;
40962        };
40963        BN.prototype.isubn = function isubn(num) {
40964          assert2(typeof num === "number");
40965          assert2(num < 67108864);
40966          if (num < 0) return this.iaddn(-num);
40967          if (this.negative !== 0) {
40968            this.negative = 0;
40969            this.iaddn(num);
40970            this.negative = 1;
40971            return this;
40972          }
40973          this.words[0] -= num;
40974          if (this.length === 1 && this.words[0] < 0) {
40975            this.words[0] = -this.words[0];
40976            this.negative = 1;
40977          } else {
40978            for (var i2 = 0; i2 < this.length && this.words[i2] < 0; i2++) {
40979              this.words[i2] += 67108864;
40980              this.words[i2 + 1] -= 1;
40981            }
40982          }
40983          return this._strip();
40984        };
40985        BN.prototype.addn = function addn(num) {
40986          return this.clone().iaddn(num);
40987        };
40988        BN.prototype.subn = function subn(num) {
40989          return this.clone().isubn(num);
40990        };
40991        BN.prototype.iabs = function iabs() {
40992          this.negative = 0;
40993          return this;
40994        };
40995        BN.prototype.abs = function abs2() {
40996          return this.clone().iabs();
40997        };
40998        BN.prototype._ishlnsubmul = function _ishlnsubmul(num, mul, shift) {
40999          var len2 = num.length + shift;
41000          var i2;
41001          this._expand(len2);
41002          var w;
41003          var carry = 0;
41004          for (i2 = 0; i2 < num.length; i2++) {
41005            w = (this.words[i2 + shift] | 0) + carry;
41006            var right = (num.words[i2] | 0) * mul;
41007            w -= right & 67108863;
41008            carry = (w >> 26) - (right / 67108864 | 0);
41009            this.words[i2 + shift] = w & 67108863;
41010          }
41011          for (; i2 < this.length - shift; i2++) {
41012            w = (this.words[i2 + shift] | 0) + carry;
41013            carry = w >> 26;
41014            this.words[i2 + shift] = w & 67108863;
41015          }
41016          if (carry === 0) return this._strip();
41017          assert2(carry === -1);
41018          carry = 0;
41019          for (i2 = 0; i2 < this.length; i2++) {
41020            w = -(this.words[i2] | 0) + carry;
41021            carry = w >> 26;
41022            this.words[i2] = w & 67108863;
41023          }
41024          this.negative = 1;
41025          return this._strip();
41026        };
41027        BN.prototype._wordDiv = function _wordDiv(num, mode) {
41028          var shift = this.length - num.length;
41029          var a = this.clone();
41030          var b = num;
41031          var bhi = b.words[b.length - 1] | 0;
41032          var bhiBits = this._countBits(bhi);
41033          shift = 26 - bhiBits;
41034          if (shift !== 0) {

vendor: 27,865 bytes, lines 41035-41899

41035            b = b.ushln(shift);
41036            a.iushln(shift);
41037            bhi = b.words[b.length - 1] | 0;
41038          }
41039          var m = a.length - b.length;
41040          var q;
41041          if (mode !== "mod") {
41042            q = new BN(null);
41043            q.length = m + 1;
41044            q.words = new Array(q.length);
41045            for (var i2 = 0; i2 < q.length; i2++) {
41046              q.words[i2] = 0;
41047            }
41048          }
41049          var diff = a.clone()._ishlnsubmul(b, 1, m);
41050          if (diff.negative === 0) {
41051            a = diff;
41052            if (q) {
41053              q.words[m] = 1;
41054            }
41055          }
41056          for (var j = m - 1; j >= 0; j--) {
41057            var qj = (a.words[b.length + j] | 0) * 67108864 + (a.words[b.length + j - 1] | 0);
41058            qj = Math.min(qj / bhi | 0, 67108863);
41059            a._ishlnsubmul(b, qj, j);
41060            while (a.negative !== 0) {
41061              qj--;
41062              a.negative = 0;
41063              a._ishlnsubmul(b, 1, j);
41064              if (!a.isZero()) {
41065                a.negative ^= 1;
41066              }
41067            }
41068            if (q) {
41069              q.words[j] = qj;
41070            }
41071          }
41072          if (q) {
41073            q._strip();
41074          }
41075          a._strip();
41076          if (mode !== "div" && shift !== 0) {
41077            a.iushrn(shift);
41078          }
41079          return {
41080            div: q || null,
41081            mod: a
41082          };
41083        };
41084        BN.prototype.divmod = function divmod(num, mode, positive) {
41085          assert2(!num.isZero());
41086          if (this.isZero()) {
41087            return {
41088              div: new BN(0),
41089              mod: new BN(0)
41090            };
41091          }
41092          var div, mod, res;
41093          if (this.negative !== 0 && num.negative === 0) {
41094            res = this.neg().divmod(num, mode);
41095            if (mode !== "mod") {
41096              div = res.div.neg();
41097            }
41098            if (mode !== "div") {
41099              mod = res.mod.neg();
41100              if (positive && mod.negative !== 0) {
41101                mod.iadd(num);
41102              }
41103            }
41104            return {
41105              div,
41106              mod
41107            };
41108          }
41109          if (this.negative === 0 && num.negative !== 0) {
41110            res = this.divmod(num.neg(), mode);
41111            if (mode !== "mod") {
41112              div = res.div.neg();
41113            }
41114            return {
41115              div,
41116              mod: res.mod
41117            };
41118          }
41119          if ((this.negative & num.negative) !== 0) {
41120            res = this.neg().divmod(num.neg(), mode);
41121            if (mode !== "div") {
41122              mod = res.mod.neg();
41123              if (positive && mod.negative !== 0) {
41124                mod.isub(num);
41125              }
41126            }
41127            return {
41128              div: res.div,
41129              mod
41130            };
41131          }
41132          if (num.length > this.length || this.cmp(num) < 0) {
41133            return {
41134              div: new BN(0),
41135              mod: this
41136            };
41137          }
41138          if (num.length === 1) {
41139            if (mode === "div") {
41140              return {
41141                div: this.divn(num.words[0]),
41142                mod: null
41143              };
41144            }
41145            if (mode === "mod") {
41146              return {
41147                div: null,
41148                mod: new BN(this.modrn(num.words[0]))
41149              };
41150            }
41151            return {
41152              div: this.divn(num.words[0]),
41153              mod: new BN(this.modrn(num.words[0]))
41154            };
41155          }
41156          return this._wordDiv(num, mode);
41157        };
41158        BN.prototype.div = function div(num) {
41159          return this.divmod(num, "div", false).div;
41160        };
41161        BN.prototype.mod = function mod(num) {
41162          return this.divmod(num, "mod", false).mod;
41163        };
41164        BN.prototype.umod = function umod(num) {
41165          return this.divmod(num, "mod", true).mod;
41166        };
41167        BN.prototype.divRound = function divRound(num) {
41168          var dm = this.divmod(num);
41169          if (dm.mod.isZero()) return dm.div;
41170          var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;
41171          var half = num.ushrn(1);
41172          var r2 = num.andln(1);
41173          var cmp = mod.cmp(half);
41174          if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
41175          return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
41176        };
41177        BN.prototype.modrn = function modrn(num) {
41178          var isNegNum = num < 0;
41179          if (isNegNum) num = -num;
41180          assert2(num <= 67108863);
41181          var p = (1 << 26) % num;
41182          var acc = 0;
41183          for (var i2 = this.length - 1; i2 >= 0; i2--) {
41184            acc = (p * acc + (this.words[i2] | 0)) % num;
41185          }
41186          return isNegNum ? -acc : acc;
41187        };
41188        BN.prototype.modn = function modn(num) {
41189          return this.modrn(num);
41190        };
41191        BN.prototype.idivn = function idivn(num) {
41192          var isNegNum = num < 0;
41193          if (isNegNum) num = -num;
41194          assert2(num <= 67108863);
41195          var carry = 0;
41196          for (var i2 = this.length - 1; i2 >= 0; i2--) {
41197            var w = (this.words[i2] | 0) + carry * 67108864;
41198            this.words[i2] = w / num | 0;
41199            carry = w % num;
41200          }
41201          this._strip();
41202          return isNegNum ? this.ineg() : this;
41203        };
41204        BN.prototype.divn = function divn(num) {
41205          return this.clone().idivn(num);
41206        };
41207        BN.prototype.egcd = function egcd(p) {
41208          assert2(p.negative === 0);
41209          assert2(!p.isZero());
41210          var x = this;
41211          var y = p.clone();
41212          if (x.negative !== 0) {
41213            x = x.umod(p);
41214          } else {
41215            x = x.clone();
41216          }
41217          var A = new BN(1);
41218          var B = new BN(0);
41219          var C = new BN(0);
41220          var D = new BN(1);
41221          var g = 0;
41222          while (x.isEven() && y.isEven()) {
41223            x.iushrn(1);
41224            y.iushrn(1);
41225            ++g;
41226          }
41227          var yp = y.clone();
41228          var xp = x.clone();
41229          while (!x.isZero()) {
41230            for (var i2 = 0, im = 1; (x.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
41231            if (i2 > 0) {
41232              x.iushrn(i2);
41233              while (i2-- > 0) {
41234                if (A.isOdd() || B.isOdd()) {
41235                  A.iadd(yp);
41236                  B.isub(xp);
41237                }
41238                A.iushrn(1);
41239                B.iushrn(1);
41240              }
41241            }
41242            for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
41243            if (j > 0) {
41244              y.iushrn(j);
41245              while (j-- > 0) {
41246                if (C.isOdd() || D.isOdd()) {
41247                  C.iadd(yp);
41248                  D.isub(xp);
41249                }
41250                C.iushrn(1);
41251                D.iushrn(1);
41252              }
41253            }
41254            if (x.cmp(y) >= 0) {
41255              x.isub(y);
41256              A.isub(C);
41257              B.isub(D);
41258            } else {
41259              y.isub(x);
41260              C.isub(A);
41261              D.isub(B);
41262            }
41263          }
41264          return {
41265            a: C,
41266            b: D,
41267            gcd: y.iushln(g)
41268          };
41269        };
41270        BN.prototype._invmp = function _invmp(p) {
41271          assert2(p.negative === 0);
41272          assert2(!p.isZero());
41273          var a = this;
41274          var b = p.clone();
41275          if (a.negative !== 0) {
41276            a = a.umod(p);
41277          } else {
41278            a = a.clone();
41279          }
41280          var x1 = new BN(1);
41281          var x2 = new BN(0);
41282          var delta = b.clone();
41283          while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {
41284            for (var i2 = 0, im = 1; (a.words[0] & im) === 0 && i2 < 26; ++i2, im <<= 1) ;
41285            if (i2 > 0) {
41286              a.iushrn(i2);
41287              while (i2-- > 0) {
41288                if (x1.isOdd()) {
41289                  x1.iadd(delta);
41290                }
41291                x1.iushrn(1);
41292              }
41293            }
41294            for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1) ;
41295            if (j > 0) {
41296              b.iushrn(j);
41297              while (j-- > 0) {
41298                if (x2.isOdd()) {
41299                  x2.iadd(delta);
41300                }
41301                x2.iushrn(1);
41302              }
41303            }
41304            if (a.cmp(b) >= 0) {
41305              a.isub(b);
41306              x1.isub(x2);
41307            } else {
41308              b.isub(a);
41309              x2.isub(x1);
41310            }
41311          }
41312          var res;
41313          if (a.cmpn(1) === 0) {
41314            res = x1;
41315          } else {
41316            res = x2;
41317          }
41318          if (res.cmpn(0) < 0) {
41319            res.iadd(p);
41320          }
41321          return res;
41322        };
41323        BN.prototype.gcd = function gcd(num) {
41324          if (this.isZero()) return num.abs();
41325          if (num.isZero()) return this.abs();
41326          var a = this.clone();
41327          var b = num.clone();
41328          a.negative = 0;
41329          b.negative = 0;
41330          for (var shift = 0; a.isEven() && b.isEven(); shift++) {
41331            a.iushrn(1);
41332            b.iushrn(1);
41333          }
41334          do {
41335            while (a.isEven()) {
41336              a.iushrn(1);
41337            }
41338            while (b.isEven()) {
41339              b.iushrn(1);
41340            }
41341            var r = a.cmp(b);
41342            if (r < 0) {
41343              var t = a;
41344              a = b;
41345              b = t;
41346            } else if (r === 0 || b.cmpn(1) === 0) {
41347              break;
41348            }
41349            a.isub(b);
41350          } while (true);
41351          return b.iushln(shift);
41352        };
41353        BN.prototype.invm = function invm(num) {
41354          return this.egcd(num).a.umod(num);
41355        };
41356        BN.prototype.isEven = function isEven() {
41357          return (this.words[0] & 1) === 0;
41358        };
41359        BN.prototype.isOdd = function isOdd() {
41360          return (this.words[0] & 1) === 1;
41361        };
41362        BN.prototype.andln = function andln(num) {
41363          return this.words[0] & num;
41364        };
41365        BN.prototype.bincn = function bincn(bit) {
41366          assert2(typeof bit === "number");
41367          var r = bit % 26;
41368          var s = (bit - r) / 26;
41369          var q = 1 << r;
41370          if (this.length <= s) {
41371            this._expand(s + 1);
41372            this.words[s] |= q;
41373            return this;
41374          }
41375          var carry = q;
41376          for (var i2 = s; carry !== 0 && i2 < this.length; i2++) {
41377            var w = this.words[i2] | 0;
41378            w += carry;
41379            carry = w >>> 26;
41380            w &= 67108863;
41381            this.words[i2] = w;
41382          }
41383          if (carry !== 0) {
41384            this.words[i2] = carry;
41385            this.length++;
41386          }
41387          return this;
41388        };
41389        BN.prototype.isZero = function isZero() {
41390          return this.length === 1 && this.words[0] === 0;
41391        };
41392        BN.prototype.cmpn = function cmpn(num) {
41393          var negative = num < 0;
41394          if (this.negative !== 0 && !negative) return -1;
41395          if (this.negative === 0 && negative) return 1;
41396          this._strip();
41397          var res;
41398          if (this.length > 1) {
41399            res = 1;
41400          } else {
41401            if (negative) {
41402              num = -num;
41403            }
41404            assert2(num <= 67108863, "Number is too big");
41405            var w = this.words[0] | 0;
41406            res = w === num ? 0 : w < num ? -1 : 1;
41407          }
41408          if (this.negative !== 0) return -res | 0;
41409          return res;
41410        };
41411        BN.prototype.cmp = function cmp(num) {
41412          if (this.negative !== 0 && num.negative === 0) return -1;
41413          if (this.negative === 0 && num.negative !== 0) return 1;
41414          var res = this.ucmp(num);
41415          if (this.negative !== 0) return -res | 0;
41416          return res;
41417        };
41418        BN.prototype.ucmp = function ucmp(num) {
41419          if (this.length > num.length) return 1;
41420          if (this.length < num.length) return -1;
41421          var res = 0;
41422          for (var i2 = this.length - 1; i2 >= 0; i2--) {
41423            var a = this.words[i2] | 0;
41424            var b = num.words[i2] | 0;
41425            if (a === b) continue;
41426            if (a < b) {
41427              res = -1;
41428            } else if (a > b) {
41429              res = 1;
41430            }
41431            break;
41432          }
41433          return res;
41434        };
41435        BN.prototype.gtn = function gtn(num) {
41436          return this.cmpn(num) === 1;
41437        };
41438        BN.prototype.gt = function gt(num) {
41439          return this.cmp(num) === 1;
41440        };
41441        BN.prototype.gten = function gten(num) {
41442          return this.cmpn(num) >= 0;
41443        };
41444        BN.prototype.gte = function gte(num) {
41445          return this.cmp(num) >= 0;
41446        };
41447        BN.prototype.ltn = function ltn(num) {
41448          return this.cmpn(num) === -1;
41449        };
41450        BN.prototype.lt = function lt(num) {
41451          return this.cmp(num) === -1;
41452        };
41453        BN.prototype.lten = function lten(num) {
41454          return this.cmpn(num) <= 0;
41455        };
41456        BN.prototype.lte = function lte(num) {
41457          return this.cmp(num) <= 0;
41458        };
41459        BN.prototype.eqn = function eqn(num) {
41460          return this.cmpn(num) === 0;
41461        };
41462        BN.prototype.eq = function eq(num) {
41463          return this.cmp(num) === 0;
41464        };
41465        BN.red = function red(num) {
41466          return new Red(num);
41467        };
41468        BN.prototype.toRed = function toRed(ctx) {
41469          assert2(!this.red, "Already a number in reduction context");
41470          assert2(this.negative === 0, "red works only with positives");
41471          return ctx.convertTo(this)._forceRed(ctx);
41472        };
41473        BN.prototype.fromRed = function fromRed() {
41474          assert2(this.red, "fromRed works only with numbers in reduction context");
41475          return this.red.convertFrom(this);
41476        };
41477        BN.prototype._forceRed = function _forceRed(ctx) {
41478          this.red = ctx;
41479          return this;
41480        };
41481        BN.prototype.forceRed = function forceRed(ctx) {
41482          assert2(!this.red, "Already a number in reduction context");
41483          return this._forceRed(ctx);
41484        };
41485        BN.prototype.redAdd = function redAdd(num) {
41486          assert2(this.red, "redAdd works only with red numbers");
41487          return this.red.add(this, num);
41488        };
41489        BN.prototype.redIAdd = function redIAdd(num) {
41490          assert2(this.red, "redIAdd works only with red numbers");
41491          return this.red.iadd(this, num);
41492        };
41493        BN.prototype.redSub = function redSub(num) {
41494          assert2(this.red, "redSub works only with red numbers");
41495          return this.red.sub(this, num);
41496        };
41497        BN.prototype.redISub = function redISub(num) {
41498          assert2(this.red, "redISub works only with red numbers");
41499          return this.red.isub(this, num);
41500        };
41501        BN.prototype.redShl = function redShl(num) {
41502          assert2(this.red, "redShl works only with red numbers");
41503          return this.red.shl(this, num);
41504        };
41505        BN.prototype.redMul = function redMul(num) {
41506          assert2(this.red, "redMul works only with red numbers");
41507          this.red._verify2(this, num);
41508          return this.red.mul(this, num);
41509        };
41510        BN.prototype.redIMul = function redIMul(num) {
41511          assert2(this.red, "redMul works only with red numbers");
41512          this.red._verify2(this, num);
41513          return this.red.imul(this, num);
41514        };
41515        BN.prototype.redSqr = function redSqr() {
41516          assert2(this.red, "redSqr works only with red numbers");
41517          this.red._verify1(this);
41518          return this.red.sqr(this);
41519        };
41520        BN.prototype.redISqr = function redISqr() {
41521          assert2(this.red, "redISqr works only with red numbers");
41522          this.red._verify1(this);
41523          return this.red.isqr(this);
41524        };
41525        BN.prototype.redSqrt = function redSqrt() {
41526          assert2(this.red, "redSqrt works only with red numbers");
41527          this.red._verify1(this);
41528          return this.red.sqrt(this);
41529        };
41530        BN.prototype.redInvm = function redInvm() {
41531          assert2(this.red, "redInvm works only with red numbers");
41532          this.red._verify1(this);
41533          return this.red.invm(this);
41534        };
41535        BN.prototype.redNeg = function redNeg() {
41536          assert2(this.red, "redNeg works only with red numbers");
41537          this.red._verify1(this);
41538          return this.red.neg(this);
41539        };
41540        BN.prototype.redPow = function redPow(num) {
41541          assert2(this.red && !num.red, "redPow(normalNum)");
41542          this.red._verify1(this);
41543          return this.red.pow(this, num);
41544        };
41545        var primes = {
41546          k256: null,
41547          p224: null,
41548          p192: null,
41549          p25519: null
41550        };
41551        function MPrime(name, p) {
41552          this.name = name;
41553          this.p = new BN(p, 16);
41554          this.n = this.p.bitLength();
41555          this.k = new BN(1).iushln(this.n).isub(this.p);
41556          this.tmp = this._tmp();
41557        }
41558        MPrime.prototype._tmp = function _tmp() {
41559          var tmp = new BN(null);
41560          tmp.words = new Array(Math.ceil(this.n / 13));
41561          return tmp;
41562        };
41563        MPrime.prototype.ireduce = function ireduce(num) {
41564          var r = num;
41565          var rlen;
41566          do {
41567            this.split(r, this.tmp);
41568            r = this.imulK(r);
41569            r = r.iadd(this.tmp);
41570            rlen = r.bitLength();
41571          } while (rlen > this.n);
41572          var cmp = rlen < this.n ? -1 : r.ucmp(this.p);
41573          if (cmp === 0) {
41574            r.words[0] = 0;
41575            r.length = 1;
41576          } else if (cmp > 0) {
41577            r.isub(this.p);
41578          } else {
41579            if (r.strip !== void 0) {
41580              r.strip();
41581            } else {
41582              r._strip();
41583            }
41584          }
41585          return r;
41586        };
41587        MPrime.prototype.split = function split(input, out) {
41588          input.iushrn(this.n, 0, out);
41589        };
41590        MPrime.prototype.imulK = function imulK(num) {
41591          return num.imul(this.k);
41592        };
41593        function K256() {
41594          MPrime.call(
41595            this,
41596            "k256",
41597            "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f"
41598          );
41599        }
41600        inherits2(K256, MPrime);
41601        K256.prototype.split = function split(input, output) {
41602          var mask = 4194303;
41603          var outLen = Math.min(input.length, 9);
41604          for (var i2 = 0; i2 < outLen; i2++) {
41605            output.words[i2] = input.words[i2];
41606          }
41607          output.length = outLen;
41608          if (input.length <= 9) {
41609            input.words[0] = 0;
41610            input.length = 1;
41611            return;
41612          }
41613          var prev = input.words[9];
41614          output.words[output.length++] = prev & mask;
41615          for (i2 = 10; i2 < input.length; i2++) {
41616            var next = input.words[i2] | 0;
41617            input.words[i2 - 10] = (next & mask) << 4 | prev >>> 22;
41618            prev = next;
41619          }
41620          prev >>>= 22;
41621          input.words[i2 - 10] = prev;
41622          if (prev === 0 && input.length > 10) {
41623            input.length -= 10;
41624          } else {
41625            input.length -= 9;
41626          }
41627        };
41628        K256.prototype.imulK = function imulK(num) {
41629          num.words[num.length] = 0;
41630          num.words[num.length + 1] = 0;
41631          num.length += 2;
41632          var lo = 0;
41633          for (var i2 = 0; i2 < num.length; i2++) {
41634            var w = num.words[i2] | 0;
41635            lo += w * 977;
41636            num.words[i2] = lo & 67108863;
41637            lo = w * 64 + (lo / 67108864 | 0);
41638          }
41639          if (num.words[num.length - 1] === 0) {
41640            num.length--;
41641            if (num.words[num.length - 1] === 0) {
41642              num.length--;
41643            }
41644          }
41645          return num;
41646        };
41647        function P224() {
41648          MPrime.call(
41649            this,
41650            "p224",
41651            "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001"
41652          );
41653        }
41654        inherits2(P224, MPrime);
41655        function P192() {
41656          MPrime.call(
41657            this,
41658            "p192",
41659            "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff"
41660          );
41661        }
41662        inherits2(P192, MPrime);
41663        function P25519() {
41664          MPrime.call(
41665            this,
41666            "25519",
41667            "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed"
41668          );
41669        }
41670        inherits2(P25519, MPrime);
41671        P25519.prototype.imulK = function imulK(num) {
41672          var carry = 0;
41673          for (var i2 = 0; i2 < num.length; i2++) {
41674            var hi = (num.words[i2] | 0) * 19 + carry;
41675            var lo = hi & 67108863;
41676            hi >>>= 26;
41677            num.words[i2] = lo;
41678            carry = hi;
41679          }
41680          if (carry !== 0) {
41681            num.words[num.length++] = carry;
41682          }
41683          return num;
41684        };
41685        BN._prime = function prime(name) {
41686          if (primes[name]) return primes[name];
41687          var prime2;
41688          if (name === "k256") {
41689            prime2 = new K256();
41690          } else if (name === "p224") {
41691            prime2 = new P224();
41692          } else if (name === "p192") {
41693            prime2 = new P192();
41694          } else if (name === "p25519") {
41695            prime2 = new P25519();
41696          } else {
41697            throw new Error("Unknown prime " + name);
41698          }
41699          primes[name] = prime2;
41700          return prime2;
41701        };
41702        function Red(m) {
41703          if (typeof m === "string") {
41704            var prime = BN._prime(m);
41705            this.m = prime.p;
41706            this.prime = prime;
41707          } else {
41708            assert2(m.gtn(1), "modulus must be greater than 1");
41709            this.m = m;
41710            this.prime = null;
41711          }
41712        }
41713        Red.prototype._verify1 = function _verify1(a) {
41714          assert2(a.negative === 0, "red works only with positives");
41715          assert2(a.red, "red works only with red numbers");
41716        };
41717        Red.prototype._verify2 = function _verify2(a, b) {
41718          assert2((a.negative | b.negative) === 0, "red works only with positives");
41719          assert2(
41720            a.red && a.red === b.red,
41721            "red works only with red numbers"
41722          );
41723        };
41724        Red.prototype.imod = function imod(a) {
41725          if (this.prime) return this.prime.ireduce(a)._forceRed(this);
41726          move(a, a.umod(this.m)._forceRed(this));
41727          return a;
41728        };
41729        Red.prototype.neg = function neg(a) {
41730          if (a.isZero()) {
41731            return a.clone();
41732          }
41733          return this.m.sub(a)._forceRed(this);
41734        };
41735        Red.prototype.add = function add(a, b) {
41736          this._verify2(a, b);
41737          var res = a.add(b);
41738          if (res.cmp(this.m) >= 0) {
41739            res.isub(this.m);
41740          }
41741          return res._forceRed(this);
41742        };
41743        Red.prototype.iadd = function iadd(a, b) {
41744          this._verify2(a, b);
41745          var res = a.iadd(b);
41746          if (res.cmp(this.m) >= 0) {
41747            res.isub(this.m);
41748          }
41749          return res;
41750        };
41751        Red.prototype.sub = function sub(a, b) {
41752          this._verify2(a, b);
41753          var res = a.sub(b);
41754          if (res.cmpn(0) < 0) {
41755            res.iadd(this.m);
41756          }
41757          return res._forceRed(this);
41758        };
41759        Red.prototype.isub = function isub(a, b) {
41760          this._verify2(a, b);
41761          var res = a.isub(b);
41762          if (res.cmpn(0) < 0) {
41763            res.iadd(this.m);
41764          }
41765          return res;
41766        };
41767        Red.prototype.shl = function shl(a, num) {
41768          this._verify1(a);
41769          return this.imod(a.ushln(num));
41770        };
41771        Red.prototype.imul = function imul(a, b) {
41772          this._verify2(a, b);
41773          return this.imod(a.imul(b));
41774        };
41775        Red.prototype.mul = function mul(a, b) {
41776          this._verify2(a, b);
41777          return this.imod(a.mul(b));
41778        };
41779        Red.prototype.isqr = function isqr(a) {
41780          return this.imul(a, a.clone());
41781        };
41782        Red.prototype.sqr = function sqr(a) {
41783          return this.mul(a, a);
41784        };
41785        Red.prototype.sqrt = function sqrt(a) {
41786          if (a.isZero()) return a.clone();
41787          var mod3 = this.m.andln(3);
41788          assert2(mod3 % 2 === 1);
41789          if (mod3 === 3) {
41790            var pow2 = this.m.add(new BN(1)).iushrn(2);
41791            return this.pow(a, pow2);
41792          }
41793          var q = this.m.subn(1);
41794          var s = 0;
41795          while (!q.isZero() && q.andln(1) === 0) {
41796            s++;
41797            q.iushrn(1);
41798          }
41799          assert2(!q.isZero());
41800          var one = new BN(1).toRed(this);
41801          var nOne = one.redNeg();
41802          var lpow = this.m.subn(1).iushrn(1);
41803          var z = this.m.bitLength();
41804          z = new BN(2 * z * z).toRed(this);
41805          while (this.pow(z, lpow).cmp(nOne) !== 0) {
41806            z.redIAdd(nOne);
41807          }
41808          var c = this.pow(z, q);
41809          var r = this.pow(a, q.addn(1).iushrn(1));
41810          var t = this.pow(a, q);
41811          var m = s;
41812          while (t.cmp(one) !== 0) {
41813            var tmp = t;
41814            for (var i2 = 0; tmp.cmp(one) !== 0; i2++) {
41815              tmp = tmp.redSqr();
41816            }
41817            assert2(i2 < m);
41818            var b = this.pow(c, new BN(1).iushln(m - i2 - 1));
41819            r = r.redMul(b);
41820            c = b.redSqr();
41821            t = t.redMul(c);
41822            m = i2;
41823          }
41824          return r;
41825        };
41826        Red.prototype.invm = function invm(a) {
41827          var inv = a._invmp(this.m);
41828          if (inv.negative !== 0) {
41829            inv.negative = 0;
41830            return this.imod(inv).redNeg();
41831          } else {
41832            return this.imod(inv);
41833          }
41834        };
41835        Red.prototype.pow = function pow2(a, num) {
41836          if (num.isZero()) return new BN(1).toRed(this);
41837          if (num.cmpn(1) === 0) return a.clone();
41838          var windowSize = 4;
41839          var wnd = new Array(1 << windowSize);
41840          wnd[0] = new BN(1).toRed(this);
41841          wnd[1] = a;
41842          for (var i2 = 2; i2 < wnd.length; i2++) {
41843            wnd[i2] = this.mul(wnd[i2 - 1], a);
41844          }
41845          var res = wnd[0];
41846          var current = 0;
41847          var currentLen = 0;
41848          var start = num.bitLength() % 26;
41849          if (start === 0) {
41850            start = 26;
41851          }
41852          for (i2 = num.length - 1; i2 >= 0; i2--) {
41853            var word = num.words[i2];
41854            for (var j = start - 1; j >= 0; j--) {
41855              var bit = word >> j & 1;
41856              if (res !== wnd[0]) {
41857                res = this.sqr(res);
41858              }
41859              if (bit === 0 && current === 0) {
41860                currentLen = 0;
41861                continue;
41862              }
41863              current <<= 1;
41864              current |= bit;
41865              currentLen++;
41866              if (currentLen !== windowSize && (i2 !== 0 || j !== 0)) continue;
41867              res = this.mul(res, wnd[current]);
41868              currentLen = 0;
41869              current = 0;
41870            }
41871            start = 26;
41872          }
41873          return res;
41874        };
41875        Red.prototype.convertTo = function convertTo(num) {
41876          var r = num.umod(this.m);
41877          return r === num ? r.clone() : r;
41878        };
41879        Red.prototype.convertFrom = function convertFrom(num) {
41880          var res = num.clone();
41881          res.red = null;
41882          return res;
41883        };
41884        BN.mont = function mont2(num) {
41885          return new Mont(num);
41886        };
41887        function Mont(m) {
41888          Red.call(this, m);
41889          this.shift = this.m.bitLength();
41890          if (this.shift % 26 !== 0) {
41891            this.shift += 26 - this.shift % 26;
41892          }
41893          this.r = new BN(1).iushln(this.shift);
41894          this.r2 = this.imod(this.r.sqr());
41895          this.rinv = this.r._invmp(this.m);
41896          this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);
41897          this.minv = this.minv.umod(this.r);
41898          this.minv = this.r.sub(this.minv);
41899        }

vendor: 11,761 bytes, lines 41900-42250

41900        inherits2(Mont, Red);
41901        Mont.prototype.convertTo = function convertTo(num) {
41902          return this.imod(num.ushln(this.shift));
41903        };
41904        Mont.prototype.convertFrom = function convertFrom(num) {
41905          var r = this.imod(num.mul(this.rinv));
41906          r.red = null;
41907          return r;
41908        };
41909        Mont.prototype.imul = function imul(a, b) {
41910          if (a.isZero() || b.isZero()) {
41911            a.words[0] = 0;
41912            a.length = 1;
41913            return a;
41914          }
41915          var t = a.imul(b);
41916          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
41917          var u = t.isub(c).iushrn(this.shift);
41918          var res = u;
41919          if (u.cmp(this.m) >= 0) {
41920            res = u.isub(this.m);
41921          } else if (u.cmpn(0) < 0) {
41922            res = u.iadd(this.m);
41923          }
41924          return res._forceRed(this);
41925        };
41926        Mont.prototype.mul = function mul(a, b) {
41927          if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);
41928          var t = a.mul(b);
41929          var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);
41930          var u = t.isub(c).iushrn(this.shift);
41931          var res = u;
41932          if (u.cmp(this.m) >= 0) {
41933            res = u.isub(this.m);
41934          } else if (u.cmpn(0) < 0) {
41935            res = u.iadd(this.m);
41936          }
41937          return res._forceRed(this);
41938        };
41939        Mont.prototype.invm = function invm(a) {
41940          var res = this.imod(a._invmp(this.m).mul(this.r2));
41941          return res._forceRed(this);
41942        };
41943      })(module, bn);
41944    })(bn$1);
41945    return bn$1.exports;
41946  }
41947  var browserifyRsa;
41948  var hasRequiredBrowserifyRsa;
41949  function requireBrowserifyRsa() {
41950    if (hasRequiredBrowserifyRsa) return browserifyRsa;
41951    hasRequiredBrowserifyRsa = 1;
41952    var BN = requireBn();
41953    var randomBytes = requireRandombytes();
41954    var Buffer2 = requireSafeBuffer$1().Buffer;
41955    function getr(priv) {
41956      var len2 = priv.modulus.byteLength();
41957      var r;
41958      do {
41959        r = new BN(randomBytes(len2));
41960      } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2));
41961      return r;
41962    }
41963    function blind(priv) {
41964      var r = getr(priv);
41965      var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed();
41966      return { blinder, unblinder: r.invm(priv.modulus) };
41967    }
41968    function crt(msg, priv) {
41969      var blinds = blind(priv);
41970      var len2 = priv.modulus.byteLength();
41971      var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus);
41972      var c1 = blinded.toRed(BN.mont(priv.prime1));
41973      var c2 = blinded.toRed(BN.mont(priv.prime2));
41974      var qinv = priv.coefficient;
41975      var p = priv.prime1;
41976      var q = priv.prime2;
41977      var m1 = c1.redPow(priv.exponent1).fromRed();
41978      var m2 = c2.redPow(priv.exponent2).fromRed();
41979      var h = m1.isub(m2).imul(qinv).umod(p).imul(q);
41980      return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer2, "be", len2);
41981    }
41982    crt.getr = getr;
41983    browserifyRsa = crt;
41984    return browserifyRsa;
41985  }
41986  var publicEncrypt;
41987  var hasRequiredPublicEncrypt$1;
41988  function requirePublicEncrypt$1() {
41989    if (hasRequiredPublicEncrypt$1) return publicEncrypt;
41990    hasRequiredPublicEncrypt$1 = 1;
41991    var parseKeys = requireParseAsn1();
41992    var randomBytes = requireRandombytes();
41993    var createHash2 = requireCreateHash();
41994    var mgf2 = requireMgf();
41995    var xor2 = requireXor();
41996    var BN = requireBn$1();
41997    var withPublic = requireWithPublic();
41998    var crt = /* @__PURE__ */ requireBrowserifyRsa();
41999    var Buffer2 = requireSafeBuffer$1().Buffer;
42000    publicEncrypt = function publicEncrypt2(publicKey, msg, reverse) {
42001      var padding;
42002      if (publicKey.padding) {
42003        padding = publicKey.padding;
42004      } else if (reverse) {
42005        padding = 1;
42006      } else {
42007        padding = 4;
42008      }
42009      var key2 = parseKeys(publicKey);
42010      var paddedMsg;
42011      if (padding === 4) {
42012        paddedMsg = oaep(key2, msg);
42013      } else if (padding === 1) {
42014        paddedMsg = pkcs1(key2, msg, reverse);
42015      } else if (padding === 3) {
42016        paddedMsg = new BN(msg);
42017        if (paddedMsg.cmp(key2.modulus) >= 0) {
42018          throw new Error("data too long for modulus");
42019        }
42020      } else {
42021        throw new Error("unknown padding");
42022      }
42023      if (reverse) {
42024        return crt(paddedMsg, key2);
42025      } else {
42026        return withPublic(paddedMsg, key2);
42027      }
42028    };
42029    function oaep(key2, msg) {
42030      var k = key2.modulus.byteLength();
42031      var mLen = msg.length;
42032      var iHash = createHash2("sha1").update(Buffer2.alloc(0)).digest();
42033      var hLen = iHash.length;
42034      var hLen2 = 2 * hLen;
42035      if (mLen > k - hLen2 - 2) {
42036        throw new Error("message too long");
42037      }
42038      var ps = Buffer2.alloc(k - mLen - hLen2 - 2);
42039      var dblen = k - hLen - 1;
42040      var seed = randomBytes(hLen);
42041      var maskedDb = xor2(Buffer2.concat([iHash, ps, Buffer2.alloc(1, 1), msg], dblen), mgf2(seed, dblen));
42042      var maskedSeed = xor2(seed, mgf2(maskedDb, hLen));
42043      return new BN(Buffer2.concat([Buffer2.alloc(1), maskedSeed, maskedDb], k));
42044    }
42045    function pkcs1(key2, msg, reverse) {
42046      var mLen = msg.length;
42047      var k = key2.modulus.byteLength();
42048      if (mLen > k - 11) {
42049        throw new Error("message too long");
42050      }
42051      var ps;
42052      if (reverse) {
42053        ps = Buffer2.alloc(k - mLen - 3, 255);
42054      } else {
42055        ps = nonZero(k - mLen - 3);
42056      }
42057      return new BN(Buffer2.concat([Buffer2.from([0, reverse ? 1 : 2]), ps, Buffer2.alloc(1), msg], k));
42058    }
42059    function nonZero(len2) {
42060      var out = Buffer2.allocUnsafe(len2);
42061      var i2 = 0;
42062      var cache2 = randomBytes(len2 * 2);
42063      var cur = 0;
42064      var num;
42065      while (i2 < len2) {
42066        if (cur === cache2.length) {
42067          cache2 = randomBytes(len2 * 2);
42068          cur = 0;
42069        }
42070        num = cache2[cur++];
42071        if (num) {
42072          out[i2++] = num;
42073        }
42074      }
42075      return out;
42076    }
42077    return publicEncrypt;
42078  }
42079  var privateDecrypt;
42080  var hasRequiredPrivateDecrypt;
42081  function requirePrivateDecrypt() {
42082    if (hasRequiredPrivateDecrypt) return privateDecrypt;
42083    hasRequiredPrivateDecrypt = 1;
42084    var parseKeys = requireParseAsn1();
42085    var mgf2 = requireMgf();
42086    var xor2 = requireXor();
42087    var BN = requireBn$1();
42088    var crt = /* @__PURE__ */ requireBrowserifyRsa();
42089    var createHash2 = requireCreateHash();
42090    var withPublic = requireWithPublic();
42091    var Buffer2 = requireSafeBuffer$1().Buffer;
42092    privateDecrypt = function privateDecrypt2(privateKey, enc, reverse) {
42093      var padding;
42094      if (privateKey.padding) {
42095        padding = privateKey.padding;
42096      } else if (reverse) {
42097        padding = 1;
42098      } else {
42099        padding = 4;
42100      }
42101      var key2 = parseKeys(privateKey);
42102      var k = key2.modulus.byteLength();
42103      if (enc.length > k || new BN(enc).cmp(key2.modulus) >= 0) {
42104        throw new Error("decryption error");
42105      }
42106      var msg;
42107      if (reverse) {
42108        msg = withPublic(new BN(enc), key2);
42109      } else {
42110        msg = crt(enc, key2);
42111      }
42112      var zBuffer = Buffer2.alloc(k - msg.length);
42113      msg = Buffer2.concat([zBuffer, msg], k);
42114      if (padding === 4) {
42115        return oaep(key2, msg);
42116      } else if (padding === 1) {
42117        return pkcs1(key2, msg, reverse);
42118      } else if (padding === 3) {
42119        return msg;
42120      } else {
42121        throw new Error("unknown padding");
42122      }
42123    };
42124    function oaep(key2, msg) {
42125      var k = key2.modulus.byteLength();
42126      var iHash = createHash2("sha1").update(Buffer2.alloc(0)).digest();
42127      var hLen = iHash.length;
42128      if (msg[0] !== 0) {
42129        throw new Error("decryption error");
42130      }
42131      var maskedSeed = msg.slice(1, hLen + 1);
42132      var maskedDb = msg.slice(hLen + 1);
42133      var seed = xor2(maskedSeed, mgf2(maskedDb, hLen));
42134      var db = xor2(maskedDb, mgf2(seed, k - hLen - 1));
42135      if (compare(iHash, db.slice(0, hLen))) {
42136        throw new Error("decryption error");
42137      }
42138      var i2 = hLen;
42139      while (db[i2] === 0) {
42140        i2++;
42141      }
42142      if (db[i2++] !== 1) {
42143        throw new Error("decryption error");
42144      }
42145      return db.slice(i2);
42146    }
42147    function pkcs1(key2, msg, reverse) {
42148      var p1 = msg.slice(0, 2);
42149      var i2 = 2;
42150      var status = 0;
42151      while (msg[i2++] !== 0) {
42152        if (i2 >= msg.length) {
42153          status++;
42154          break;
42155        }
42156      }
42157      var ps = msg.slice(2, i2 - 1);
42158      if (p1.toString("hex") !== "0002" && !reverse || p1.toString("hex") !== "0001" && reverse) {
42159        status++;
42160      }
42161      if (ps.length < 8) {
42162        status++;
42163      }
42164      if (status) {
42165        throw new Error("decryption error");
42166      }
42167      return msg.slice(i2);
42168    }
42169    function compare(a, b) {
42170      a = Buffer2.from(a);
42171      b = Buffer2.from(b);
42172      var dif = 0;
42173      var len2 = a.length;
42174      if (a.length !== b.length) {
42175        dif++;
42176        len2 = Math.min(a.length, b.length);
42177      }
42178      var i2 = -1;
42179      while (++i2 < len2) {
42180        dif += a[i2] ^ b[i2];
42181      }
42182      return dif;
42183    }
42184    return privateDecrypt;
42185  }
42186  var hasRequiredBrowser$2;
42187  function requireBrowser$2() {
42188    if (hasRequiredBrowser$2) return browser$2;
42189    hasRequiredBrowser$2 = 1;
42190    (function(exports$12) {
42191      exports$12.publicEncrypt = requirePublicEncrypt$1();
42192      exports$12.privateDecrypt = requirePrivateDecrypt();
42193      exports$12.privateEncrypt = function privateEncrypt(key2, buf) {
42194        return exports$12.publicEncrypt(key2, buf, true);
42195      };
42196      exports$12.publicDecrypt = function publicDecrypt(key2, buf) {
42197        return exports$12.privateDecrypt(key2, buf, true);
42198      };
42199    })(browser$2);
42200    return browser$2;
42201  }
42202  var hasRequiredPublicEncrypt;
42203  function requirePublicEncrypt() {
42204    if (hasRequiredPublicEncrypt) return publicEncrypt$1;
42205    hasRequiredPublicEncrypt = 1;
42206    var crypto2 = requireCryptoBrowserify();
42207    if (typeof crypto2.publicEncrypt !== "function") {
42208      crypto2 = requireBrowser$2();
42209    }
42210    publicEncrypt$1.publicEncrypt = crypto2.publicEncrypt;
42211    publicEncrypt$1.privateDecrypt = crypto2.privateDecrypt;
42212    if (typeof crypto2.privateEncrypt !== "function") {
42213      publicEncrypt$1.privateEncrypt = requireBrowser$2().privateEncrypt;
42214    } else {
42215      publicEncrypt$1.privateEncrypt = crypto2.privateEncrypt;
42216    }
42217    if (typeof crypto2.publicDecrypt !== "function") {
42218      publicEncrypt$1.publicDecrypt = requireBrowser$2().publicDecrypt;
42219    } else {
42220      publicEncrypt$1.publicDecrypt = crypto2.publicDecrypt;
42221    }
42222    return publicEncrypt$1;
42223  }
42224  var randomfill = { exports: {} };
42225  var browser$1 = {};
42226  var hasRequiredBrowser$1;
42227  function requireBrowser$1() {
42228    if (hasRequiredBrowser$1) return browser$1;
42229    hasRequiredBrowser$1 = 1;
42230    function oldBrowser() {
42231      throw new Error("secure random number generation not supported by this browser\nuse chrome, FireFox or Internet Explorer 11");
42232    }
42233    var safeBuffer2 = requireSafeBuffer$1();
42234    var randombytes2 = requireRandombytes();
42235    var Buffer2 = safeBuffer2.Buffer;
42236    var kBufferMaxLength = safeBuffer2.kMaxLength;
42237    var crypto2 = commonjsGlobal.crypto || commonjsGlobal.msCrypto;
42238    var kMaxUint32 = Math.pow(2, 32) - 1;
42239    function assertOffset(offset, length) {
42240      if (typeof offset !== "number" || offset !== offset) {
42241        throw new TypeError("offset must be a number");
42242      }
42243      if (offset > kMaxUint32 || offset < 0) {
42244        throw new TypeError("offset must be a uint32");
42245      }
42246      if (offset > kBufferMaxLength || offset > length) {
42247        throw new RangeError("offset out of range");
42248      }
42249    }
42250    function assertSize(size, offset, length) {

42251      if (typeof size !== "number" || size !== size) {
42252        throw new TypeError("size must be a number");
42253      }
42254      if (size > kMaxUint32 || size < 0) {
42255        throw new TypeError("size must be a uint32");
42256      }
42257      if (size + offset > length || size > kBufferMaxLength) {
42258        throw new RangeError("buffer too small");
42259      }
42260    }
42261    if (crypto2 && crypto2.getRandomValues || !process$1.browser) {
42262      browser$1.randomFill = randomFill;
42263      browser$1.randomFillSync = randomFillSync;
42264    } else {
42265      browser$1.randomFill = oldBrowser;
42266      browser$1.randomFillSync = oldBrowser;
42267    }
42268    function randomFill(buf, offset, size, cb) {
42269      if (!Buffer2.isBuffer(buf) && !(buf instanceof commonjsGlobal.Uint8Array)) {
42270        throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
42271      }
42272      if (typeof offset === "function") {
42273        cb = offset;
42274        offset = 0;
42275        size = buf.length;
42276      } else if (typeof size === "function") {
42277        cb = size;
42278        size = buf.length - offset;
42279      } else if (typeof cb !== "function") {
42280        throw new TypeError('"cb" argument must be a function');
42281      }
42282      assertOffset(offset, buf.length);
42283      assertSize(size, offset, buf.length);
42284      return actualFill(buf, offset, size, cb);
42285    }
42286    function actualFill(buf, offset, size, cb) {
42287      if (process$1.browser) {
42288        var ourBuf = buf.buffer;
42289        var uint = new Uint8Array(ourBuf, offset, size);
42290        crypto2.getRandomValues(uint);
42291        if (cb) {
42292          process$1.nextTick(function() {
42293            cb(null, buf);
42294          });
42295          return;
42296        }
42297        return buf;
42298      }
42299      if (cb) {
42300        randombytes2(size, function(err, bytes2) {
42301          if (err) {
42302            return cb(err);
42303          }
42304          bytes2.copy(buf, offset);
42305          cb(null, buf);
42306        });
42307        return;
42308      }
42309      var bytes = randombytes2(size);
42310      bytes.copy(buf, offset);
42311      return buf;
42312    }
42313    function randomFillSync(buf, offset, size) {
42314      if (typeof offset === "undefined") {
42315        offset = 0;
42316      }
42317      if (!Buffer2.isBuffer(buf) && !(buf instanceof commonjsGlobal.Uint8Array)) {
42318        throw new TypeError('"buf" argument must be a Buffer or Uint8Array');
42319      }
42320      assertOffset(offset, buf.length);
42321      if (size === void 0) size = buf.length - offset;
42322      assertSize(size, offset, buf.length);
42323      return actualFill(buf, offset, size);
42324    }
42325    return browser$1;
42326  }
42327  var hasRequiredRandomfill;
42328  function requireRandomfill() {
42329    if (hasRequiredRandomfill) return randomfill.exports;
42330    hasRequiredRandomfill = 1;
42331    (function(module, exports$12) {
42332      var crypto2 = requireCryptoBrowserify();
42333      if (typeof crypto2.randomFill === "function" && typeof crypto2.randomFillSync === "function") {
42334        exports$12.randomFill = crypto2.randomFill;
42335        exports$12.randomFillSync = crypto2.randomFillSync;
42336      } else {
42337        module.exports = requireBrowser$1();
42338      }
42339    })(randomfill, randomfill.exports);
42340    return randomfill.exports;
42341  }
42342  var hasRequiredCryptoBrowserify;
42343  function requireCryptoBrowserify() {
42344    if (hasRequiredCryptoBrowserify) return cryptoBrowserify;
42345    hasRequiredCryptoBrowserify = 1;
42346    cryptoBrowserify.randomBytes = cryptoBrowserify.rng = cryptoBrowserify.pseudoRandomBytes = cryptoBrowserify.prng = requireRandombytes();
42347    cryptoBrowserify.createHash = cryptoBrowserify.Hash = requireCreateHash();
42348    cryptoBrowserify.createHmac = cryptoBrowserify.Hmac = requireCreateHmac();
42349    var algos2 = requireAlgos();
42350    var algoKeys = Object.keys(algos2);
42351    var hashes = [
42352      "sha1",
42353      "sha224",
42354      "sha256",
42355      "sha384",
42356      "sha512",
42357      "md5",
42358      "rmd160"
42359    ].concat(algoKeys);
42360    cryptoBrowserify.getHashes = function() {
42361      return hashes;
42362    };
42363    var p = requirePbkdf2();
42364    cryptoBrowserify.pbkdf2 = p.pbkdf2;
42365    cryptoBrowserify.pbkdf2Sync = p.pbkdf2Sync;
42366    var aes = requireBrowserifyCipher();
42367    cryptoBrowserify.Cipher = aes.Cipher;
42368    cryptoBrowserify.createCipher = aes.createCipher;
42369    cryptoBrowserify.Cipheriv = aes.Cipheriv;
42370    cryptoBrowserify.createCipheriv = aes.createCipheriv;
42371    cryptoBrowserify.Decipher = aes.Decipher;
42372    cryptoBrowserify.createDecipher = aes.createDecipher;
42373    cryptoBrowserify.Decipheriv = aes.Decipheriv;
42374    cryptoBrowserify.createDecipheriv = aes.createDecipheriv;
42375    cryptoBrowserify.getCiphers = aes.getCiphers;
42376    cryptoBrowserify.listCiphers = aes.listCiphers;
42377    var dh = requireDiffieHellman();
42378    cryptoBrowserify.DiffieHellmanGroup = dh.DiffieHellmanGroup;
42379    cryptoBrowserify.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
42380    cryptoBrowserify.getDiffieHellman = dh.getDiffieHellman;
42381    cryptoBrowserify.createDiffieHellman = dh.createDiffieHellman;
42382    cryptoBrowserify.DiffieHellman = dh.DiffieHellman;
42383    var sign2 = requireBrowserifySign();
42384    cryptoBrowserify.createSign = sign2.createSign;
42385    cryptoBrowserify.Sign = sign2.Sign;
42386    cryptoBrowserify.createVerify = sign2.createVerify;
42387    cryptoBrowserify.Verify = sign2.Verify;
42388    cryptoBrowserify.createECDH = requireCreateEcdh();
42389    var publicEncrypt2 = requirePublicEncrypt();
42390    cryptoBrowserify.publicEncrypt = publicEncrypt2.publicEncrypt;
42391    cryptoBrowserify.privateEncrypt = publicEncrypt2.privateEncrypt;
42392    cryptoBrowserify.publicDecrypt = publicEncrypt2.publicDecrypt;
42393    cryptoBrowserify.privateDecrypt = publicEncrypt2.privateDecrypt;
42394    var rf = requireRandomfill();
42395    cryptoBrowserify.randomFill = rf.randomFill;
42396    cryptoBrowserify.randomFillSync = rf.randomFillSync;
42397    cryptoBrowserify.createCredentials = function() {
42398      throw new Error("sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify");
42399    };
42400    cryptoBrowserify.constants = {
42401      DH_CHECK_P_NOT_SAFE_PRIME: 2,
42402      DH_CHECK_P_NOT_PRIME: 1,
42403      DH_UNABLE_TO_CHECK_GENERATOR: 4,
42404      DH_NOT_SUITABLE_GENERATOR: 8,
42405      NPN_ENABLED: 1,
42406      ALPN_ENABLED: 1,
42407      RSA_PKCS1_PADDING: 1,
42408      RSA_SSLV23_PADDING: 2,
42409      RSA_NO_PADDING: 3,
42410      RSA_PKCS1_OAEP_PADDING: 4,
42411      RSA_X931_PADDING: 5,
42412      RSA_PKCS1_PSS_PADDING: 6,
42413      POINT_CONVERSION_COMPRESSED: 2,
42414      POINT_CONVERSION_UNCOMPRESSED: 4,
42415      POINT_CONVERSION_HYBRID: 6
42416    };
42417    return cryptoBrowserify;
42418  }
42419  var mimeTypes = {};
42420  const require$$0 = {
42421    "application/1d-interleaved-parityfec": { "source": "iana" },
42422    "application/3gpdash-qoe-report+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42423    "application/3gpp-ims+xml": { "source": "iana", "compressible": true },

42424    "application/3gpphal+json": { "source": "iana", "compressible": true },
42425    "application/3gpphalforms+json": { "source": "iana", "compressible": true },
42426    "application/a2l": { "source": "iana" },
42427    "application/ace+cbor": { "source": "iana" },
42428    "application/activemessage": { "source": "iana" },
42429    "application/activity+json": { "source": "iana", "compressible": true },
42430    "application/alto-costmap+json": { "source": "iana", "compressible": true },
42431    "application/alto-costmapfilter+json": { "source": "iana", "compressible": true },
42432    "application/alto-directory+json": { "source": "iana", "compressible": true },
42433    "application/alto-endpointcost+json": { "source": "iana", "compressible": true },
42434    "application/alto-endpointcostparams+json": { "source": "iana", "compressible": true },
42435    "application/alto-endpointprop+json": { "source": "iana", "compressible": true },
42436    "application/alto-endpointpropparams+json": { "source": "iana", "compressible": true },
42437    "application/alto-error+json": { "source": "iana", "compressible": true },
42438    "application/alto-networkmap+json": { "source": "iana", "compressible": true },
42439    "application/alto-networkmapfilter+json": { "source": "iana", "compressible": true },
42440    "application/alto-updatestreamcontrol+json": { "source": "iana", "compressible": true },
42441    "application/alto-updatestreamparams+json": { "source": "iana", "compressible": true },
42442    "application/aml": { "source": "iana" },
42443    "application/andrew-inset": { "source": "iana", "extensions": ["ez"] },
42444    "application/applefile": { "source": "iana" },
42445    "application/applixware": { "source": "apache", "extensions": ["aw"] },
42446    "application/at+jwt": { "source": "iana" },
42447    "application/atf": { "source": "iana" },
42448    "application/atfx": { "source": "iana" },
42449    "application/atom+xml": { "source": "iana", "compressible": true, "extensions": ["atom"] },
42450    "application/atomcat+xml": { "source": "iana", "compressible": true, "extensions": ["atomcat"] },
42451    "application/atomdeleted+xml": { "source": "iana", "compressible": true, "extensions": ["atomdeleted"] },
42452    "application/atomicmail": { "source": "iana" },
42453    "application/atomsvc+xml": { "source": "iana", "compressible": true, "extensions": ["atomsvc"] },
42454    "application/atsc-dwd+xml": { "source": "iana", "compressible": true, "extensions": ["dwd"] },
42455    "application/atsc-dynamic-event-message": { "source": "iana" },
42456    "application/atsc-held+xml": { "source": "iana", "compressible": true, "extensions": ["held"] },
42457    "application/atsc-rdt+json": { "source": "iana", "compressible": true },
42458    "application/atsc-rsat+xml": { "source": "iana", "compressible": true, "extensions": ["rsat"] },
42459    "application/atxml": { "source": "iana" },
42460    "application/auth-policy+xml": { "source": "iana", "compressible": true },
42461    "application/bacnet-xdd+zip": { "source": "iana", "compressible": false },
42462    "application/batch-smtp": { "source": "iana" },
42463    "application/bdoc": { "compressible": false, "extensions": ["bdoc"] },
42464    "application/beep+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42465    "application/calendar+json": { "source": "iana", "compressible": true },
42466    "application/calendar+xml": { "source": "iana", "compressible": true, "extensions": ["xcs"] },

42467    "application/call-completion": { "source": "iana" },
42468    "application/cals-1840": { "source": "iana" },
42469    "application/captive+json": { "source": "iana", "compressible": true },
42470    "application/cbor": { "source": "iana" },
42471    "application/cbor-seq": { "source": "iana" },
42472    "application/cccex": { "source": "iana" },
42473    "application/ccmp+xml": { "source": "iana", "compressible": true },
42474    "application/ccxml+xml": { "source": "iana", "compressible": true, "extensions": ["ccxml"] },
42475    "application/cdfx+xml": { "source": "iana", "compressible": true, "extensions": ["cdfx"] },
42476    "application/cdmi-capability": { "source": "iana", "extensions": ["cdmia"] },
42477    "application/cdmi-container": { "source": "iana", "extensions": ["cdmic"] },
42478    "application/cdmi-domain": { "source": "iana", "extensions": ["cdmid"] },
42479    "application/cdmi-object": { "source": "iana", "extensions": ["cdmio"] },
42480    "application/cdmi-queue": { "source": "iana", "extensions": ["cdmiq"] },
42481    "application/cdni": { "source": "iana" },
42482    "application/cea": { "source": "iana" },
42483    "application/cea-2018+xml": { "source": "iana", "compressible": true },
42484    "application/cellml+xml": { "source": "iana", "compressible": true },
42485    "application/cfw": { "source": "iana" },
42486    "application/city+json": { "source": "iana", "compressible": true },
42487    "application/clr": { "source": "iana" },
42488    "application/clue+xml": { "source": "iana", "compressible": true },
42489    "application/clue_info+xml": { "source": "iana", "compressible": true },
42490    "application/cms": { "source": "iana" },
42491    "application/cnrp+xml": { "source": "iana", "compressible": true },
42492    "application/coap-group+json": { "source": "iana", "compressible": true },
42493    "application/coap-payload": { "source": "iana" },
42494    "application/commonground": { "source": "iana" },
42495    "application/conference-info+xml": { "source": "iana", "compressible": true },
42496    "application/cose": { "source": "iana" },
42497    "application/cose-key": { "source": "iana" },
42498    "application/cose-key-set": { "source": "iana" },
42499    "application/cpl+xml": { "source": "iana", "compressible": true, "extensions": ["cpl"] },
42500    "application/csrattrs": { "source": "iana" },
42501    "application/csta+xml": { "source": "iana", "compressible": true },
42502    "application/cstadata+xml": { "source": "iana", "compressible": true },
42503    "application/csvm+json": { "source": "iana", "compressible": true },
42504    "application/cu-seeme": { "source": "apache", "extensions": ["cu"] },
42505    "application/cwt": { "source": "iana" },
42506    "application/cybercash": { "source": "iana" },
42507    "application/dart": { "compressible": true },
42508    "application/dash+xml": { "source": "iana", "compressible": true, "extensions": ["mpd"] },
42509    "application/dash-patch+xml": { "source": "iana", "compressible": true, "extensions": ["mpp"] },
42510    "application/dashdelta": { "source": "iana" },
42511    "application/davmount+xml": { "source": "iana", "compressible": true, "extensions": ["davmount"] },
42512    "application/dca-rft": { "source": "iana" },
42513    "application/dcd": { "source": "iana" },
42514    "application/dec-dx": { "source": "iana" },
42515    "application/dialog-info+xml": { "source": "iana", "compressible": true },
42516    "application/dicom": { "source": "iana" },
42517    "application/dicom+json": { "source": "iana", "compressible": true },
42518    "application/dicom+xml": { "source": "iana", "compressible": true },
42519    "application/dii": { "source": "iana" },
42520    "application/dit": { "source": "iana" },
42521    "application/dns": { "source": "iana" },
42522    "application/dns+json": { "source": "iana", "compressible": true },
42523    "application/dns-message": { "source": "iana" },
42524    "application/docbook+xml": { "source": "apache", "compressible": true, "extensions": ["dbk"] },
42525    "application/dots+cbor": { "source": "iana" },
42526    "application/dskpp+xml": { "source": "iana", "compressible": true },
42527    "application/dssc+der": { "source": "iana", "extensions": ["dssc"] },
42528    "application/dssc+xml": { "source": "iana", "compressible": true, "extensions": ["xdssc"] },

vendor: 17,990 bytes, lines 42529-42761

42529    "application/dvcs": { "source": "iana" },
42530    "application/ecmascript": { "source": "iana", "compressible": true, "extensions": ["es", "ecma"] },
42531    "application/edi-consent": { "source": "iana" },
42532    "application/edi-x12": { "source": "iana", "compressible": false },
42533    "application/edifact": { "source": "iana", "compressible": false },
42534    "application/efi": { "source": "iana" },
42535    "application/elm+json": { "source": "iana", "charset": "UTF-8", "compressible": true },
42536    "application/elm+xml": { "source": "iana", "compressible": true },
42537    "application/emergencycalldata.cap+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42538    "application/emergencycalldata.comment+xml": { "source": "iana", "compressible": true },
42539    "application/emergencycalldata.control+xml": { "source": "iana", "compressible": true },
42540    "application/emergencycalldata.deviceinfo+xml": { "source": "iana", "compressible": true },
42541    "application/emergencycalldata.ecall.msd": { "source": "iana" },
42542    "application/emergencycalldata.providerinfo+xml": { "source": "iana", "compressible": true },
42543    "application/emergencycalldata.serviceinfo+xml": { "source": "iana", "compressible": true },
42544    "application/emergencycalldata.subscriberinfo+xml": { "source": "iana", "compressible": true },
42545    "application/emergencycalldata.veds+xml": { "source": "iana", "compressible": true },
42546    "application/emma+xml": { "source": "iana", "compressible": true, "extensions": ["emma"] },
42547    "application/emotionml+xml": { "source": "iana", "compressible": true, "extensions": ["emotionml"] },
42548    "application/encaprtp": { "source": "iana" },
42549    "application/epp+xml": { "source": "iana", "compressible": true },
42550    "application/epub+zip": { "source": "iana", "compressible": false, "extensions": ["epub"] },
42551    "application/eshop": { "source": "iana" },
42552    "application/exi": { "source": "iana", "extensions": ["exi"] },
42553    "application/expect-ct-report+json": { "source": "iana", "compressible": true },
42554    "application/express": { "source": "iana", "extensions": ["exp"] },
42555    "application/fastinfoset": { "source": "iana" },
42556    "application/fastsoap": { "source": "iana" },
42557    "application/fdt+xml": { "source": "iana", "compressible": true, "extensions": ["fdt"] },
42558    "application/fhir+json": { "source": "iana", "charset": "UTF-8", "compressible": true },
42559    "application/fhir+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42560    "application/fido.trusted-apps+json": { "compressible": true },
42561    "application/fits": { "source": "iana" },
42562    "application/flexfec": { "source": "iana" },
42563    "application/font-sfnt": { "source": "iana" },
42564    "application/font-tdpfr": { "source": "iana", "extensions": ["pfr"] },
42565    "application/font-woff": { "source": "iana", "compressible": false },
42566    "application/framework-attributes+xml": { "source": "iana", "compressible": true },
42567    "application/geo+json": { "source": "iana", "compressible": true, "extensions": ["geojson"] },
42568    "application/geo+json-seq": { "source": "iana" },
42569    "application/geopackage+sqlite3": { "source": "iana" },
42570    "application/geoxacml+xml": { "source": "iana", "compressible": true },
42571    "application/gltf-buffer": { "source": "iana" },
42572    "application/gml+xml": { "source": "iana", "compressible": true, "extensions": ["gml"] },
42573    "application/gpx+xml": { "source": "apache", "compressible": true, "extensions": ["gpx"] },
42574    "application/gxf": { "source": "apache", "extensions": ["gxf"] },
42575    "application/gzip": { "source": "iana", "compressible": false, "extensions": ["gz"] },
42576    "application/h224": { "source": "iana" },
42577    "application/held+xml": { "source": "iana", "compressible": true },
42578    "application/hjson": { "extensions": ["hjson"] },
42579    "application/http": { "source": "iana" },
42580    "application/hyperstudio": { "source": "iana", "extensions": ["stk"] },
42581    "application/ibe-key-request+xml": { "source": "iana", "compressible": true },
42582    "application/ibe-pkg-reply+xml": { "source": "iana", "compressible": true },
42583    "application/ibe-pp-data": { "source": "iana" },
42584    "application/iges": { "source": "iana" },
42585    "application/im-iscomposing+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42586    "application/index": { "source": "iana" },
42587    "application/index.cmd": { "source": "iana" },
42588    "application/index.obj": { "source": "iana" },
42589    "application/index.response": { "source": "iana" },
42590    "application/index.vnd": { "source": "iana" },
42591    "application/inkml+xml": { "source": "iana", "compressible": true, "extensions": ["ink", "inkml"] },
42592    "application/iotp": { "source": "iana" },
42593    "application/ipfix": { "source": "iana", "extensions": ["ipfix"] },
42594    "application/ipp": { "source": "iana" },
42595    "application/isup": { "source": "iana" },
42596    "application/its+xml": { "source": "iana", "compressible": true, "extensions": ["its"] },
42597    "application/java-archive": { "source": "apache", "compressible": false, "extensions": ["jar", "war", "ear"] },
42598    "application/java-serialized-object": { "source": "apache", "compressible": false, "extensions": ["ser"] },
42599    "application/java-vm": { "source": "apache", "compressible": false, "extensions": ["class"] },
42600    "application/javascript": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["js", "mjs"] },
42601    "application/jf2feed+json": { "source": "iana", "compressible": true },
42602    "application/jose": { "source": "iana" },
42603    "application/jose+json": { "source": "iana", "compressible": true },
42604    "application/jrd+json": { "source": "iana", "compressible": true },
42605    "application/jscalendar+json": { "source": "iana", "compressible": true },
42606    "application/json": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["json", "map"] },
42607    "application/json-patch+json": { "source": "iana", "compressible": true },
42608    "application/json-seq": { "source": "iana" },
42609    "application/json5": { "extensions": ["json5"] },
42610    "application/jsonml+json": { "source": "apache", "compressible": true, "extensions": ["jsonml"] },
42611    "application/jwk+json": { "source": "iana", "compressible": true },
42612    "application/jwk-set+json": { "source": "iana", "compressible": true },
42613    "application/jwt": { "source": "iana" },
42614    "application/kpml-request+xml": { "source": "iana", "compressible": true },
42615    "application/kpml-response+xml": { "source": "iana", "compressible": true },
42616    "application/ld+json": { "source": "iana", "compressible": true, "extensions": ["jsonld"] },
42617    "application/lgr+xml": { "source": "iana", "compressible": true, "extensions": ["lgr"] },
42618    "application/link-format": { "source": "iana" },
42619    "application/load-control+xml": { "source": "iana", "compressible": true },
42620    "application/lost+xml": { "source": "iana", "compressible": true, "extensions": ["lostxml"] },
42621    "application/lostsync+xml": { "source": "iana", "compressible": true },
42622    "application/lpf+zip": { "source": "iana", "compressible": false },
42623    "application/lxf": { "source": "iana" },
42624    "application/mac-binhex40": { "source": "iana", "extensions": ["hqx"] },
42625    "application/mac-compactpro": { "source": "apache", "extensions": ["cpt"] },
42626    "application/macwriteii": { "source": "iana" },
42627    "application/mads+xml": { "source": "iana", "compressible": true, "extensions": ["mads"] },
42628    "application/manifest+json": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["webmanifest"] },
42629    "application/marc": { "source": "iana", "extensions": ["mrc"] },
42630    "application/marcxml+xml": { "source": "iana", "compressible": true, "extensions": ["mrcx"] },
42631    "application/mathematica": { "source": "iana", "extensions": ["ma", "nb", "mb"] },
42632    "application/mathml+xml": { "source": "iana", "compressible": true, "extensions": ["mathml"] },
42633    "application/mathml-content+xml": { "source": "iana", "compressible": true },
42634    "application/mathml-presentation+xml": { "source": "iana", "compressible": true },
42635    "application/mbms-associated-procedure-description+xml": { "source": "iana", "compressible": true },
42636    "application/mbms-deregister+xml": { "source": "iana", "compressible": true },
42637    "application/mbms-envelope+xml": { "source": "iana", "compressible": true },
42638    "application/mbms-msk+xml": { "source": "iana", "compressible": true },
42639    "application/mbms-msk-response+xml": { "source": "iana", "compressible": true },
42640    "application/mbms-protection-description+xml": { "source": "iana", "compressible": true },
42641    "application/mbms-reception-report+xml": { "source": "iana", "compressible": true },
42642    "application/mbms-register+xml": { "source": "iana", "compressible": true },
42643    "application/mbms-register-response+xml": { "source": "iana", "compressible": true },
42644    "application/mbms-schedule+xml": { "source": "iana", "compressible": true },
42645    "application/mbms-user-service-description+xml": { "source": "iana", "compressible": true },
42646    "application/mbox": { "source": "iana", "extensions": ["mbox"] },
42647    "application/media-policy-dataset+xml": { "source": "iana", "compressible": true, "extensions": ["mpf"] },
42648    "application/media_control+xml": { "source": "iana", "compressible": true },
42649    "application/mediaservercontrol+xml": { "source": "iana", "compressible": true, "extensions": ["mscml"] },
42650    "application/merge-patch+json": { "source": "iana", "compressible": true },
42651    "application/metalink+xml": { "source": "apache", "compressible": true, "extensions": ["metalink"] },
42652    "application/metalink4+xml": { "source": "iana", "compressible": true, "extensions": ["meta4"] },
42653    "application/mets+xml": { "source": "iana", "compressible": true, "extensions": ["mets"] },
42654    "application/mf4": { "source": "iana" },
42655    "application/mikey": { "source": "iana" },
42656    "application/mipc": { "source": "iana" },
42657    "application/missing-blocks+cbor-seq": { "source": "iana" },
42658    "application/mmt-aei+xml": { "source": "iana", "compressible": true, "extensions": ["maei"] },
42659    "application/mmt-usd+xml": { "source": "iana", "compressible": true, "extensions": ["musd"] },
42660    "application/mods+xml": { "source": "iana", "compressible": true, "extensions": ["mods"] },
42661    "application/moss-keys": { "source": "iana" },
42662    "application/moss-signature": { "source": "iana" },
42663    "application/mosskey-data": { "source": "iana" },
42664    "application/mosskey-request": { "source": "iana" },
42665    "application/mp21": { "source": "iana", "extensions": ["m21", "mp21"] },
42666    "application/mp4": { "source": "iana", "extensions": ["mp4s", "m4p"] },
42667    "application/mpeg4-generic": { "source": "iana" },
42668    "application/mpeg4-iod": { "source": "iana" },
42669    "application/mpeg4-iod-xmt": { "source": "iana" },
42670    "application/mrb-consumer+xml": { "source": "iana", "compressible": true },
42671    "application/mrb-publish+xml": { "source": "iana", "compressible": true },
42672    "application/msc-ivr+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42673    "application/msc-mixer+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42674    "application/msword": { "source": "iana", "compressible": false, "extensions": ["doc", "dot"] },
42675    "application/mud+json": { "source": "iana", "compressible": true },
42676    "application/multipart-core": { "source": "iana" },
42677    "application/mxf": { "source": "iana", "extensions": ["mxf"] },
42678    "application/n-quads": { "source": "iana", "extensions": ["nq"] },
42679    "application/n-triples": { "source": "iana", "extensions": ["nt"] },
42680    "application/nasdata": { "source": "iana" },
42681    "application/news-checkgroups": { "source": "iana", "charset": "US-ASCII" },
42682    "application/news-groupinfo": { "source": "iana", "charset": "US-ASCII" },
42683    "application/news-transmission": { "source": "iana" },
42684    "application/nlsml+xml": { "source": "iana", "compressible": true },
42685    "application/node": { "source": "iana", "extensions": ["cjs"] },
42686    "application/nss": { "source": "iana" },
42687    "application/oauth-authz-req+jwt": { "source": "iana" },
42688    "application/oblivious-dns-message": { "source": "iana" },
42689    "application/ocsp-request": { "source": "iana" },
42690    "application/ocsp-response": { "source": "iana" },
42691    "application/octet-stream": { "source": "iana", "compressible": false, "extensions": ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] },
42692    "application/oda": { "source": "iana", "extensions": ["oda"] },
42693    "application/odm+xml": { "source": "iana", "compressible": true },
42694    "application/odx": { "source": "iana" },
42695    "application/oebps-package+xml": { "source": "iana", "compressible": true, "extensions": ["opf"] },
42696    "application/ogg": { "source": "iana", "compressible": false, "extensions": ["ogx"] },
42697    "application/omdoc+xml": { "source": "apache", "compressible": true, "extensions": ["omdoc"] },
42698    "application/onenote": { "source": "apache", "extensions": ["onetoc", "onetoc2", "onetmp", "onepkg"] },
42699    "application/opc-nodeset+xml": { "source": "iana", "compressible": true },
42700    "application/oscore": { "source": "iana" },
42701    "application/oxps": { "source": "iana", "extensions": ["oxps"] },
42702    "application/p21": { "source": "iana" },
42703    "application/p21+zip": { "source": "iana", "compressible": false },
42704    "application/p2p-overlay+xml": { "source": "iana", "compressible": true, "extensions": ["relo"] },
42705    "application/parityfec": { "source": "iana" },
42706    "application/passport": { "source": "iana" },
42707    "application/patch-ops-error+xml": { "source": "iana", "compressible": true, "extensions": ["xer"] },
42708    "application/pdf": { "source": "iana", "compressible": false, "extensions": ["pdf"] },
42709    "application/pdx": { "source": "iana" },
42710    "application/pem-certificate-chain": { "source": "iana" },
42711    "application/pgp-encrypted": { "source": "iana", "compressible": false, "extensions": ["pgp"] },
42712    "application/pgp-keys": { "source": "iana", "extensions": ["asc"] },
42713    "application/pgp-signature": { "source": "iana", "extensions": ["asc", "sig"] },
42714    "application/pics-rules": { "source": "apache", "extensions": ["prf"] },
42715    "application/pidf+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42716    "application/pidf-diff+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42717    "application/pkcs10": { "source": "iana", "extensions": ["p10"] },
42718    "application/pkcs12": { "source": "iana" },
42719    "application/pkcs7-mime": { "source": "iana", "extensions": ["p7m", "p7c"] },
42720    "application/pkcs7-signature": { "source": "iana", "extensions": ["p7s"] },
42721    "application/pkcs8": { "source": "iana", "extensions": ["p8"] },
42722    "application/pkcs8-encrypted": { "source": "iana" },
42723    "application/pkix-attr-cert": { "source": "iana", "extensions": ["ac"] },
42724    "application/pkix-cert": { "source": "iana", "extensions": ["cer"] },
42725    "application/pkix-crl": { "source": "iana", "extensions": ["crl"] },
42726    "application/pkix-pkipath": { "source": "iana", "extensions": ["pkipath"] },
42727    "application/pkixcmp": { "source": "iana", "extensions": ["pki"] },
42728    "application/pls+xml": { "source": "iana", "compressible": true, "extensions": ["pls"] },
42729    "application/poc-settings+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
42730    "application/postscript": { "source": "iana", "compressible": true, "extensions": ["ai", "eps", "ps"] },
42731    "application/ppsp-tracker+json": { "source": "iana", "compressible": true },
42732    "application/problem+json": { "source": "iana", "compressible": true },
42733    "application/problem+xml": { "source": "iana", "compressible": true },
42734    "application/provenance+xml": { "source": "iana", "compressible": true, "extensions": ["provx"] },
42735    "application/prs.alvestrand.titrax-sheet": { "source": "iana" },
42736    "application/prs.cww": { "source": "iana", "extensions": ["cww"] },
42737    "application/prs.cyn": { "source": "iana", "charset": "7-BIT" },
42738    "application/prs.hpub+zip": { "source": "iana", "compressible": false },
42739    "application/prs.nprend": { "source": "iana" },
42740    "application/prs.plucker": { "source": "iana" },
42741    "application/prs.rdf-xml-crypt": { "source": "iana" },
42742    "application/prs.xsf+xml": { "source": "iana", "compressible": true },
42743    "application/pskc+xml": { "source": "iana", "compressible": true, "extensions": ["pskcxml"] },
42744    "application/pvd+json": { "source": "iana", "compressible": true },
42745    "application/qsig": { "source": "iana" },
42746    "application/raml+yaml": { "compressible": true, "extensions": ["raml"] },
42747    "application/raptorfec": { "source": "iana" },
42748    "application/rdap+json": { "source": "iana", "compressible": true },
42749    "application/rdf+xml": { "source": "iana", "compressible": true, "extensions": ["rdf", "owl"] },
42750    "application/reginfo+xml": { "source": "iana", "compressible": true, "extensions": ["rif"] },
42751    "application/relax-ng-compact-syntax": { "source": "iana", "extensions": ["rnc"] },
42752    "application/remote-printing": { "source": "iana" },
42753    "application/reputon+json": { "source": "iana", "compressible": true },
42754    "application/resource-lists+xml": { "source": "iana", "compressible": true, "extensions": ["rl"] },
42755    "application/resource-lists-diff+xml": { "source": "iana", "compressible": true, "extensions": ["rld"] },
42756    "application/rfc+xml": { "source": "iana", "compressible": true },
42757    "application/riscos": { "source": "iana" },
42758    "application/rlmi+xml": { "source": "iana", "compressible": true },
42759    "application/rls-services+xml": { "source": "iana", "compressible": true, "extensions": ["rs"] },
42760    "application/route-apd+xml": { "source": "iana", "compressible": true, "extensions": ["rapd"] },
42761    "application/route-s-tsid+xml": { "source": "iana", "compressible": true, "extensions": ["sls"] },

42762    "application/route-usd+xml": { "source": "iana", "compressible": true, "extensions": ["rusd"] },
42763    "application/rpki-ghostbusters": { "source": "iana", "extensions": ["gbr"] },
42764    "application/rpki-manifest": { "source": "iana", "extensions": ["mft"] },
42765    "application/rpki-publication": { "source": "iana" },
42766    "application/rpki-roa": { "source": "iana", "extensions": ["roa"] },
42767    "application/rpki-updown": { "source": "iana" },
42768    "application/rsd+xml": { "source": "apache", "compressible": true, "extensions": ["rsd"] },
42769    "application/rss+xml": { "source": "apache", "compressible": true, "extensions": ["rss"] },
42770    "application/rtf": { "source": "iana", "compressible": true, "extensions": ["rtf"] },
42771    "application/rtploopback": { "source": "iana" },
42772    "application/rtx": { "source": "iana" },
42773    "application/samlassertion+xml": { "source": "iana", "compressible": true },
42774    "application/samlmetadata+xml": { "source": "iana", "compressible": true },
42775    "application/sarif+json": { "source": "iana", "compressible": true },
42776    "application/sarif-external-properties+json": { "source": "iana", "compressible": true },
42777    "application/sbe": { "source": "iana" },
42778    "application/sbml+xml": { "source": "iana", "compressible": true, "extensions": ["sbml"] },
42779    "application/scaip+xml": { "source": "iana", "compressible": true },
42780    "application/scim+json": { "source": "iana", "compressible": true },
42781    "application/scvp-cv-request": { "source": "iana", "extensions": ["scq"] },
42782    "application/scvp-cv-response": { "source": "iana", "extensions": ["scs"] },
42783    "application/scvp-vp-request": { "source": "iana", "extensions": ["spq"] },
42784    "application/scvp-vp-response": { "source": "iana", "extensions": ["spp"] },
42785    "application/sdp": { "source": "iana", "extensions": ["sdp"] },
42786    "application/secevent+jwt": { "source": "iana" },
42787    "application/senml+cbor": { "source": "iana" },
42788    "application/senml+json": { "source": "iana", "compressible": true },
42789    "application/senml+xml": { "source": "iana", "compressible": true, "extensions": ["senmlx"] },
42790    "application/senml-etch+cbor": { "source": "iana" },
42791    "application/senml-etch+json": { "source": "iana", "compressible": true },
42792    "application/senml-exi": { "source": "iana" },
42793    "application/sensml+cbor": { "source": "iana" },
42794    "application/sensml+json": { "source": "iana", "compressible": true },
42795    "application/sensml+xml": { "source": "iana", "compressible": true, "extensions": ["sensmlx"] },
42796    "application/sensml-exi": { "source": "iana" },
42797    "application/sep+xml": { "source": "iana", "compressible": true },
42798    "application/sep-exi": { "source": "iana" },
42799    "application/session-info": { "source": "iana" },
42800    "application/set-payment": { "source": "iana" },
42801    "application/set-payment-initiation": { "source": "iana", "extensions": ["setpay"] },
42802    "application/set-registration": { "source": "iana" },
42803    "application/set-registration-initiation": { "source": "iana", "extensions": ["setreg"] },
42804    "application/sgml": { "source": "iana" },
42805    "application/sgml-open-catalog": { "source": "iana" },
42806    "application/shf+xml": { "source": "iana", "compressible": true, "extensions": ["shf"] },
42807    "application/sieve": { "source": "iana", "extensions": ["siv", "sieve"] },
42808    "application/simple-filter+xml": { "source": "iana", "compressible": true },
42809    "application/simple-message-summary": { "source": "iana" },
42810    "application/simplesymbolcontainer": { "source": "iana" },
42811    "application/sipc": { "source": "iana" },
42812    "application/slate": { "source": "iana" },
42813    "application/smil": { "source": "iana" },
42814    "application/smil+xml": { "source": "iana", "compressible": true, "extensions": ["smi", "smil"] },
42815    "application/smpte336m": { "source": "iana" },
42816    "application/soap+fastinfoset": { "source": "iana" },
42817    "application/soap+xml": { "source": "iana", "compressible": true },
42818    "application/sparql-query": { "source": "iana", "extensions": ["rq"] },
42819    "application/sparql-results+xml": { "source": "iana", "compressible": true, "extensions": ["srx"] },

42820    "application/spdx+json": { "source": "iana", "compressible": true },
42821    "application/spirits-event+xml": { "source": "iana", "compressible": true },
42822    "application/sql": { "source": "iana" },
42823    "application/srgs": { "source": "iana", "extensions": ["gram"] },
42824    "application/srgs+xml": { "source": "iana", "compressible": true, "extensions": ["grxml"] },
42825    "application/sru+xml": { "source": "iana", "compressible": true, "extensions": ["sru"] },
42826    "application/ssdl+xml": { "source": "apache", "compressible": true, "extensions": ["ssdl"] },
42827    "application/ssml+xml": { "source": "iana", "compressible": true, "extensions": ["ssml"] },
42828    "application/stix+json": { "source": "iana", "compressible": true },
42829    "application/swid+xml": { "source": "iana", "compressible": true, "extensions": ["swidtag"] },
42830    "application/tamp-apex-update": { "source": "iana" },
42831    "application/tamp-apex-update-confirm": { "source": "iana" },
42832    "application/tamp-community-update": { "source": "iana" },
42833    "application/tamp-community-update-confirm": { "source": "iana" },
42834    "application/tamp-error": { "source": "iana" },
42835    "application/tamp-sequence-adjust": { "source": "iana" },
42836    "application/tamp-sequence-adjust-confirm": { "source": "iana" },
42837    "application/tamp-status-query": { "source": "iana" },
42838    "application/tamp-status-response": { "source": "iana" },
42839    "application/tamp-update": { "source": "iana" },
42840    "application/tamp-update-confirm": { "source": "iana" },
42841    "application/tar": { "compressible": true },
42842    "application/taxii+json": { "source": "iana", "compressible": true },
42843    "application/td+json": { "source": "iana", "compressible": true },
42844    "application/tei+xml": { "source": "iana", "compressible": true, "extensions": ["tei", "teicorpus"] },
42845    "application/tetra_isi": { "source": "iana" },
42846    "application/thraud+xml": { "source": "iana", "compressible": true, "extensions": ["tfi"] },
42847    "application/timestamp-query": { "source": "iana" },
42848    "application/timestamp-reply": { "source": "iana" },
42849    "application/timestamped-data": { "source": "iana", "extensions": ["tsd"] },
42850    "application/tlsrpt+gzip": { "source": "iana" },
42851    "application/tlsrpt+json": { "source": "iana", "compressible": true },
42852    "application/tnauthlist": { "source": "iana" },
42853    "application/token-introspection+jwt": { "source": "iana" },
42854    "application/toml": { "compressible": true, "extensions": ["toml"] },
42855    "application/trickle-ice-sdpfrag": { "source": "iana" },
42856    "application/trig": { "source": "iana", "extensions": ["trig"] },
42857    "application/ttml+xml": { "source": "iana", "compressible": true, "extensions": ["ttml"] },
42858    "application/tve-trigger": { "source": "iana" },
42859    "application/tzif": { "source": "iana" },
42860    "application/tzif-leap": { "source": "iana" },
42861    "application/ubjson": { "compressible": false, "extensions": ["ubj"] },
42862    "application/ulpfec": { "source": "iana" },
42863    "application/urc-grpsheet+xml": { "source": "iana", "compressible": true },
42864    "application/urc-ressheet+xml": { "source": "iana", "compressible": true, "extensions": ["rsheet"] },
42865    "application/urc-targetdesc+xml": { "source": "iana", "compressible": true, "extensions": ["td"] },
42866    "application/urc-uisocketdesc+xml": { "source": "iana", "compressible": true },
42867    "application/vcard+json": { "source": "iana", "compressible": true },
42868    "application/vcard+xml": { "source": "iana", "compressible": true },
42869    "application/vemmi": { "source": "iana" },
42870    "application/vividence.scriptfile": { "source": "apache" },
42871    "application/vnd.1000minds.decision-model+xml": { "source": "iana", "compressible": true, "extensions": ["1km"] },
42872    "application/vnd.3gpp-prose+xml": { "source": "iana", "compressible": true },
42873    "application/vnd.3gpp-prose-pc3ch+xml": { "source": "iana", "compressible": true },
42874    "application/vnd.3gpp-v2x-local-service-information": { "source": "iana" },
42875    "application/vnd.3gpp.5gnas": { "source": "iana" },
42876    "application/vnd.3gpp.access-transfer-events+xml": { "source": "iana", "compressible": true },
42877    "application/vnd.3gpp.bsf+xml": { "source": "iana", "compressible": true },
42878    "application/vnd.3gpp.gmop+xml": { "source": "iana", "compressible": true },

42879    "application/vnd.3gpp.gtpc": { "source": "iana" },
42880    "application/vnd.3gpp.interworking-data": { "source": "iana" },
42881    "application/vnd.3gpp.lpp": { "source": "iana" },
42882    "application/vnd.3gpp.mc-signalling-ear": { "source": "iana" },
42883    "application/vnd.3gpp.mcdata-affiliation-command+xml": { "source": "iana", "compressible": true },
42884    "application/vnd.3gpp.mcdata-info+xml": { "source": "iana", "compressible": true },
42885    "application/vnd.3gpp.mcdata-payload": { "source": "iana" },
42886    "application/vnd.3gpp.mcdata-service-config+xml": { "source": "iana", "compressible": true },
42887    "application/vnd.3gpp.mcdata-signalling": { "source": "iana" },
42888    "application/vnd.3gpp.mcdata-ue-config+xml": { "source": "iana", "compressible": true },
42889    "application/vnd.3gpp.mcdata-user-profile+xml": { "source": "iana", "compressible": true },
42890    "application/vnd.3gpp.mcptt-affiliation-command+xml": { "source": "iana", "compressible": true },
42891    "application/vnd.3gpp.mcptt-floor-request+xml": { "source": "iana", "compressible": true },
42892    "application/vnd.3gpp.mcptt-info+xml": { "source": "iana", "compressible": true },
42893    "application/vnd.3gpp.mcptt-location-info+xml": { "source": "iana", "compressible": true },
42894    "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { "source": "iana", "compressible": true },
42895    "application/vnd.3gpp.mcptt-service-config+xml": { "source": "iana", "compressible": true },
42896    "application/vnd.3gpp.mcptt-signed+xml": { "source": "iana", "compressible": true },
42897    "application/vnd.3gpp.mcptt-ue-config+xml": { "source": "iana", "compressible": true },
42898    "application/vnd.3gpp.mcptt-ue-init-config+xml": { "source": "iana", "compressible": true },
42899    "application/vnd.3gpp.mcptt-user-profile+xml": { "source": "iana", "compressible": true },
42900    "application/vnd.3gpp.mcvideo-affiliation-command+xml": { "source": "iana", "compressible": true },
42901    "application/vnd.3gpp.mcvideo-affiliation-info+xml": { "source": "iana", "compressible": true },
42902    "application/vnd.3gpp.mcvideo-info+xml": { "source": "iana", "compressible": true },
42903    "application/vnd.3gpp.mcvideo-location-info+xml": { "source": "iana", "compressible": true },
42904    "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { "source": "iana", "compressible": true },
42905    "application/vnd.3gpp.mcvideo-service-config+xml": { "source": "iana", "compressible": true },
42906    "application/vnd.3gpp.mcvideo-transmission-request+xml": { "source": "iana", "compressible": true },
42907    "application/vnd.3gpp.mcvideo-ue-config+xml": { "source": "iana", "compressible": true },
42908    "application/vnd.3gpp.mcvideo-user-profile+xml": { "source": "iana", "compressible": true },
42909    "application/vnd.3gpp.mid-call+xml": { "source": "iana", "compressible": true },
42910    "application/vnd.3gpp.ngap": { "source": "iana" },
42911    "application/vnd.3gpp.pfcp": { "source": "iana" },
42912    "application/vnd.3gpp.pic-bw-large": { "source": "iana", "extensions": ["plb"] },
42913    "application/vnd.3gpp.pic-bw-small": { "source": "iana", "extensions": ["psb"] },
42914    "application/vnd.3gpp.pic-bw-var": { "source": "iana", "extensions": ["pvb"] },
42915    "application/vnd.3gpp.s1ap": { "source": "iana" },
42916    "application/vnd.3gpp.sms": { "source": "iana" },
42917    "application/vnd.3gpp.sms+xml": { "source": "iana", "compressible": true },
42918    "application/vnd.3gpp.srvcc-ext+xml": { "source": "iana", "compressible": true },
42919    "application/vnd.3gpp.srvcc-info+xml": { "source": "iana", "compressible": true },
42920    "application/vnd.3gpp.state-and-event-info+xml": { "source": "iana", "compressible": true },
42921    "application/vnd.3gpp.ussd+xml": { "source": "iana", "compressible": true },
42922    "application/vnd.3gpp2.bcmcsinfo+xml": { "source": "iana", "compressible": true },
42923    "application/vnd.3gpp2.sms": { "source": "iana" },
42924    "application/vnd.3gpp2.tcap": { "source": "iana", "extensions": ["tcap"] },
42925    "application/vnd.3lightssoftware.imagescal": { "source": "iana" },
42926    "application/vnd.3m.post-it-notes": { "source": "iana", "extensions": ["pwn"] },
42927    "application/vnd.accpac.simply.aso": { "source": "iana", "extensions": ["aso"] },

42928    "application/vnd.accpac.simply.imp": { "source": "iana", "extensions": ["imp"] },
42929    "application/vnd.acucobol": { "source": "iana", "extensions": ["acu"] },
42930    "application/vnd.acucorp": { "source": "iana", "extensions": ["atc", "acutc"] },
42931    "application/vnd.adobe.air-application-installer-package+zip": { "source": "apache", "compressible": false, "extensions": ["air"] },
42932    "application/vnd.adobe.flash.movie": { "source": "iana" },
42933    "application/vnd.adobe.formscentral.fcdt": { "source": "iana", "extensions": ["fcdt"] },
42934    "application/vnd.adobe.fxp": { "source": "iana", "extensions": ["fxp", "fxpl"] },
42935    "application/vnd.adobe.partial-upload": { "source": "iana" },
42936    "application/vnd.adobe.xdp+xml": { "source": "iana", "compressible": true, "extensions": ["xdp"] },
42937    "application/vnd.adobe.xfdf": { "source": "iana", "extensions": ["xfdf"] },
42938    "application/vnd.aether.imp": { "source": "iana" },
42939    "application/vnd.afpc.afplinedata": { "source": "iana" },
42940    "application/vnd.afpc.afplinedata-pagedef": { "source": "iana" },
42941    "application/vnd.afpc.cmoca-cmresource": { "source": "iana" },
42942    "application/vnd.afpc.foca-charset": { "source": "iana" },
42943    "application/vnd.afpc.foca-codedfont": { "source": "iana" },
42944    "application/vnd.afpc.foca-codepage": { "source": "iana" },
42945    "application/vnd.afpc.modca": { "source": "iana" },
42946    "application/vnd.afpc.modca-cmtable": { "source": "iana" },
42947    "application/vnd.afpc.modca-formdef": { "source": "iana" },
42948    "application/vnd.afpc.modca-mediummap": { "source": "iana" },
42949    "application/vnd.afpc.modca-objectcontainer": { "source": "iana" },
42950    "application/vnd.afpc.modca-overlay": { "source": "iana" },
42951    "application/vnd.afpc.modca-pagesegment": { "source": "iana" },
42952    "application/vnd.age": { "source": "iana", "extensions": ["age"] },
42953    "application/vnd.ah-barcode": { "source": "iana" },
42954    "application/vnd.ahead.space": { "source": "iana", "extensions": ["ahead"] },
42955    "application/vnd.airzip.filesecure.azf": { "source": "iana", "extensions": ["azf"] },
42956    "application/vnd.airzip.filesecure.azs": { "source": "iana", "extensions": ["azs"] },
42957    "application/vnd.amadeus+json": { "source": "iana", "compressible": true },
42958    "application/vnd.amazon.ebook": { "source": "apache", "extensions": ["azw"] },
42959    "application/vnd.amazon.mobi8-ebook": { "source": "iana" },
42960    "application/vnd.americandynamics.acc": { "source": "iana", "extensions": ["acc"] },
42961    "application/vnd.amiga.ami": { "source": "iana", "extensions": ["ami"] },
42962    "application/vnd.amundsen.maze+xml": { "source": "iana", "compressible": true },
42963    "application/vnd.android.ota": { "source": "iana" },
42964    "application/vnd.android.package-archive": { "source": "apache", "compressible": false, "extensions": ["apk"] },
42965    "application/vnd.anki": { "source": "iana" },
42966    "application/vnd.anser-web-certificate-issue-initiation": { "source": "iana", "extensions": ["cii"] },
42967    "application/vnd.anser-web-funds-transfer-initiation": { "source": "apache", "extensions": ["fti"] },
42968    "application/vnd.antix.game-component": { "source": "iana", "extensions": ["atx"] },
42969    "application/vnd.apache.arrow.file": { "source": "iana" },
42970    "application/vnd.apache.arrow.stream": { "source": "iana" },
42971    "application/vnd.apache.thrift.binary": { "source": "iana" },
42972    "application/vnd.apache.thrift.compact": { "source": "iana" },
42973    "application/vnd.apache.thrift.json": { "source": "iana" },
42974    "application/vnd.api+json": { "source": "iana", "compressible": true },
42975    "application/vnd.aplextor.warrp+json": { "source": "iana", "compressible": true },
42976    "application/vnd.apothekende.reservation+json": { "source": "iana", "compressible": true },
42977    "application/vnd.apple.installer+xml": { "source": "iana", "compressible": true, "extensions": ["mpkg"] },
42978    "application/vnd.apple.keynote": { "source": "iana", "extensions": ["key"] },
42979    "application/vnd.apple.mpegurl": { "source": "iana", "extensions": ["m3u8"] },
42980    "application/vnd.apple.numbers": { "source": "iana", "extensions": ["

42980numbers"] },
42981    "application/vnd.apple.pages": { "source": "iana", "extensions": ["pages"] },
42982    "application/vnd.apple.pkpass": { "compressible": false, "extensions": ["pkpass"] },
42983    "application/vnd.arastra.swi": { "source": "iana" },
42984    "application/vnd.aristanetworks.swi": { "source": "iana", "extensions": ["swi"] },
42985    "application/vnd.artisan+json": { "source": "iana", "compressible": true },
42986    "application/vnd.artsquare": { "source": "iana" },
42987    "application/vnd.astraea-software.iota": { "source": "iana", "extensions": ["iota"] },
42988    "application/vnd.audiograph": { "source": "iana", "extensions": ["aep"] },
42989    "application/vnd.autopackage": { "source": "iana" },
42990    "application/vnd.avalon+json": { "source": "iana", "compressible": true },
42991    "application/vnd.avistar+xml": { "source": "iana", "compressible": true },
42992    "application/vnd.balsamiq.bmml+xml": { "source": "iana", "compressible": true, "extensions": ["bmml"] },
42993    "application/vnd.balsamiq.bmpr": { "source": "iana" },
42994    "application/vnd.banana-accounting": { "source": "iana" },
42995    "application/vnd.bbf.usp.error": { "source": "iana" },
42996    "application/vnd.bbf.usp.msg": { "source": "iana" },
42997    "application/vnd.bbf.usp.msg+json": { "source": "iana", "compressible": true },
42998    "application/vnd.bekitzur-stech+json": { "source": "iana", "compressible": true },
42999    "application/vnd.bint.med-content": { "source": "iana" },
43000    "application/vnd.biopax.rdf+xml": { "source": "iana", "compressible": true },
43001    "application/vnd.blink-idb-value-wrapper": { "source": "iana" },
43002    "application/vnd.blueice.multipass": { "source": "iana", "extensions": ["mpm"] },
43003    "application/vnd.bluetooth.ep.oob": { "source": "iana" },
43004    "application/vnd.bluetooth.le.oob": { "source": "iana" },
43005    "application/vnd.bmi": { "source": "iana", "extensions": ["bmi"] },
43006    "application/vnd.bpf": { "source": "iana" },
43007    "application/vnd.bpf3": { "source": "iana" },
43008    "application/vnd.businessobjects": { "source": "iana", "extensions": ["rep"] },
43009    "application/vnd.byu.uapi+json": { "source": "iana", "compressible": true },
43010    "application/vnd.cab-jscript": { "source": "iana" },
43011    "application/vnd.canon-cpdl": { "source": "iana" },
43012    "application/vnd.canon-lips": { "source": "iana" },
43013    "application/vnd.capasystems-pg+json": { "source": "iana", "compressible": true },
43014    "application/vnd.cendio.thinlinc.clientconf": { "source": "iana" },
43015    "application/vnd.century-systems.tcp_stream": { "source": "iana" },
43016    "application/vnd.chemdraw+xml": { "source": "iana", "compressible": true, "extensions": ["cdxml"] },
43017    "application/vnd.chess-pgn": { "source": "iana" },

43018    "application/vnd.chipnuts.karaoke-mmd": { "source": "iana", "extensions": ["mmd"] },
43019    "application/vnd.ciedi": { "source": "iana" },
43020    "application/vnd.cinderella": { "source": "iana", "extensions": ["cdy"] },
43021    "application/vnd.cirpack.isdn-ext": { "source": "iana" },
43022    "application/vnd.citationstyles.style+xml": { "source": "iana", "compressible": true, "extensions": ["csl"] },
43023    "application/vnd.claymore": { "source": "iana", "extensions": ["cla"] },
43024    "application/vnd.cloanto.rp9": { "source": "iana", "extensions": ["rp9"] },
43025    "application/vnd.clonk.c4group": { "source": "iana", "extensions": ["c4g", "c4d", "c4f", "c4p", "c4u"] },
43026    "application/vnd.cluetrust.cartomobile-config": { "source": "iana", "extensions": ["c11amc"] },
43027    "application/vnd.cluetrust.cartomobile-config-pkg": { "source": "iana", "extensions": ["c11amz"] },
43028    "application/vnd.coffeescript": { "source": "iana" },
43029    "application/vnd.collabio.xodocuments.document": { "source": "iana" },
43030    "application/vnd.collabio.xodocuments.document-template": { "source": "iana" },
43031    "application/vnd.collabio.xodocuments.presentation": { "source": "iana" },
43032    "application/vnd.collabio.xodocuments.presentation-template": { "source": "iana" },
43033    "application/vnd.collabio.xodocuments.spreadsheet": { "source": "iana" },
43034    "application/vnd.collabio.xodocuments.spreadsheet-template": { "source": "iana" },
43035    "application/vnd.collection+json": { "source": "iana", "compressible": true },
43036    "application/vnd.collection.doc+json": { "source": "iana", "compressible": true },
43037    "application/vnd.collection.next+json": { "source": "iana", "compressible": true },
43038    "application/vnd.comicbook+zip": { "source": "iana", "compressible": false },
43039    "application/vnd.comicbook-rar": { "source": "iana" },
43040    "application/vnd.commerce-battelle": { "source": "iana" },
43041    "application/vnd.commonspace": { "source": "iana", "extensions": ["csp"] },
43042    "application/vnd.contact.cmsg": { "source": "iana", "extensions": ["cdbcmsg"] },
43043    "application/vnd.coreos.ignition+json": { "source": "iana", "compressible": true },
43044    "application/vnd.cosmocaller": { "source": "iana", "extensions": ["cmc"] },
43045    "application/vnd.crick.clicker": { "source": "iana", "extensions": ["clkx"] },
43046    "application/vnd.crick.clicker.keyboard": { "source": "iana", "extensions": ["clkk"] },
43047    "application/vnd.crick.clicker.palette": { "source": "iana", "extensions": ["clkp"] },
43048    "application/vnd.crick.clicker.template": { "source": "iana", "extensions": ["clkt"] },
43049    "application/vnd.crick.clicker.wordbank": { "source": "iana", "extensions": ["clkw"] },
43050    "application/vnd.criticaltools.wbs+xml": { "source": "iana", "compressible": true, "extensions": ["wbs"] },
43051    "application/vnd.cryptii.pipe+json": { "source": "iana", "compressible": true },
43052    "application/vnd.crypto-shade-file": { "source": "iana" },
43053    "application/vnd.cryptomator.encrypted": { "source": "iana" },
43054    "application/vnd.cryptomator.vault": { "source": "iana" },
43055    "application/vnd.ctc-posml": { "source": "iana", "extensions": ["pml"] },
43056    "application/vnd.ctct.ws+xml": { "source": "iana", "compressible": true },
43057    "application/vnd.cups-pdf": { "source": "iana" },
43058    "application/vnd.cups-postscript": { "source": "iana" },
43059    "application/vnd.cups-ppd": { "source": "iana", "extensions": ["ppd"] },
43060    "application/vnd.cups-raster": { "source": "iana" },
43061    "application/vnd.cups-raw": { "source": "iana" },
43062    "application/vnd.curl": { "source": "iana" },
43063    "application/vnd.curl.car": { "source": "apache", "extensions": ["car"] },
43064    "application/vnd.curl.pcurl": { "source": "apache", "extensions": ["pcurl"] },
43065    "application/vnd.cyan.dean.root+xml": { "source": "iana", "compressible": true },
43066    "application/vnd.cybank": { "source": "iana" },
43067    "application/vnd.cyclonedx+json": { "source": "iana", "compressible": true },
43068    "application/vnd.cyclonedx+xml": { "source": "iana", "compressible": true },
43069    "application/vnd.d2l.coursepackage1p0+zip": { "source": "iana", "compressible": false },
43070    "application/vnd.d3m-dataset": { "source": "iana" },
43071    "application/vnd.d3m-problem": { "source": "iana" },
43072    "application/vnd.dart": { "source": "iana", "compressible": true, "extensions": ["dart"] },
43073    "application/vnd.data-vision.rdz": { "source": "iana", "extensions": ["rdz"] },

43074    "application/vnd.datapackage+json": { "source": "iana", "compressible": true },
43075    "application/vnd.dataresource+json": { "source": "iana", "compressible": true },
43076    "application/vnd.dbf": { "source": "iana", "extensions": ["dbf"] },
43077    "application/vnd.debian.binary-package": { "source": "iana" },
43078    "application/vnd.dece.data": { "source": "iana", "extensions": ["uvf", "uvvf", "uvd", "uvvd"] },
43079    "application/vnd.dece.ttml+xml": { "source": "iana", "compressible": true, "extensions": ["uvt", "uvvt"] },
43080    "application/vnd.dece.unspecified": { "source": "iana", "extensions": ["uvx", "uvvx"] },
43081    "application/vnd.dece.zip": { "source": "iana", "extensions": ["uvz", "uvvz"] },
43082    "application/vnd.denovo.fcselayout-link": { "source": "iana", "extensions": ["fe_launch"] },
43083    "application/vnd.desmume.movie": { "source": "iana" },
43084    "application/vnd.dir-bi.plate-dl-nosuffix": { "source": "iana" },
43085    "application/vnd.dm.delegation+xml": { "source": "iana", "compressible": true },
43086    "application/vnd.dna": { "source": "iana", "extensions": ["dna"] },
43087    "application/vnd.document+json": { "source": "iana", "compressible": true },
43088    "application/vnd.dolby.mlp": { "source": "apache", "extensions": ["mlp"] },
43089    "application/vnd.dolby.mobile.1": { "source": "iana" },
43090    "application/vnd.dolby.mobile.2": { "source": "iana" },
43091    "application/vnd.doremir.scorecloud-binary-document": { "source": "iana" },
43092    "application/vnd.dpgraph": { "source": "iana", "extensions": ["dpg"] },
43093    "application/vnd.dreamfactory": { "source": "iana", "extensions": ["dfac"] },
43094    "application/vnd.drive+json": { "source": "iana", "compressible": true },
43095    "application/vnd.ds-keypoint": { "source": "apache", "extensions": ["kpxx"] },

43096    "application/vnd.dtg.local": { "source": "iana" },
43097    "application/vnd.dtg.local.flash": { "source": "iana" },
43098    "application/vnd.dtg.local.html": { "source": "iana" },
43099    "application/vnd.dvb.ait": { "source": "iana", "extensions": ["ait"] },
43100    "application/vnd.dvb.dvbisl+xml": { "source": "iana", "compressible": true },
43101    "application/vnd.dvb.dvbj": { "source": "iana" },
43102    "application/vnd.dvb.esgcontainer": { "source": "iana" },
43103    "application/vnd.dvb.ipdcdftnotifaccess": { "source": "iana" },
43104    "application/vnd.dvb.ipdcesgaccess": { "source": "iana" },
43105    "application/vnd.dvb.ipdcesgaccess2": { "source": "iana" },
43106    "application/vnd.dvb.ipdcesgpdd": { "source": "iana" },
43107    "application/vnd.dvb.ipdcroaming": { "source": "iana" },
43108    "application/vnd.dvb.iptv.alfec-base": { "source": "iana" },
43109    "application/vnd.dvb.iptv.alfec-enhancement": { "source": "iana" },
43110    "application/vnd.dvb.notif-aggregate-root+xml": { "source": "iana", "compressible": true },
43111    "application/vnd.dvb.notif-container+xml": { "source": "iana", "compressible": true },
43112    "application/vnd.dvb.notif-generic+xml": { "source": "iana", "compressible": true },
43113    "application/vnd.dvb.notif-ia-msglist+xml": { "source": "iana", "compressible": true },
43114    "application/vnd.dvb.notif-ia-registration-request+xml": { "source": "iana", "compressible": true },
43115    "application/vnd.dvb.notif-ia-registration-response+xml": { "source": "iana", "compressible": true },
43116    "application/vnd.dvb.notif-init+xml": { "source": "iana", "compressible": true },
43117    "application/vnd.dvb.pfr": { "source": "iana" },
43118    "application/vnd.dvb.service": { "source": "iana", "extensions": ["svc"] },
43119    "application/vnd.dxr": { "source": "iana" },
43120    "application/vnd.dynageo": { "source": "iana", "extensions": ["geo"] },
43121    "application/vnd.dzr": { "source": "iana" },
43122    "application/vnd.easykaraoke.cdgdownload": { "source": "iana" },
43123    "application/vnd.ecdis-update": { "source": "iana" },
43124    "application/vnd.ecip.rlp": { "source": "iana" },
43125    "application/vnd.eclipse.ditto+json": { "source": "iana", "compressible": true },
43126    "application/vnd.ecowin.chart": { "source": "iana", "extensions": ["mag"] },
43127    "application/vnd.ecowin.filerequest": { "source": "iana" },
43128    "application/vnd.ecowin.fileupdate": { "source": "iana" },
43129    "application/vnd.ecowin.series": { "source": "iana" },
43130    "application/vnd.ecowin.seriesrequest": { "source": "iana" },
43131    "application/vnd.ecowin.seriesupdate": { "source": "iana" },
43132    "application/vnd.efi.img": { "source": "iana" },
43133    "application/vnd.efi.iso": { "source": "iana" },
43134    "application/vnd.emclient.accessrequest+xml": { "source": "iana", "compressible": true },
43135    "application/vnd.enliven": { "source": "iana", "extensions": ["nml"] },
43136    "application/vnd.enphase.envoy": { "source": "iana" },
43137    "application/vnd.eprints.data+xml": { "source": "iana", "compressible": true },
43138    "application/vnd.epson.esf": { "source": "iana", "extensions": ["esf"] },
43139    "application/vnd.epson.msf": { "source": "iana", "extensions": ["msf"] },
43140    "application/vnd.epson.quickanime": { "source": "iana", "extensions": ["qam"] },
43141    "application/vnd.epson.salt": { "source": "iana", "extensions": ["slt"] },
43142    "application/vnd.epson.ssf": { "source": "iana", "extensions": ["ssf"] },
43143    "application/vnd.ericsson.quickcall": { "source": "iana" },
43144    "application/vnd.espass-espass+zip": { "source": "iana", "compressible": false },
43145    "application/vnd.eszigno3+xml": { "source": "iana", "compressible": true, "extensions": ["es3", "et3"] },
43146    "application/vnd.etsi.aoc+xml": { "source": "iana", "compressible": true },
43147    "application/vnd.etsi.asic-e+zip": { "source": "iana", "compressible": false },
43148    "application/vnd.etsi.asic-s+zip": { "source": "iana", "compressible": false },
43149    "application/vnd.etsi.cug+xml": { "source": "iana", "compressible": true },
43150    "application/vnd.etsi.iptvcommand+xml": { "source": "iana", "compressible": true },
43151    "application/vnd.etsi.iptvdiscovery+xml": { "source": "iana", "compressible": true },
43152    "application/vnd.etsi.iptvprofile+xml": { "source": "iana", "compressible": true },
43153    "application/vnd.etsi.iptvsad-bc+xml": { "source": "iana", "compressible": true },
43154    "application/vnd.etsi.iptvsad-cod+xml": { "source": "iana", "compressible": true },
43155    "application/vnd.etsi.iptvsad-npvr+xml": { "source": "iana", "compressible": true },
43156    "application/vnd.etsi.iptvservice+xml": { "source": "iana", "compressible": true },
43157    "application/vnd.etsi.iptvsync+xml": { "source": "iana", "compressible": true },
43158    "application/vnd.etsi.iptvueprofile+xml": { "source": "iana", "compressible": true },
43159    "application/vnd.etsi.mcid+xml": { "source": "iana", "compressible": true },

43160    "application/vnd.etsi.mheg5": { "source": "iana" },
43161    "application/vnd.etsi.overload-control-policy-dataset+xml": { "source": "iana", "compressible": true },
43162    "application/vnd.etsi.pstn+xml": { "source": "iana", "compressible": true },
43163    "application/vnd.etsi.sci+xml": { "source": "iana", "compressible": true },
43164    "application/vnd.etsi.simservs+xml": { "source": "iana", "compressible": true },
43165    "application/vnd.etsi.timestamp-token": { "source": "iana" },
43166    "application/vnd.etsi.tsl+xml": { "source": "iana", "compressible": true },
43167    "application/vnd.etsi.tsl.der": { "source": "iana" },
43168    "application/vnd.eu.kasparian.car+json": { "source": "iana", "compressible": true },
43169    "application/vnd.eudora.data": { "source": "iana" },
43170    "application/vnd.evolv.ecig.profile": { "source": "iana" },
43171    "application/vnd.evolv.ecig.settings": { "source": "iana" },
43172    "application/vnd.evolv.ecig.theme": { "source": "iana" },
43173    "application/vnd.exstream-empower+zip": { "source": "iana", "compressible": false },
43174    "application/vnd.exstream-package": { "source": "iana" },
43175    "application/vnd.ezpix-album": { "source": "iana", "extensions": ["ez2"] },
43176    "application/vnd.ezpix-package": { "source": "iana", "extensions": ["ez3"] },
43177    "application/vnd.f-secure.mobile": { "source": "iana" },
43178    "application/vnd.familysearch.gedcom+zip": { "source": "iana", "compressible": false },
43179    "application/vnd.fastcopy-disk-image": { "source": "iana" },
43180    "application/vnd.fdf": { "source": "iana", "extensions": ["fdf"] },
43181    "application/vnd.fdsn.mseed": { "source": "iana", "extensions": ["mseed"] },
43182    "application/vnd.fdsn.seed": { "source": "iana", "extensions": ["seed", "dataless"] },
43183    "application/vnd.ffsns": { "source": "iana" },
43184    "application/vnd.ficlab.flb+zip": { "source": "iana", "compressible": false },
43185    "application/vnd.filmit.zfc": { "source": "iana" },
43186    "application/vnd.fints": { "source": "iana" },
43187    "application/vnd.firemonkeys.cloudcell": { "source": "iana" },
43188    "application/vnd.flographit": { "source": "iana", "extensions": ["gph"] },

43189    "application/vnd.fluxtime.clip": { "source": "iana", "extensions": ["ftc"] },
43190    "application/vnd.font-fontforge-sfd": { "source": "iana" },
43191    "application/vnd.framemaker": { "source": "iana", "extensions": ["fm", "frame", "maker", "book"] },
43192    "application/vnd.frogans.fnc": { "source": "iana", "extensions": ["fnc"] },
43193    "application/vnd.frogans.ltf": { "source": "iana", "extensions": ["ltf"] },
43194    "application/vnd.fsc.weblaunch": { "source": "iana", "extensions": ["fsc"] },
43195    "application/vnd.fujifilm.fb.docuworks": { "source": "iana" },
43196    "application/vnd.fujifilm.fb.docuworks.binder": { "source": "iana" },
43197    "application/vnd.fujifilm.fb.docuworks.container": { "source": "iana" },
43198    "application/vnd.fujifilm.fb.jfi+xml": { "source": "iana", "compressible": true },
43199    "application/vnd.fujitsu.oasys": { "source": "iana", "extensions": ["oas"] },
43200    "application/vnd.fujitsu.oasys2": { "source": "iana", "extensions": ["oa2"] },
43201    "application/vnd.fujitsu.oasys3": { "source": "iana", "extensions": ["oa3"] },
43202    "application/vnd.fujitsu.oasysgp": { "source": "iana", "extensions": ["fg5"] },
43203    "application/vnd.fujitsu.oasysprs": { "source": "iana", "extensions": ["bh2"] },
43204    "application/vnd.fujixerox.art-ex": { "source": "iana" },
43205    "application/vnd.fujixerox.art4": { "source": "iana" },
43206    "application/vnd.fujixerox.ddd": { "source": "iana", "extensions": ["ddd"] },
43207    "application/vnd.fujixerox.docuworks": { "source": "iana", "extensions": ["xdw"] },
43208    "application/vnd.fujixerox.docuworks.binder": { "source": "iana", "extensions": ["xbd"] },
43209    "application/vnd.fujixerox.docuworks.container": { "source": "iana" },
43210    "application/vnd.fujixerox.hbpl": { "source": "iana" },
43211    "application/vnd.fut-misnet": { "source": "iana" },
43212    "application/vnd.futoin+cbor": { "source": "iana" },
43213    "application/vnd.futoin+json": { "source": "iana", "compressible": true },
43214    "application/vnd.fuzzysheet": { "source": "iana", "extensions": ["fzs"] },
43215    "application/vnd.genomatix.tuxedo": { "source": "iana", "extensions": ["txd"] },
43216    "application/vnd.gentics.grd+json": { "source": "iana", "compressible": true },
43217    "application/vnd.geo+json": { "source": "iana", "compressible": true },
43218    "application/vnd.geocube+xml": { "source": "iana", "compressible": true },
43219    "application/vnd.geogebra.file": { "source": "iana", "extensions": ["ggb"] },
43220    "application/vnd.geogebra.slides": { "source": "iana" },
43221    "application/vnd.geogebra.tool": { "source": "iana", "extensions": ["ggt"] },
43222    "application/vnd.geometry-explorer": { "source": "iana", "extensions": ["gex", "gre"] },
43223    "application/vnd.geonext": { "source": "iana", "extensions": ["gxt"] },
43224    "application/vnd.geoplan": { "source": "iana", "extensions": ["g2w"] },
43225    "application/vnd.geospace": { "source": "iana", "extensions": ["g3w"] },
43226    "application/vnd.gerber": { "source": "iana" },
43227    "application/vnd.globalplatform.card-content-mgt": { "source": "iana" },
43228    "application/vnd.globalplatform.card-content-mgt-response": { "source": "iana" },
43229    "application/vnd.gmx": { "source": "iana", "extensions": ["gmx"] },
43230    "application/vnd.google-apps.document": { "compressible": false, "extensions": ["gdoc"] },
43231    "application/vnd.google-apps.presentation": { "compressible": false, "extensions": ["gslides"] },

43232    "application/vnd.google-apps.spreadsheet": { "compressible": false, "extensions": ["gsheet"] },
43233    "application/vnd.google-earth.kml+xml": { "source": "iana", "compressible": true, "extensions": ["kml"] },
43234    "application/vnd.google-earth.kmz": { "source": "iana", "compressible": false, "extensions": ["kmz"] },
43235    "application/vnd.gov.sk.e-form+xml": { "source": "iana", "compressible": true },
43236    "application/vnd.gov.sk.e-form+zip": { "source": "iana", "compressible": false },
43237    "application/vnd.gov.sk.xmldatacontainer+xml": { "source": "iana", "compressible": true },
43238    "application/vnd.grafeq": { "source": "iana", "extensions": ["gqf", "gqs"] },
43239    "application/vnd.gridmp": { "source": "iana" },
43240    "application/vnd.groove-account": { "source": "iana", "extensions": ["gac"] },
43241    "application/vnd.groove-help": { "source": "iana", "extensions": ["ghf"] },
43242    "application/vnd.groove-identity-message": { "source": "iana", "extensions": ["gim"] },
43243    "application/vnd.groove-injector": { "source": "iana", "extensions": ["grv"] },
43244    "application/vnd.groove-tool-message": { "source": "iana", "extensions": ["gtm"] },
43245    "application/vnd.groove-tool-template": { "source": "iana", "extensions": ["tpl"] },
43246    "application/vnd.groove-vcard": { "source": "iana", "extensions": ["vcg"] },
43247    "application/vnd.hal+json": { "source": "iana", "compressible": true },
43248    "application/vnd.hal+xml": { "source": "iana", "compressible": true, "extensions": ["hal"] },
43249    "application/vnd.handheld-entertainment+xml": { "source": "iana", "compressible": true, "extensions": ["zmm"] },
43250    "application/vnd.hbci": { "source": "iana", "extensions": ["hbci"] },
43251    "application/vnd.hc+json": { "source": "iana", "compressible": true },
43252    "application/vnd.hcl-bireports": { "source": "iana" },
43253    "application/vnd.hdt": { "source": "iana" },
43254    "application/vnd.heroku+json": { "source": "iana", "compressible": true },
43255    "application/vnd.hhe.lesson-player": { "source": "iana", "extensions": ["les"] },
43256    "application/vnd.hl7cda+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43257    "application/vnd.hl7v2+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43258    "application/vnd.hp-hpgl": { "source": "iana", "extensions": ["hpgl"] },
43259    "application/vnd.hp-hpid": { "source": "iana", "extensions": ["hpid"] },
43260    "application/vnd.hp-hps": { "source": "iana", "extensions": ["hps"] },
43261    "application/vnd.hp-jlyt": { "source": "iana", "extensions": ["jlt"] },
43262    "application/vnd.hp-pcl": { "source": "iana", "extensions": ["pcl"] },
43263    "application/vnd.hp-pclxl": { "source": "iana", "extensions": ["pclxl"] },
43264    "application/vnd.httphone": { "source": "iana" },

43265    "application/vnd.hydrostatix.sof-data": { "source": "iana", "extensions": ["sfd-hdstx"] },
43266    "application/vnd.hyper+json": { "source": "iana", "compressible": true },
43267    "application/vnd.hyper-item+json": { "source": "iana", "compressible": true },
43268    "application/vnd.hyperdrive+json": { "source": "iana", "compressible": true },
43269    "application/vnd.hzn-3d-crossword": { "source": "iana" },
43270    "application/vnd.ibm.afplinedata": { "source": "iana" },
43271    "application/vnd.ibm.electronic-media": { "source": "iana" },
43272    "application/vnd.ibm.minipay": { "source": "iana", "extensions": ["mpy"] },
43273    "application/vnd.ibm.modcap": { "source": "iana", "extensions": ["afp", "listafp", "list3820"] },
43274    "application/vnd.ibm.rights-management": { "source": "iana", "extensions": ["irm"] },
43275    "application/vnd.ibm.secure-container": { "source": "iana", "extensions": ["sc"] },
43276    "application/vnd.iccprofile": { "source": "iana", "extensions": ["icc", "icm"] },
43277    "application/vnd.ieee.1905": { "source": "iana" },
43278    "application/vnd.igloader": { "source": "iana", "extensions": ["igl"] },
43279    "application/vnd.imagemeter.folder+zip": { "source": "iana", "compressible": false },
43280    "application/vnd.imagemeter.image+zip": { "source": "iana", "compressible": false },

43281    "application/vnd.immervision-ivp": { "source": "iana", "extensions": ["ivp"] },
43282    "application/vnd.immervision-ivu": { "source": "iana", "extensions": ["ivu"] },
43283    "application/vnd.ims.imsccv1p1": { "source": "iana" },
43284    "application/vnd.ims.imsccv1p2": { "source": "iana" },
43285    "application/vnd.ims.imsccv1p3": { "source": "iana" },
43286    "application/vnd.ims.lis.v2.result+json": { "source": "iana", "compressible": true },
43287    "application/vnd.ims.lti.v2.toolconsumerprofile+json": { "source": "iana", "compressible": true },
43288    "application/vnd.ims.lti.v2.toolproxy+json": { "source": "iana", "compressible": true },
43289    "application/vnd.ims.lti.v2.toolproxy.id+json": { "source": "iana", "compressible": true },
43290    "application/vnd.ims.lti.v2.toolsettings+json": { "source": "iana", "compressible": true },
43291    "application/vnd.ims.lti.v2.toolsettings.simple+json": { "source": "iana", "compressible": true },
43292    "application/vnd.informedcontrol.rms+xml": { "source": "iana", "compressible": true },
43293    "application/vnd.informix-visionary": { "source": "iana" },
43294    "application/vnd.infotech.project": { "source": "iana" },
43295    "application/vnd.infotech.project+xml": { "source": "iana", "compressible": true },
43296    "application/vnd.innopath.wamp.notification": { "source": "iana" },
43297    "application/vnd.insors.igm": { "source": "iana", "extensions": ["igm"] },
43298    "application/vnd.intercon.formnet": { "source": "iana", "extensions": ["xpw", "xpx"] },

43299    "application/vnd.intergeo": { "source": "iana", "extensions": ["i2g"] },
43300    "application/vnd.intertrust.digibox": { "source": "iana" },
43301    "application/vnd.intertrust.nncp": { "source": "iana" },
43302    "application/vnd.intu.qbo": { "source": "iana", "extensions": ["qbo"] },
43303    "application/vnd.intu.qfx": { "source": "iana", "extensions": ["qfx"] },
43304    "application/vnd.iptc.g2.catalogitem+xml": { "source": "iana", "compressible": true },
43305    "application/vnd.iptc.g2.conceptitem+xml": { "source": "iana", "compressible": true },
43306    "application/vnd.iptc.g2.knowledgeitem+xml": { "source": "iana", "compressible": true },
43307    "application/vnd.iptc.g2.newsitem+xml": { "source": "iana", "compressible": true },
43308    "application/vnd.iptc.g2.newsmessage+xml": { "source": "iana", "compressible": true },
43309    "application/vnd.iptc.g2.packageitem+xml": { "source": "iana", "compressible": true },
43310    "application/vnd.iptc.g2.planningitem+xml": { "source": "iana", "compressible": true },
43311    "application/vnd.ipunplugged.rcprofile": { "source": "iana", "extensions": ["rcprofile"] },
43312    "application/vnd.irepository.package+xml": { "source": "iana", "compressible": true, "extensions": ["irp"] },
43313    "application/vnd.is-xpr": { "source": "iana", "extensions": ["xpr"] },
43314    "application/vnd.isac.fcs": { "source": "iana", "extensions": ["fcs"] },
43315    "application/vnd.iso11783-10+zip": { "source": "iana", "compressible": false },
43316    "application/vnd.jam": { "source": "iana", "extensions": ["jam"] },
43317    "application/vnd.japannet-directory-service": { "source": "iana" },
43318    "application/vnd.japannet-jpnstore-wakeup": { "source": "iana" },
43319    "application/vnd.japannet-payment-wakeup": { "source": "iana" },
43320    "application/vnd.japannet-registration": { "source": "iana" },
43321    "application/vnd.japannet-registration-wakeup": { "source": "iana" },
43322    "application/vnd.japannet-setstore-wakeup": { "source": "iana" },
43323    "application/vnd.japannet-verification": { "source": "iana" },
43324    "application/vnd.japannet-verification-wakeup": { "source": "iana" },
43325    "application/vnd.jcp.javame.midlet-rms": { "source": "iana", "extensions": ["rms"] },
43326    "application/vnd.jisp": { "source": "iana", "extensions": ["jisp"] },
43327    "application/vnd.joost.joda-archive": { "source": "iana", "extensions": ["joda"] },
43328    "application/vnd.jsk.isdn-ngn": { "source": "iana" },
43329    "application/vnd.kahootz": { "source": "iana", "extensions": ["ktz", "ktr"] },
43330    "application/vnd.kde.karbon": { "source": "iana", "extensions": ["karbon"] },
43331    "application/vnd.kde.kchart": { "source": "iana", "extensions": ["chrt"] },
43332    "application/vnd.kde.kformula": { "source": "iana", "extensions": ["kfo"] },
43333    "application/vnd.kde.kivio": { "source": "iana", "extensions": ["flw"] },
43334    "application/vnd.kde.kontour": { "source": "iana", "extensions": ["kon"] },
43335    "application/vnd.kde.kpresenter": { "source": "iana", "extensions": ["kpr", "kpt"] },
43336    "application/vnd.kde.kspread": { "source": "iana", "extensions": ["ksp"] },
43337    "application/vnd.kde.kword": { "source": "iana", "extensions": ["kwd", "kwt"] },
43338    "application/vnd.kenameaapp": { "source": "iana", "extensions": ["htke"] },
43339    "application/vnd.kidspiration": { "source": "iana", "extensions": ["kia"] },
43340    "application/vnd.kinar": { "source": "iana", "extensions": ["kne", "knp"] },
43341    "application/vnd.koan": { "source": "iana", "extensions": ["skp", "skd", "skt", "skm"] },
43342    "application/vnd.kodak-descriptor": { "source": "iana", "extensions": ["sse"] },
43343    "application/vnd.las": { "source": "iana" },
43344    "application/vnd.las.las+json": { "source": "iana", "compressible": true },
43345    "application/vnd.las.las+xml": { "source": "iana", "compressible": true, "extensions": ["lasxml"] },
43346    "application/vnd.laszip": { "source": "iana" },
43347    "application/vnd.leap+json": { "source": "iana", "compressible": true },
43348    "application/vnd.liberty-request+xml": { "source": "iana", "compressible": true },
43349    "application/vnd.llamagraphics.life-balance.desktop": { "source": "iana", "extensions": ["lbd"] },
43350    "application/vnd.llamagraphics.life-balance.exchange+xml": { "source": "iana", "compressible": true, "extensions": ["lbe"] },

43351    "application/vnd.logipipe.circuit+zip": { "source": "iana", "compressible": false },
43352    "application/vnd.loom": { "source": "iana" },
43353    "application/vnd.lotus-1-2-3": { "source": "iana", "extensions": ["123"] },
43354    "application/vnd.lotus-approach": { "source": "iana", "extensions": ["apr"] },
43355    "application/vnd.lotus-freelance": { "source": "iana", "extensions": ["pre"] },
43356    "application/vnd.lotus-notes": { "source": "iana", "extensions": ["nsf"] },
43357    "application/vnd.lotus-organizer": { "source": "iana", "extensions": ["org"] },
43358    "application/vnd.lotus-screencam": { "source": "iana", "extensions": ["scm"] },
43359    "application/vnd.lotus-wordpro": { "source": "iana", "extensions": ["lwp"] },
43360    "application/vnd.macports.portpkg": { "source": "iana", "extensions": ["portpkg"] },
43361    "application/vnd.mapbox-vector-tile": { "source": "iana", "extensions": ["mvt"] },
43362    "application/vnd.marlin.drm.actiontoken+xml": { "source": "iana", "compressible": true },
43363    "application/vnd.marlin.drm.conftoken+xml": { "source": "iana", "compressible": true },
43364    "application/vnd.marlin.drm.license+xml": { "source": "iana", "compressible": true },
43365    "application/vnd.marlin.drm.mdcf": { "source": "iana" },
43366    "application/vnd.mason+json": { "source": "iana", "compressible": true },
43367    "application/vnd.maxar.archive.3tz+zip": { "source": "iana", "compressible": false },
43368    "application/vnd.maxmind.maxmind-db": { "source": "iana" },
43369    "application/vnd.mcd": { "source": "iana", "extensions": ["mcd"] },

vendor: 6,164 bytes, lines 43370-43444

43370    "application/vnd.medcalcdata": { "source": "iana", "extensions": ["mc1"] },
43371    "application/vnd.mediastation.cdkey": { "source": "iana", "extensions": ["cdkey"] },
43372    "application/vnd.meridian-slingshot": { "source": "iana" },
43373    "application/vnd.mfer": { "source": "iana", "extensions": ["mwf"] },
43374    "application/vnd.mfmp": { "source": "iana", "extensions": ["mfm"] },
43375    "application/vnd.micro+json": { "source": "iana", "compressible": true },
43376    "application/vnd.micrografx.flo": { "source": "iana", "extensions": ["flo"] },
43377    "application/vnd.micrografx.igx": { "source": "iana", "extensions": ["igx"] },
43378    "application/vnd.microsoft.portable-executable": { "source": "iana" },
43379    "application/vnd.microsoft.windows.thumbnail-cache": { "source": "iana" },
43380    "application/vnd.miele+json": { "source": "iana", "compressible": true },
43381    "application/vnd.mif": { "source": "iana", "extensions": ["mif"] },
43382    "application/vnd.minisoft-hp3000-save": { "source": "iana" },
43383    "application/vnd.mitsubishi.misty-guard.trustweb": { "source": "iana" },
43384    "application/vnd.mobius.daf": { "source": "iana", "extensions": ["daf"] },
43385    "application/vnd.mobius.dis": { "source": "iana", "extensions": ["dis"] },
43386    "application/vnd.mobius.mbk": { "source": "iana", "extensions": ["mbk"] },
43387    "application/vnd.mobius.mqy": { "source": "iana", "extensions": ["mqy"] },
43388    "application/vnd.mobius.msl": { "source": "iana", "extensions": ["msl"] },
43389    "application/vnd.mobius.plc": { "source": "iana", "extensions": ["plc"] },
43390    "application/vnd.mobius.txf": { "source": "iana", "extensions": ["txf"] },
43391    "application/vnd.mophun.application": { "source": "iana", "extensions": ["mpn"] },
43392    "application/vnd.mophun.certificate": { "source": "iana", "extensions": ["mpc"] },
43393    "application/vnd.motorola.flexsuite": { "source": "iana" },
43394    "application/vnd.motorola.flexsuite.adsi": { "source": "iana" },
43395    "application/vnd.motorola.flexsuite.fis": { "source": "iana" },
43396    "application/vnd.motorola.flexsuite.gotap": { "source": "iana" },
43397    "application/vnd.motorola.flexsuite.kmr": { "source": "iana" },
43398    "application/vnd.motorola.flexsuite.ttc": { "source": "iana" },
43399    "application/vnd.motorola.flexsuite.wem": { "source": "iana" },
43400    "application/vnd.motorola.iprm": { "source": "iana" },
43401    "application/vnd.mozilla.xul+xml": { "source": "iana", "compressible": true, "extensions": ["xul"] },
43402    "application/vnd.ms-3mfdocument": { "source": "iana" },
43403    "application/vnd.ms-artgalry": { "source": "iana", "extensions": ["cil"] },
43404    "application/vnd.ms-asf": { "source": "iana" },
43405    "application/vnd.ms-cab-compressed": { "source": "iana", "extensions": ["cab"] },
43406    "application/vnd.ms-color.iccprofile": { "source": "apache" },
43407    "application/vnd.ms-excel": { "source": "iana", "compressible": false, "extensions": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] },
43408    "application/vnd.ms-excel.addin.macroenabled.12": { "source": "iana", "extensions": ["xlam"] },
43409    "application/vnd.ms-excel.sheet.binary.macroenabled.12": { "source": "iana", "extensions": ["xlsb"] },
43410    "application/vnd.ms-excel.sheet.macroenabled.12": { "source": "iana", "extensions": ["xlsm"] },
43411    "application/vnd.ms-excel.template.macroenabled.12": { "source": "iana", "extensions": ["xltm"] },
43412    "application/vnd.ms-fontobject": { "source": "iana", "compressible": true, "extensions": ["eot"] },
43413    "application/vnd.ms-htmlhelp": { "source": "iana", "extensions": ["chm"] },
43414    "application/vnd.ms-ims": { "source": "iana", "extensions": ["ims"] },
43415    "application/vnd.ms-lrm": { "source": "iana", "extensions": ["lrm"] },
43416    "application/vnd.ms-office.activex+xml": { "source": "iana", "compressible": true },
43417    "application/vnd.ms-officetheme": { "source": "iana", "extensions": ["thmx"] },
43418    "application/vnd.ms-opentype": { "source": "apache", "compressible": true },
43419    "application/vnd.ms-outlook": { "compressible": false, "extensions": ["msg"] },
43420    "application/vnd.ms-package.obfuscated-opentype": { "source": "apache" },
43421    "application/vnd.ms-pki.seccat": { "source": "apache", "extensions": ["cat"] },
43422    "application/vnd.ms-pki.stl": { "source": "apache", "extensions": ["stl"] },
43423    "application/vnd.ms-playready.initiator+xml": { "source": "iana", "compressible": true },
43424    "application/vnd.ms-powerpoint": { "source": "iana", "compressible": false, "extensions": ["ppt", "pps", "pot"] },
43425    "application/vnd.ms-powerpoint.addin.macroenabled.12": { "source": "iana", "extensions": ["ppam"] },
43426    "application/vnd.ms-powerpoint.presentation.macroenabled.12": { "source": "iana", "extensions": ["pptm"] },
43427    "application/vnd.ms-powerpoint.slide.macroenabled.12": { "source": "iana", "extensions": ["sldm"] },
43428    "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { "source": "iana", "extensions": ["ppsm"] },
43429    "application/vnd.ms-powerpoint.template.macroenabled.12": { "source": "iana", "extensions": ["potm"] },
43430    "application/vnd.ms-printdevicecapabilities+xml": { "source": "iana", "compressible": true },
43431    "application/vnd.ms-printing.printticket+xml": { "source": "apache", "compressible": true },
43432    "application/vnd.ms-printschematicket+xml": { "source": "iana", "compressible": true },
43433    "application/vnd.ms-project": { "source": "iana", "extensions": ["mpp", "mpt"] },
43434    "application/vnd.ms-tnef": { "source": "iana" },
43435    "application/vnd.ms-windows.devicepairing": { "source": "iana" },
43436    "application/vnd.ms-windows.nwprinting.oob": { "source": "iana" },
43437    "application/vnd.ms-windows.printerpairing": { "source": "iana" },
43438    "application/vnd.ms-windows.wsd.oob": { "source": "iana" },
43439    "application/vnd.ms-wmdrm.lic-chlg-req": { "source": "iana" },
43440    "application/vnd.ms-wmdrm.lic-resp": { "source": "iana" },
43441    "application/vnd.ms-wmdrm.meter-chlg-req": { "source": "iana" },
43442    "application/vnd.ms-wmdrm.meter-resp": { "source": "iana" },
43443    "application/vnd.ms-word.document.macroenabled.12": { "source": "iana", "extensions": ["docm"] },
43444    "application/vnd.ms-word.template.macroenabled.12": { "source": "iana", "extensions": ["dotm"] },

43445    "application/vnd.ms-works": { "source": "iana", "extensions": ["wps", "wks", "wcm", "wdb"] },
43446    "application/vnd.ms-wpl": { "source": "iana", "extensions": ["wpl"] },
43447    "application/vnd.ms-xpsdocument": { "source": "iana", "compressible": false, "extensions": ["xps"] },
43448    "application/vnd.msa-disk-image": { "source": "iana" },
43449    "application/vnd.mseq": { "source": "iana", "extensions": ["mseq"] },
43450    "application/vnd.msign": { "source": "iana" },
43451    "application/vnd.multiad.creator": { "source": "iana" },
43452    "application/vnd.multiad.creator.cif": { "source": "iana" },
43453    "application/vnd.music-niff": { "source": "iana" },
43454    "application/vnd.musician": { "source": "iana", "extensions": ["mus"] },
43455    "application/vnd.muvee.style": { "source": "iana", "extensions": ["msty"] },
43456    "application/vnd.mynfc": { "source": "iana", "extensions": ["taglet"] },
43457    "application/vnd.nacamar.ybrid+json": { "source": "iana", "compressible": true },
43458    "application/vnd.ncd.control": { "source": "iana" },
43459    "application/vnd.ncd.reference": { "source": "iana" },
43460    "application/vnd.nearst.inv+json": { "source": "iana", "compressible": true },
43461    "application/vnd.nebumind.line": { "source": "iana" },
43462    "application/vnd.nervana": { "source": "iana" },
43463    "application/vnd.netfpx": { "source": "iana" },
43464    "application/vnd.neurolanguage.nlu": { "source": "iana", "extensions": ["nlu"] },
43465    "application/vnd.nimn": { "source": "iana" },
43466    "application/vnd.nintendo.nitro.rom": { "source": "iana" },
43467    "application/vnd.nintendo.snes.rom": { "source": "iana" },
43468    "application/vnd.nitf": { "source": "iana", "extensions": ["ntf", "nitf"] },
43469    "application/vnd.noblenet-directory": { "source": "iana", "extensions": ["nnd"] },
43470    "application/vnd.noblenet-sealer": { "source": "iana", "extensions": ["nns"] },
43471    "application/vnd.noblenet-web": { "source": "iana", "extensions": ["nnw"] },
43472    "application/vnd.nokia.catalogs": { "source": "iana" },
43473    "application/vnd.nokia.conml+wbxml": { "source": "iana" },
43474    "application/vnd.nokia.conml+xml": { "source": "iana", "compressible": true },
43475    "application/vnd.nokia.iptv.config+xml": { "source": "iana", "compressible": true },
43476    "application/vnd.nokia.isds-radio-presets": { "source": "iana" },
43477    "application/vnd.nokia.landmark+wbxml": { "source": "iana" },
43478    "application/vnd.nokia.landmark+xml": { "source": "iana", "compressible": true },
43479    "application/vnd.nokia.landmarkcollection+xml": { "source": "iana", "compressible": true },
43480    "application/vnd.nokia.n-gage.ac+xml": { "source": "iana", "compressible": true, "extensions": ["ac"] },
43481    "application/vnd.nokia.n-gage.data": { "source": "iana", "extensions": ["ngdat"] },
43482    "application/vnd.nokia.n-gage.symbian.install": { "source": "iana", "extensions": ["n-gage"] },
43483    "application/vnd.nokia.ncd": { "source": "iana" },
43484    "application/vnd.nokia.pcd+wbxml": { "source": "iana" },
43485    "application/vnd.nokia.pcd+xml": { "source": "iana", "compressible": true },
43486    "application/vnd.nokia.radio-preset": { "source": "iana", "extensions": ["rpst"] },
43487    "application/vnd.nokia.radio-presets": { "source": "iana", "extensions": ["rpss"] },
43488    "application/vnd.novadigm.edm": { "source": "iana", "extensions": ["edm"] },
43489    "application/vnd.novadigm.edx": { "source": "iana", "extensions": ["edx"] },
43490    "application/vnd.novadigm.ext": { "source": "iana", "extensions": ["ext"] },
43491    "application/vnd.ntt-local.content-share": { "source": "iana" },
43492    "application/vnd.ntt-local.file-transfer": { "source": "iana" },
43493    "application/vnd.ntt-local.ogw_remote-access": { "source": "iana" },
43494    "application/vnd.ntt-local.sip-ta_remote": { "source": "iana" },
43495    "application/vnd.ntt-local.sip-ta_tcp_stream": { "source": "iana" },
43496    "application/vnd.oasis.opendocument.chart": { "source": "iana", "extensions": ["odc"] },
43497    "application/vnd.oasis.opendocument.chart-template": { "source": "iana", "extensions": ["otc"] },
43498    "application/vnd.oasis.opendocument.database": { "source": "iana", "extensions": ["odb"] },

43499    "application/vnd.oasis.opendocument.formula": { "source": "iana", "extensions": ["odf"] },
43500    "application/vnd.oasis.opendocument.formula-template": { "source": "iana", "extensions": ["odft"] },
43501    "application/vnd.oasis.opendocument.graphics": { "source": "iana", "compressible": false, "extensions": ["odg"] },
43502    "application/vnd.oasis.opendocument.graphics-template": { "source": "iana", "extensions": ["otg"] },
43503    "application/vnd.oasis.opendocument.image": { "source": "iana", "extensions": ["odi"] },
43504    "application/vnd.oasis.opendocument.image-template": { "source": "iana", "extensions": ["oti"] },
43505    "application/vnd.oasis.opendocument.presentation": { "source": "iana", "compressible": false, "extensions": ["odp"] },
43506    "application/vnd.oasis.opendocument.presentation-template": { "source": "iana", "extensions": ["otp"] },
43507    "application/vnd.oasis.opendocument.spreadsheet": { "source": "iana", "compressible": false, "extensions": ["ods"] },
43508    "application/vnd.oasis.opendocument.spreadsheet-template": { "source": "iana", "extensions": ["ots"] },
43509    "application/vnd.oasis.opendocument.text": { "source": "iana", "compressible": false, "extensions": ["odt"] },
43510    "application/vnd.oasis.opendocument.text-master": { "source": "iana", "extensions": ["odm"] },
43511    "application/vnd.oasis.opendocument.text-template": { "source": "iana", "extensions": ["ott"] },
43512    "application/vnd.oasis.opendocument.text-web": { "source": "iana", "extensions": ["oth"] },
43513    "application/vnd.obn": { "source": "iana" },
43514    "application/vnd.ocf+cbor": { "source": "iana" },
43515    "application/vnd.oci.image.manifest.v1+json": { "source": "iana", "compressible": true },
43516    "application/vnd.oftn.l10n+json": { "source": "iana", "compressible": true },
43517    "application/vnd.oipf.contentaccessdownload+xml": { "source": "iana", "compressible": true },
43518    "application/vnd.oipf.contentaccessstreaming+xml": { "source": "iana", "compressible": true },
43519    "application/vnd.oipf.cspg-hexbinary": { "source": "iana" },
43520    "application/vnd.oipf.dae.svg+xml": { "source": "iana", "compressible": true },
43521    "application/vnd.oipf.dae.xhtml+xml": { "source": "iana", "compressible": true },
43522    "application/vnd.oipf.mippvcontrolmessage+xml": { "source": "iana", "compressible": true },
43523    "application/vnd.oipf.pae.gem": { "source": "iana" },
43524    "application/vnd.oipf.spdiscovery+xml": { "source": "iana", "compressible": true },
43525    "application/vnd.oipf.spdlist+xml": { "source": "iana", "compressible": true },
43526    "application/vnd.oipf.ueprofile+xml": { "source": "iana", "compressible": true },
43527    "application/vnd.oipf.userprofile+xml": { "source": "iana", "compressible": true },
43528    "application/vnd.olpc-sugar": { "source": "iana", "extensions": ["xo"] },
43529    "application/vnd.oma-scws-config": { "source": "iana" },
43530    "application/vnd.oma-scws-http-request": { "source": "iana" },
43531    "application/vnd.oma-scws-http-response": { "source": "iana" },
43532    "application/vnd.oma.bcast.associated-procedure-parameter+xml": { "source": "iana", "compressible": true },
43533    "application/vnd.oma.bcast.drm-trigger+xml": { "source": "iana", "compressible": true },
43534    "application/vnd.oma.bcast.imd+xml": { "source": "iana", "compressible": true },
43535    "application/vnd.oma.bcast.ltkm": { "source": "iana" },
43536    "application/vnd.oma.bcast.notification+xml": { "source": "iana", "compressible": true },
43537    "application/vnd.oma.bcast.provisioningtrigger": { "source": "iana" },
43538    "application/vnd.oma.bcast.sgboot": { "source": "iana" },
43539    "application/vnd.oma.bcast.sgdd+xml": { "source": "iana", "compressible": true },
43540    "application/vnd.oma.bcast.sgdu": { "source": "iana" },
43541    "application/vnd.oma.bcast.simple-symbol-container": { "source": "iana" },
43542    "application/vnd.oma.bcast.smartcard-trigger+xml": { "source": "iana", "compressible": true },
43543    "application/vnd.oma.bcast.sprov+xml": { "source": "iana", "compressible": true },
43544    "application/vnd.oma.bcast.stkm": { "source": "iana" },
43545    "application/vnd.oma.cab-address-book+xml": { "source": "iana", "compressible": true },
43546    "application/vnd.oma.cab-feature-handler+xml": { "source": "iana", "compressible": true },
43547    "application/vnd.oma.cab-pcc+xml": { "source": "iana", "compressible": true },
43548    "application/vnd.oma.cab-subs-invite+xml": { "source": "iana", "compressible": true },
43549    "application/vnd.oma.cab-user-prefs+xml": { "source": "iana", "compressible": true },
43550    "application/vnd.oma.dcd": { "source": "iana" },

43551    "application/vnd.oma.dcdc": { "source": "iana" },
43552    "application/vnd.oma.dd2+xml": { "source": "iana", "compressible": true, "extensions": ["dd2"] },
43553    "application/vnd.oma.drm.risd+xml": { "source": "iana", "compressible": true },
43554    "application/vnd.oma.group-usage-list+xml": { "source": "iana", "compressible": true },
43555    "application/vnd.oma.lwm2m+cbor": { "source": "iana" },
43556    "application/vnd.oma.lwm2m+json": { "source": "iana", "compressible": true },
43557    "application/vnd.oma.lwm2m+tlv": { "source": "iana" },
43558    "application/vnd.oma.pal+xml": { "source": "iana", "compressible": true },
43559    "application/vnd.oma.poc.detailed-progress-report+xml": { "source": "iana", "compressible": true },
43560    "application/vnd.oma.poc.final-report+xml": { "source": "iana", "compressible": true },
43561    "application/vnd.oma.poc.groups+xml": { "source": "iana", "compressible": true },
43562    "application/vnd.oma.poc.invocation-descriptor+xml": { "source": "iana", "compressible": true },
43563    "application/vnd.oma.poc.optimized-progress-report+xml": { "source": "iana", "compressible": true },
43564    "application/vnd.oma.push": { "source": "iana" },
43565    "application/vnd.oma.scidm.messages+xml": { "source": "iana", "compressible": true },
43566    "application/vnd.oma.xcap-directory+xml": { "source": "iana", "compressible": true },
43567    "application/vnd.omads-email+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43568    "application/vnd.omads-file+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43569    "application/vnd.omads-folder+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43570    "application/vnd.omaloc-supl-init": { "source": "iana" },
43571    "application/vnd.onepager": { "source": "iana" },
43572    "application/vnd.onepagertamp": { "source": "iana" },
43573    "application/vnd.onepagertamx": { "source": "iana" },
43574    "application/vnd.onepagertat": { "source": "iana" },
43575    "application/vnd.onepagertatp": { "source": "iana" },
43576    "application/vnd.onepagertatx": { "source": "iana" },
43577    "application/vnd.openblox.game+xml": { "source": "iana", "compressible": true, "extensions": ["obgx"] },
43578    "application/vnd.openblox.game-binary": { "source": "iana" },
43579    "application/vnd.openeye.oeb": { "source": "iana" },
43580    "application/vnd.openofficeorg.extension": { "source": "apache", "extensions": ["oxt"] },
43581    "application/vnd.openstreetmap.data+xml": { "source": "iana", "compressible": true, "extensions": ["osm"] },
43582    "application/vnd.opentimestamps.ots": { "source": "iana" },
43583    "application/vnd.openxmlformats-officedocument.custom-properties+xml": { "source": "iana", "compressible": true },
43584    "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { "source": "iana", "compressible": true },
43585    "application/vnd.openxmlformats-officedocument.drawing+xml": { "source": "iana", "compressible": true },
43586    "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { "source": "iana", "compressible": true },
43587    "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { "source": "iana", "compressible": true },
43588    "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { "source": "iana", "compressible": true },
43589    "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { "source": "iana", "compressible": true },
43590    "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { "source": "iana", "compressible": true },
43591    "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { "source": "iana", "compressible": true },
43592    "application/vnd.openxmlformats-officedocument.extended-properties+xml": { "source": "iana", "compressible": true },
43593    "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { "source": "iana", "compressible": true },
43594    "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { "source": "iana", "compressible": true },
43595    "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { "source": "iana", "compressible": true },
43596    "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { "source": "iana", "compressible": true },
43597    "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { "source": "iana", "compressible": true },
43598    "application/vnd.openxmlformats-officedocument.presentationml.presentation": { "s

43598ource": "iana", "compressible": false, "extensions": ["pptx"] },
43599    "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { "source": "iana", "compressible": true },
43600    "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { "source": "iana", "compressible": true },
43601    "application/vnd.openxmlformats-officedocument.presentationml.slide": { "source": "iana", "extensions": ["sldx"] },
43602    "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { "source": "iana", "compressible": true },
43603    "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { "source": "iana", "compressible": true },
43604    "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { "source": "iana", "compressible": true },
43605    "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { "source": "iana", "extensions": ["ppsx"] },
43606    "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { "source": "iana", "compressible": true },
43607    "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { "source": "iana", "compressible": true },
43608    "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { "source": "iana", "compressible": true },
43609    "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { "source": "iana", "compressible": true },
43610    "application/vnd.openxmlformats-officedocument.presentationml.template": { "source": "iana", "extensions": ["potx"] },
43611    "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { "source": "iana", "compressible": true },
43612    "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { "source": "iana", "compressible": true },
43613    "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { "source": "iana", "compressible": true },
43614    "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { "source": "iana", "compressible": true },
43615    "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { "source": "iana", "compressible": true },
43616    "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { "source": "iana", "compressible": true },
43617    "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { "source": "iana", "compressible": true },
43618    "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { "source": "iana", "compressible": true },
43619    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { "source": "iana", "compressible": true },
43620    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { "source": "iana", "compressible": true },
43621    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { "source": "iana", "compressible": true },
43622    "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { "source": "iana", "compressible": true },
43623    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { "source": "iana", "compressible": true },
43624    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { "source": "iana", "compressible": true },
43625    "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { "source": "iana", "compressible": true },
43626    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { "source": "iana", "compressible": false, "extensions": ["xlsx"] },
43627    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { "source": "iana", "compressible": true },
43628    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { "source": "iana", "compressible": true },
43629    "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { "source": "iana", "compressible": true },
43630    "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { "source": "iana", "compressible": true },
43631    "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { "source": "iana", "compressible": true },
43632    "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { "source": "iana", "extensions": ["xltx"] },
43633    "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { "source": "iana", "compressible": true },
43634    "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { "source": "iana", "compressible": true },
43635    "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { "source": "iana", "compressible": true },
43636    "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { "source": "iana", "compressible": true },
43637    "application/vnd.openxmlformats-officedocument.theme+xml": { "source": "iana", "compressible": true },
43638    "application/vnd.openxmlformats-officedocument.themeoverride+xml": { "source": "iana", "compressible": true },
43639    "application/vnd.openxmlformats-officedocument.vmldrawing": { "source": "iana" },
43640    "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { "source": "iana", "compressible": true },
43641    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { "source": "iana", "compressible": false, "extensions": ["docx"] },
43642    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { "source": "iana", "compressible": true },
43643    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { "source": "iana", "compressible": true },
43644    "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { "source": "iana", "compressible": true },
43645    "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { "source": "iana", "compressible": true },
43646    "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { "source": "iana", "compressible": true },
43647    "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { "source": "iana", "compressible": true },
43648    "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { "source": "iana", "compressible": true },
43649    "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { "source": "iana", "compressible": true },
43650    "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { "source": "iana", "compressible": true },
43651    "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { "source": "iana", "extensions": ["dotx"] },
43652    "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { "source": "iana", "compressible": true },
43653    "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { "source": "iana", "compressible": true },
43654    "application/vnd.openxmlformats-package.core-properties+xml": { "source": "iana", "compressible": true },
43655    "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { "source": "iana", "compressible": true },
43656    "application/vnd.openxmlformats-package.relationships+xml": { "source": "iana", "compressible": true },

43657    "application/vnd.oracle.resource+json": { "source": "iana", "compressible": true },
43658    "application/vnd.orange.indata": { "source": "iana" },
43659    "application/vnd.osa.netdeploy": { "source": "iana" },
43660    "application/vnd.osgeo.mapguide.package": { "source": "iana", "extensions": ["mgp"] },
43661    "application/vnd.osgi.bundle": { "source": "iana" },
43662    "application/vnd.osgi.dp": { "source": "iana", "extensions": ["dp"] },
43663    "application/vnd.osgi.subsystem": { "source": "iana", "extensions": ["esa"] },
43664    "application/vnd.otps.ct-kip+xml": { "source": "iana", "compressible": true },
43665    "application/vnd.oxli.countgraph": { "source": "iana" },
43666    "application/vnd.pagerduty+json": { "source": "iana", "compressible": true },
43667    "application/vnd.palm": { "source": "iana", "extensions": ["pdb", "pqa", "oprc"] },
43668    "application/vnd.panoply": { "source": "iana" },
43669    "application/vnd.paos.xml": { "source": "iana" },
43670    "application/vnd.patentdive": { "source": "iana" },
43671    "application/vnd.patientecommsdoc": { "source": "iana" },
43672    "application/vnd.pawaafile": { "source": "iana", "extensions": ["paw"] },
43673    "application/vnd.pcos": { "source": "iana" },
43674    "application/vnd.pg.format": { "source": "iana", "extensions": ["str"] },
43675    "application/vnd.pg.osasli": { "source": "iana", "extensions": ["ei6"] },
43676    "application/vnd.piaccess.application-licence": { "source": "iana" },
43677    "application/vnd.picsel": { "source": "iana", "extensions": ["efif"] },
43678    "application/vnd.pmi.widget": { "source": "iana", "extensions": ["wg"] },
43679    "application/vnd.poc.group-advertisement+xml": { "source": "iana", "compressible": true },
43680    "application/vnd.pocketlearn": { "source": "iana", "extensions": ["plf"] },
43681    "application/vnd.powerbuilder6": { "source": "iana", "extensions": ["pbd"] },
43682    "application/vnd.powerbuilder6-s": { "source": "iana" },
43683    "application/vnd.powerbuilder7": { "source": "iana" },
43684    "application/vnd.powerbuilder7-s": { "source": "iana" },
43685    "application/vnd.powerbuilder75": { "source": "iana" },
43686    "application/vnd.powerbuilder75-s": { "source": "iana" },
43687    "application/vnd.preminet": { "source": "iana" },
43688    "application/vnd.previewsystems.box": { "source": "iana", "extensions": ["box"] },
43689    "application/vnd.proteus.magazine": { "source": "iana", "extensions": ["mgz"] },
43690    "application/vnd.psfs": { "source": "iana" },
43691    "application/vnd.publishare-delta-tree": { "source": "iana", "extensions": ["qps"] },
43692    "application/vnd.pvi.ptid1": { "source": "iana", "extensions": ["ptid"] },
43693    "application/vnd.pwg-multiplexed": { "source": "iana" },
43694    "application/vnd.pwg-xhtml-print+xml": { "source": "iana", "compressible": true },
43695    "application/vnd.qualcomm.brew-app-res": { "source": "iana" },
43696    "application/vnd.quarantainenet": { "source": "iana" },
43697    "application/vnd.quark.quarkxpress": { "source": "iana", "extensions": ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] },
43698    "application/vnd.quobject-quoxdocument": { "source": "iana" },
43699    "application/vnd.radisys.moml+xml": { "source": "iana", "compressible": true },
43700    "application/vnd.radisys.msml+xml": { "source": "iana", "compressible": true },
43701    "application/vnd.radisys.msml-audit+xml": { "source": "iana", "compressible": true },
43702    "application/vnd.radisys.msml-audit-conf+xml": { "source": "iana", "compressible": true },
43703    "application/vnd.radisys.msml-audit-conn+xml": { "source": "iana", "compressible": true },
43704    "application/vnd.radisys.msml-audit-dialog+xml": { "source": "iana", "compressible": true },
43705    "application/vnd.radisys.msml-audit-stream+xml": { "source": "iana", "compressible": true },
43706    "application/vnd.radisys.msml-conf+xml": { "source": "iana", "compressible": true },
43707    "application/vnd.radisys.msml-dialog+xml": { "source": "iana", "compressible": true },
43708    "application/vnd.radisys.msml-dialog-base+xml": { "source": "iana", "compressible": true },
43709    "application/vnd.radisys.msml-dialog-fax-detect+xml": { "source": "iana", "compressible": true },
43710    "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { "source": "iana", "compressible": true },
43711    "application/vnd.radisys.msml-dialog-group+xml": { "source": "iana", "compressible": true },
43712    "application/vnd.radisys.msml-dialog-speech+xml": { "source": "iana", "compressible": true },
43713    "application/vnd.radisys.msml-dialog-transform+xml": { "source": "iana", "compressible": true },

43714    "application/vnd.rainstor.data": { "source": "iana" },
43715    "application/vnd.rapid": { "source": "iana" },
43716    "application/vnd.rar": { "source": "iana", "extensions": ["rar"] },
43717    "application/vnd.realvnc.bed": { "source": "iana", "extensions": ["bed"] },
43718    "application/vnd.recordare.musicxml": { "source": "iana", "extensions": ["mxl"] },
43719    "application/vnd.recordare.musicxml+xml": { "source": "iana", "compressible": true, "extensions": ["musicxml"] },
43720    "application/vnd.renlearn.rlprint": { "source": "iana" },
43721    "application/vnd.resilient.logic": { "source": "iana" },
43722    "application/vnd.restful+json": { "source": "iana", "compressible": true },
43723    "application/vnd.rig.cryptonote": { "source": "iana", "extensions": ["cryptonote"] },
43724    "application/vnd.rim.cod": { "source": "apache", "extensions": ["cod"] },
43725    "application/vnd.rn-realmedia": { "source": "apache", "extensions": ["rm"] },
43726    "application/vnd.rn-realmedia-vbr": { "source": "apache", "extensions": ["rmvb"] },
43727    "application/vnd.route66.link66+xml": { "source": "iana", "compressible": true, "extensions": ["link66"] },
43728    "application/vnd.rs-274x": { "source": "iana" },
43729    "application/vnd.ruckus.download": { "source": "iana" },
43730    "application/vnd.s3sms": { "source": "iana" },
43731    "application/vnd.sailingtracker.track": { "source": "iana", "extensions": ["st"] },
43732    "application/vnd.sar": { "source": "iana" },
43733    "application/vnd.sbm.cid": { "source": "iana" },
43734    "application/vnd.sbm.mid2": { "source": "iana" },
43735    "application/vnd.scribus": { "source": "iana" },
43736    "application/vnd.sealed.3df": { "source": "iana" },
43737    "application/vnd.sealed.csf": { "source": "iana" },
43738    "application/vnd.sealed.doc": { "source": "iana" },
43739    "application/vnd.sealed.eml": { "source": "iana" },
43740    "application/vnd.sealed.mht": { "source": "iana" },
43741    "application/vnd.sealed.net": { "source": "iana" },
43742    "application/vnd.sealed.ppt": { "source": "iana" },
43743    "application/vnd.sealed.tiff": { "source": "iana" },
43744    "application/vnd.sealed.xls": { "source": "iana" },
43745    "application/vnd.sealedmedia.softseal.html": { "source": "iana" },
43746    "application/vnd.sealedmedia.softseal.pdf": { "source": "iana" },
43747    "application/vnd.seemail": { "source": "iana", "extensions": ["see"] },
43748    "application/vnd.seis+json": { "source": "iana", "compressible": true },
43749    "application/vnd.sema": { "source": "iana", "extensions": ["sema"] },

43750    "application/vnd.semd": { "source": "iana", "extensions": ["semd"] },
43751    "application/vnd.semf": { "source": "iana", "extensions": ["semf"] },
43752    "application/vnd.shade-save-file": { "source": "iana" },
43753    "application/vnd.shana.informed.formdata": { "source": "iana", "extensions": ["ifm"] },
43754    "application/vnd.shana.informed.formtemplate": { "source": "iana", "extensions": ["itp"] },
43755    "application/vnd.shana.informed.interchange": { "source": "iana", "extensions": ["iif"] },
43756    "application/vnd.shana.informed.package": { "source": "iana", "extensions": ["ipk"] },
43757    "application/vnd.shootproof+json": { "source": "iana", "compressible": true },
43758    "application/vnd.shopkick+json": { "source": "iana", "compressible": true },
43759    "application/vnd.shp": { "source": "iana" },
43760    "application/vnd.shx": { "source": "iana" },
43761    "application/vnd.sigrok.session": { "source": "iana" },
43762    "application/vnd.simtech-mindmapper": { "source": "iana", "extensions": ["twd", "twds"] },
43763    "application/vnd.siren+json": { "source": "iana", "compressible": true },
43764    "application/vnd.smaf": { "source": "iana", "extensions": ["mmf"] },
43765    "application/vnd.smart.notebook": { "source": "iana" },
43766    "application/vnd.smart.teacher": { "source": "iana", "extensions": ["teacher"] },
43767    "application/vnd.snesdev-page-table": { "source": "iana" },
43768    "application/vnd.software602.filler.form+xml": { "source": "iana", "compressible": true, "extensions": ["fo"] },
43769    "application/vnd.software602.filler.form-xml-zip": { "source": "iana" },
43770    "application/vnd.solent.sdkm+xml": { "source": "iana", "compressible": true, "extensions": ["sdkm", "sdkd"] },
43771    "application/vnd.spotfire.dxp": { "source": "iana", "extensions": ["dxp"] },
43772    "application/vnd.spotfire.sfs": { "source": "iana", "extensions": ["sfs"] },
43773    "application/vnd.sqlite3": { "source": "iana" },
43774    "application/vnd.sss-cod": { "source": "iana" },
43775    "application/vnd.sss-dtf": { "source": "iana" },
43776    "application/vnd.sss-ntf": { "source": "iana" },
43777    "application/vnd.stardivision.calc": { "source": "apache", "extensions": ["sdc"] },
43778    "application/vnd.stardivision.draw": { "source": "apache", "extensions": ["sda"] },
43779    "application/vnd.stardivision.impress": { "source": "apache", "extensions": ["sdd"] },
43780    "application/vnd.stardivision.math": { "source": "apache", "extensions": ["smf"] },
43781    "application/vnd.stardivision.writer": { "source": "apache", "extensions": ["sdw", "vor"] },
43782    "application/vnd.stardivision.writer-global": { "source": "apache", "extensions": ["sgl"] },
43783    "application/vnd.stepmania.package": { "source": "iana", "extensions": ["smzip"] },
43784    "application/vnd.stepmania.stepchart": { "source": "iana", "extensions": ["sm"] },
43785    "application/vnd.street-stream": { "source": "iana" },
43786    "application/vnd.sun.wadl+xml": { "source": "iana", "compressible": true, "extensions": ["wadl"] },
43787    "application/vnd.sun.xml.calc": { "source": "apache", "extensions": ["sxc"] },
43788    "application/vnd.sun.xml.calc.template": { "source": "apache", "extensions": ["stc"] },
43789    "application/vnd.sun.xml.draw": { "source": "apache", "extensions": ["sxd"] },
43790    "application/vnd.sun.xml.draw.template": { "source": "apache", "extensions": ["std"] },
43791    "application/vnd.sun.xml.impress": { "source": "apache", "extensions": ["sxi"] },
43792    "application/vnd.sun.xml.impress.template": { "source": "apache", "extensions": ["sti"] },
43793    "application/vnd.sun.xml.math": { "source": "apache", "extensions": ["sxm"] },
43794    "application/vnd.sun.xml.writer": { "source": "apache", "extensions": ["sxw"] },
43795    "application/vnd.sun.xml.writer.global": { "source": "apache", "extensions": ["sxg"] },
43796    "application/vnd.sun.xml.writer.template": { "source": "apache", "extensions": ["stw"] },
43797    "application/vnd.sus-calendar": { "source": "iana", "extensions": ["sus", "susp"] },
43798    "application/vnd.svd": { "source": "iana", "extensions": ["svd"] },
43799    "application/vnd.swiftview-ics": { "source": "iana" },
43800    "application/vnd.sycle+xml": { "source": "iana", "compressible": true },

43801    "application/vnd.syft+json": { "source": "iana", "compressible": true },
43802    "application/vnd.symbian.install": { "source": "apache", "extensions": ["sis", "sisx"] },
43803    "application/vnd.syncml+xml": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["xsm"] },
43804    "application/vnd.syncml.dm+wbxml": { "source": "iana", "charset": "UTF-8", "extensions": ["bdm"] },
43805    "application/vnd.syncml.dm+xml": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["xdm"] },
43806    "application/vnd.syncml.dm.notification": { "source": "iana" },
43807    "application/vnd.syncml.dmddf+wbxml": { "source": "iana" },
43808    "application/vnd.syncml.dmddf+xml": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["ddf"] },
43809    "application/vnd.syncml.dmtnds+wbxml": { "source": "iana" },
43810    "application/vnd.syncml.dmtnds+xml": { "source": "iana", "charset": "UTF-8", "compressible": true },
43811    "application/vnd.syncml.ds.notification": { "source": "iana" },
43812    "application/vnd.tableschema+json": { "source": "iana", "compressible": true },
43813    "application/vnd.tao.intent-module-archive": { "source": "iana", "extensions": ["tao"] },
43814    "application/vnd.tcpdump.pcap": { "source": "iana", "extensions": ["pcap", "cap", "dmp"] },
43815    "application/vnd.think-cell.ppttc+json": { "source": "iana", "compressible": true },
43816    "application/vnd.tmd.mediaflex.api+xml": { "source": "iana", "compressible": true },
43817    "application/vnd.tml": { "source": "iana" },
43818    "application/vnd.tmobile-livetv": { "source": "iana", "extensions": ["tmo"] },
43819    "application/vnd.tri.onesource": { "source": "iana" },
43820    "application/vnd.trid.tpt": { "source": "iana", "extensions": ["tpt"] },
43821    "application/vnd.triscape.mxs": { "source": "iana", "extensions": ["mxs"] },
43822    "application/vnd.trueapp": { "source": "iana", "extensions": ["tra"] },
43823    "application/vnd.truedoc": { "source": "iana" },
43824    "application/vnd.ubisoft.webplayer": { "source": "iana" },
43825    "application/vnd.ufdl": { "source": "iana", "extensions": ["ufd", "ufdl"] },
43826    "application/vnd.uiq.theme": { "source": "iana", "extensions": ["utz"] },
43827    "application/vnd.umajin": { "source": "iana", "extensions": ["umj"] },
43828    "application/vnd.unity": { "source": "iana", "extensions": ["unityweb"] },
43829    "application/vnd.uoml+xml": { "source": "iana", "compressible": true, "extensions": ["uoml"] },
43830    "application/vnd.uplanet.alert": { "source": "iana" },
43831    "application/vnd.uplanet.alert-wbxml": { "source": "iana" },
43832    "application/vnd.uplanet.bearer-choice": { "source": "iana" },
43833    "application/vnd.uplanet.bearer-choice-wbxml": { "source": "iana" },
43834    "application/vnd.uplanet.cacheop": { "source": "iana" },
43835    "application/vnd.uplanet.cacheop-wbxml": { "source": "iana" },
43836    "application/vnd.uplanet.channel": { "source": "iana" },
43837    "application/vnd.uplanet.channel-wbxml": { "source": "iana" },
43838    "application/vnd.uplanet.list": { "source": "iana" },
43839    "application/vnd.uplanet.list-wbxml": { "source": "iana" },
43840    "application/vnd.uplanet.listcmd": { "source": "iana" },
43841    "application/vnd.uplanet.listcmd-wbxml": { "source": "iana" },
43842    "application/vnd.uplanet.signal": { "source": "iana" },
43843    "application/vnd.uri-map": { "source": "iana" },
43844    "application/vnd.valve.source.material": { "source": "iana" },
43845    "application/vnd.vcx": { "source": "iana", "extensions": ["vcx"] },
43846    "application/vnd.vd-study": { "source": "iana" },
43847    "application/vnd.vectorworks": { "source": "iana" },
43848    "application/vnd.vel+json": { "source": "iana", "compressible": true },

43849    "application/vnd.verimatrix.vcas": { "source": "iana" },
43850    "application/vnd.veritone.aion+json": { "source": "iana", "compressible": true },
43851    "application/vnd.veryant.thin": { "source": "iana" },
43852    "application/vnd.ves.encrypted": { "source": "iana" },
43853    "application/vnd.vidsoft.vidconference": { "source": "iana" },
43854    "application/vnd.visio": { "source": "iana", "extensions": ["vsd", "vst", "vss", "vsw"] },
43855    "application/vnd.visionary": { "source": "iana", "extensions": ["vis"] },
43856    "application/vnd.vividence.scriptfile": { "source": "iana" },
43857    "application/vnd.vsf": { "source": "iana", "extensions": ["vsf"] },
43858    "application/vnd.wap.sic": { "source": "iana" },
43859    "application/vnd.wap.slc": { "source": "iana" },
43860    "application/vnd.wap.wbxml": { "source": "iana", "charset": "UTF-8", "extensions": ["wbxml"] },
43861    "application/vnd.wap.wmlc": { "source": "iana", "extensions": ["wmlc"] },
43862    "application/vnd.wap.wmlscriptc": { "source": "iana", "extensions": ["wmlsc"] },
43863    "application/vnd.webturbo": { "source": "iana", "extensions": ["wtb"] },
43864    "application/vnd.wfa.dpp": { "source": "iana" },
43865    "application/vnd.wfa.p2p": { "source": "iana" },

43866    "application/vnd.wfa.wsc": { "source": "iana" },
43867    "application/vnd.windows.devicepairing": { "source": "iana" },
43868    "application/vnd.wmc": { "source": "iana" },
43869    "application/vnd.wmf.bootstrap": { "source": "iana" },
43870    "application/vnd.wolfram.mathematica": { "source": "iana" },
43871    "application/vnd.wolfram.mathematica.package": { "source": "iana" },
43872    "application/vnd.wolfram.player": { "source": "iana", "extensions": ["nbp"] },
43873    "application/vnd.wordperfect": { "source": "iana", "extensions": ["wpd"] },
43874    "application/vnd.wqd": { "source": "iana", "extensions": ["wqd"] },
43875    "application/vnd.wrq-hp3000-labelled": { "source": "iana" },
43876    "application/vnd.wt.stf": { "source": "iana", "extensions": ["stf"] },
43877    "application/vnd.wv.csp+wbxml": { "source": "iana" },
43878    "application/vnd.wv.csp+xml": { "source": "iana", "compressible": true },
43879    "application/vnd.wv.ssp+xml": { "source": "iana", "compressible": true },
43880    "application/vnd.xacml+json": { "source": "iana", "compressible": true },
43881    "application/vnd.xara": { "source": "iana", "extensions": ["xar"] },
43882    "application/vnd.xfdl": { "source": "iana", "extensions": ["xfdl"] },
43883    "application/vnd.xfdl.webform": { "source": "iana" },
43884    "application/vnd.xmi+xml": { "source": "iana", "compressible": true },
43885    "application/vnd.xmpie.cpkg": { "source": "iana" },
43886    "application/vnd.xmpie.dpkg": { "source": "iana" },
43887    "application/vnd.xmpie.plan": { "source": "iana" },
43888    "application/vnd.xmpie.ppkg": { "source": "iana" },
43889    "application/vnd.xmpie.xlim": { "source": "iana" },
43890    "application/vnd.yamaha.hv-dic": { "source": "iana", "extensions": ["hvd"] },
43891    "application/vnd.yamaha.hv-script": { "source": "iana", "extensions": ["hvs"] },
43892    "application/vnd.yamaha.hv-voice": { "source": "iana", "extensions": ["hvp"] },
43893    "application/vnd.yamaha.openscoreformat": { "source": "iana", "extensions": ["osf"] },
43894    "application/vnd.yamaha.openscoreformat.osfpvg+xml": { "source": "iana", "compressible": true, "extensions": ["osfpvg"] },
43895    "application/vnd.yamaha.remote-setup": { "source": "iana" },
43896    "application/vnd.yamaha.smaf-audio": { "source": "iana", "extensions": ["saf"] },
43897    "application/vnd.yamaha.smaf-phrase": { "source": "iana", "extensions": ["spf"] },
43898    "application/vnd.yamaha.through-ngn": { "source": "iana" },
43899    "application/vnd.yamaha.tunnel-udpencap": { "source": "iana" },
43900    "application/vnd.yaoweme": { "source": "iana" },
43901    "application/vnd.yellowriver-custom-menu": { "source": "iana", "extensions": ["cmp"] },
43902    "application/vnd.youtube.yt": { "source": "iana" },
43903    "application/vnd.zul": { "source": "iana", "extensions": ["zir", "zirz"] },
43904    "application/vnd.zzazz.deck+xml": { "source": "iana", "compressible": true, "extensions": ["zaz"] },
43905    "application/voicexml+xml": { "source": "iana", "compressible": true, "extensions": ["vxml"] },
43906    "application/voucher-cms+json": { "source": "iana", "compressible": true },
43907    "application/vq-rtcpxr": { "source": "iana" },
43908    "application/wasm": { "source": "iana", "compressible": true, "extensions": ["wasm"] },
43909    "application/watcherinfo+xml": { "source": "iana", "compressible": true, "extensions": ["wif"] },
43910    "application/webpush-options+json": { "source": "iana", "compressible": true },
43911    "application/whoispp-query": { "source": "iana" },
43912    "application/whoispp-response": { "source": "iana" },
43913    "application/widget": { "source": "iana", "extensions": ["wgt"] },
43914    "application/winhlp": { "source": "apache", "extensions": ["hlp"] },
43915    "application/wita": { "source": "iana" },
43916    "application/wordperfect5.1": { "source": "iana" },
43917    "application/wsdl+xml": { "source": "iana", "compressible": true, "extensions": ["wsdl"] },
43918    "application/wspolicy+xml": { "source": "iana", "compressible": true, "extensions": ["wspolicy"] },
43919    "application/x-7z-compressed": { "source": "apache", "compressible": false, "extensions": ["7z"] },
43920    "application/x-abiword": { "source": "apache", "extensions": ["abw"] },

vendor: 7,263 bytes, lines 43921-44012

43921    "application/x-ace-compressed": { "source": "apache", "extensions": ["ace"] },
43922    "application/x-amf": { "source": "apache" },
43923    "application/x-apple-diskimage": { "source": "apache", "extensions": ["dmg"] },
43924    "application/x-arj": { "compressible": false, "extensions": ["arj"] },
43925    "application/x-authorware-bin": { "source": "apache", "extensions": ["aab", "x32", "u32", "vox"] },
43926    "application/x-authorware-map": { "source": "apache", "extensions": ["aam"] },
43927    "application/x-authorware-seg": { "source": "apache", "extensions": ["aas"] },
43928    "application/x-bcpio": { "source": "apache", "extensions": ["bcpio"] },
43929    "application/x-bdoc": { "compressible": false, "extensions": ["bdoc"] },
43930    "application/x-bittorrent": { "source": "apache", "extensions": ["torrent"] },
43931    "application/x-blorb": { "source": "apache", "extensions": ["blb", "blorb"] },
43932    "application/x-bzip": { "source": "apache", "compressible": false, "extensions": ["bz"] },
43933    "application/x-bzip2": { "source": "apache", "compressible": false, "extensions": ["bz2", "boz"] },
43934    "application/x-cbr": { "source": "apache", "extensions": ["cbr", "cba", "cbt", "cbz", "cb7"] },
43935    "application/x-cdlink": { "source": "apache", "extensions": ["vcd"] },
43936    "application/x-cfs-compressed": { "source": "apache", "extensions": ["cfs"] },
43937    "application/x-chat": { "source": "apache", "extensions": ["chat"] },
43938    "application/x-chess-pgn": { "source": "apache", "extensions": ["pgn"] },
43939    "application/x-chrome-extension": { "extensions": ["crx"] },
43940    "application/x-cocoa": { "source": "nginx", "extensions": ["cco"] },
43941    "application/x-compress": { "source": "apache" },
43942    "application/x-conference": { "source": "apache", "extensions": ["nsc"] },
43943    "application/x-cpio": { "source": "apache", "extensions": ["cpio"] },
43944    "application/x-csh": { "source": "apache", "extensions": ["csh"] },
43945    "application/x-deb": { "compressible": false },
43946    "application/x-debian-package": { "source": "apache", "extensions": ["deb", "udeb"] },
43947    "application/x-dgc-compressed": { "source": "apache", "extensions": ["dgc"] },
43948    "application/x-director": { "source": "apache", "extensions": ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] },
43949    "application/x-doom": { "source": "apache", "extensions": ["wad"] },
43950    "application/x-dtbncx+xml": { "source": "apache", "compressible": true, "extensions": ["ncx"] },
43951    "application/x-dtbook+xml": { "source": "apache", "compressible": true, "extensions": ["dtb"] },
43952    "application/x-dtbresource+xml": { "source": "apache", "compressible": true, "extensions": ["res"] },
43953    "application/x-dvi": { "source": "apache", "compressible": false, "extensions": ["dvi"] },
43954    "application/x-envoy": { "source": "apache", "extensions": ["evy"] },
43955    "application/x-eva": { "source": "apache", "extensions": ["eva"] },
43956    "application/x-font-bdf": { "source": "apache", "extensions": ["bdf"] },
43957    "application/x-font-dos": { "source": "apache" },
43958    "application/x-font-framemaker": { "source": "apache" },
43959    "application/x-font-ghostscript": { "source": "apache", "extensions": ["gsf"] },
43960    "application/x-font-libgrx": { "source": "apache" },
43961    "application/x-font-linux-psf": { "source": "apache", "extensions": ["psf"] },
43962    "application/x-font-pcf": { "source": "apache", "extensions": ["pcf"] },
43963    "application/x-font-snf": { "source": "apache", "extensions": ["snf"] },
43964    "application/x-font-speedo": { "source": "apache" },
43965    "application/x-font-sunos-news": { "source": "apache" },
43966    "application/x-font-type1": { "source": "apache", "extensions": ["pfa", "pfb", "pfm", "afm"] },
43967    "application/x-font-vfont": { "source": "apache" },
43968    "application/x-freearc": { "source": "apache", "extensions": ["arc"] },
43969    "application/x-futuresplash": { "source": "apache", "extensions": ["spl"] },
43970    "application/x-gca-compressed": { "source": "apache", "extensions": ["gca"] },
43971    "application/x-glulx": { "source": "apache", "extensions": ["ulx"] },
43972    "application/x-gnumeric": { "source": "apache", "extensions": ["gnumeric"] },
43973    "application/x-gramps-xml": { "source": "apache", "extensions": ["gramps"] },
43974    "application/x-gtar": { "source": "apache", "extensions": ["gtar"] },
43975    "application/x-gzip": { "source": "apache" },
43976    "application/x-hdf": { "source": "apache", "extensions": ["hdf"] },
43977    "application/x-httpd-php": { "compressible": true, "extensions": ["php"] },
43978    "application/x-install-instructions": { "source": "apache", "extensions": ["install"] },
43979    "application/x-iso9660-image": { "source": "apache", "extensions": ["iso"] },
43980    "application/x-iwork-keynote-sffkey": { "extensions": ["key"] },
43981    "application/x-iwork-numbers-sffnumbers": { "extensions": ["numbers"] },
43982    "application/x-iwork-pages-sffpages": { "extensions": ["pages"] },
43983    "application/x-java-archive-diff": { "source": "nginx", "extensions": ["jardiff"] },
43984    "application/x-java-jnlp-file": { "source": "apache", "compressible": false, "extensions": ["jnlp"] },
43985    "application/x-javascript": { "compressible": true },
43986    "application/x-keepass2": { "extensions": ["kdbx"] },
43987    "application/x-latex": { "source": "apache", "compressible": false, "extensions": ["latex"] },
43988    "application/x-lua-bytecode": { "extensions": ["luac"] },
43989    "application/x-lzh-compressed": { "source": "apache", "extensions": ["lzh", "lha"] },
43990    "application/x-makeself": { "source": "nginx", "extensions": ["run"] },
43991    "application/x-mie": { "source": "apache", "extensions": ["mie"] },
43992    "application/x-mobipocket-ebook": { "source": "apache", "extensions": ["prc", "mobi"] },
43993    "application/x-mpegurl": { "compressible": false },
43994    "application/x-ms-application": { "source": "apache", "extensions": ["application"] },
43995    "application/x-ms-shortcut": { "source": "apache", "extensions": ["lnk"] },
43996    "application/x-ms-wmd": { "source": "apache", "extensions": ["wmd"] },
43997    "application/x-ms-wmz": { "source": "apache", "extensions": ["wmz"] },
43998    "application/x-ms-xbap": { "source": "apache", "extensions": ["xbap"] },
43999    "application/x-msaccess": { "source": "apache", "extensions": ["mdb"] },
44000    "application/x-msbinder": { "source": "apache", "extensions": ["obd"] },
44001    "application/x-mscardfile": { "source": "apache", "extensions": ["crd"] },
44002    "application/x-msclip": { "source": "apache", "extensions": ["clp"] },
44003    "application/x-msdos-program": { "extensions": ["exe"] },
44004    "application/x-msdownload": { "source": "apache", "extensions": ["exe", "dll", "com", "bat", "msi"] },
44005    "application/x-msmediaview": { "source": "apache", "extensions": ["mvb", "m13", "m14"] },
44006    "application/x-msmetafile": { "source": "apache", "extensions": ["wmf", "wmz", "emf", "emz"] },
44007    "application/x-msmoney": { "source": "apache", "extensions": ["mny"] },
44008    "application/x-mspublisher": { "source": "apache", "extensions": ["pub"] },
44009    "application/x-msschedule": { "source": "apache", "extensions": ["scd"] },
44010    "application/x-msterminal": { "source": "apache", "extensions": ["trm"] },
44011    "application/x-mswrite": { "source": "apache", "extensions": ["wri"] },
44012    "application/x-netcdf": { "source": "apache", "extensions": ["

44012nc", "cdf"] },
44013    "application/x-ns-proxy-autoconfig": { "compressible": true, "extensions": ["pac"] },
44014    "application/x-nzb": { "source": "apache", "extensions": ["nzb"] },
44015    "application/x-perl": { "source": "nginx", "extensions": ["pl", "pm"] },
44016    "application/x-pilot": { "source": "nginx", "extensions": ["prc", "pdb"] },
44017    "application/x-pkcs12": { "source": "apache", "compressible": false, "extensions": ["p12", "pfx"] },
44018    "application/x-pkcs7-certificates": { "source": "apache", "extensions": ["p7b", "spc"] },
44019    "application/x-pkcs7-certreqresp": { "source": "apache", "extensions": ["p7r"] },
44020    "application/x-pki-message": { "source": "iana" },
44021    "application/x-rar-compressed": { "source": "apache", "compressible": false, "extensions": ["rar"] },
44022    "application/x-redhat-package-manager": { "source": "nginx", "extensions": ["rpm"] },
44023    "application/x-research-info-systems": { "source": "apache", "extensions": ["ris"] },
44024    "application/x-sea": { "source": "nginx", "extensions": ["sea"] },
44025    "application/x-sh": { "source": "apache", "compressible": true, "extensions": ["sh"] },
44026    "application/x-shar": { "source": "apache", "extensions": ["shar"] },
44027    "application/x-shockwave-flash": { "source": "apache", "compressible": false, "extensions": ["swf"] },
44028    "application/x-silverlight-app": { "source": "apache", "extensions": ["xap"] },
44029    "application/x-sql": { "source": "apache", "extensions": ["sql"] },
44030    "application/x-stuffit": { "source": "apache", "compressible": false, "extensions": ["sit"] },
44031    "application/x-stuffitx": { "source": "apache", "extensions": ["sitx"] },
44032    "application/x-subrip": { "source": "apache", "extensions": ["srt"] },
44033    "application/x-sv4cpio": { "source": "apache", "extensions": ["sv4cpio"] },
44034    "application/x-sv4crc": { "source": "apache", "extensions": ["sv4crc"] },
44035    "application/x-t3vm-image": { "source": "apache", "extensions": ["t3"] },
44036    "application/x-tads": { "source": "apache", "extensions": ["gam"] },
44037    "application/x-tar": { "source": "apache", "compressible": true, "extensions": ["tar"] },
44038    "application/x-tcl": { "source": "apache", "extensions": ["tcl", "tk"] },

vendor: 4,378 bytes, lines 44039-44088

44039    "application/x-tex": { "source": "apache", "extensions": ["tex"] },
44040    "application/x-tex-tfm": { "source": "apache", "extensions": ["tfm"] },
44041    "application/x-texinfo": { "source": "apache", "extensions": ["texinfo", "texi"] },
44042    "application/x-tgif": { "source": "apache", "extensions": ["obj"] },
44043    "application/x-ustar": { "source": "apache", "extensions": ["ustar"] },
44044    "application/x-virtualbox-hdd": { "compressible": true, "extensions": ["hdd"] },
44045    "application/x-virtualbox-ova": { "compressible": true, "extensions": ["ova"] },
44046    "application/x-virtualbox-ovf": { "compressible": true, "extensions": ["ovf"] },
44047    "application/x-virtualbox-vbox": { "compressible": true, "extensions": ["vbox"] },
44048    "application/x-virtualbox-vbox-extpack": { "compressible": false, "extensions": ["vbox-extpack"] },
44049    "application/x-virtualbox-vdi": { "compressible": true, "extensions": ["vdi"] },
44050    "application/x-virtualbox-vhd": { "compressible": true, "extensions": ["vhd"] },
44051    "application/x-virtualbox-vmdk": { "compressible": true, "extensions": ["vmdk"] },
44052    "application/x-wais-source": { "source": "apache", "extensions": ["src"] },
44053    "application/x-web-app-manifest+json": { "compressible": true, "extensions": ["webapp"] },
44054    "application/x-www-form-urlencoded": { "source": "iana", "compressible": true },
44055    "application/x-x509-ca-cert": { "source": "iana", "extensions": ["der", "crt", "pem"] },
44056    "application/x-x509-ca-ra-cert": { "source": "iana" },
44057    "application/x-x509-next-ca-cert": { "source": "iana" },
44058    "application/x-xfig": { "source": "apache", "extensions": ["fig"] },
44059    "application/x-xliff+xml": { "source": "apache", "compressible": true, "extensions": ["xlf"] },
44060    "application/x-xpinstall": { "source": "apache", "compressible": false, "extensions": ["xpi"] },
44061    "application/x-xz": { "source": "apache", "extensions": ["xz"] },
44062    "application/x-zmachine": { "source": "apache", "extensions": ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] },
44063    "application/x400-bp": { "source": "iana" },
44064    "application/xacml+xml": { "source": "iana", "compressible": true },
44065    "application/xaml+xml": { "source": "apache", "compressible": true, "extensions": ["xaml"] },
44066    "application/xcap-att+xml": { "source": "iana", "compressible": true, "extensions": ["xav"] },
44067    "application/xcap-caps+xml": { "source": "iana", "compressible": true, "extensions": ["xca"] },
44068    "application/xcap-diff+xml": { "source": "iana", "compressible": true, "extensions": ["xdf"] },
44069    "application/xcap-el+xml": { "source": "iana", "compressible": true, "extensions": ["xel"] },
44070    "application/xcap-error+xml": { "source": "iana", "compressible": true },
44071    "application/xcap-ns+xml": { "source": "iana", "compressible": true, "extensions": ["xns"] },
44072    "application/xcon-conference-info+xml": { "source": "iana", "compressible": true },
44073    "application/xcon-conference-info-diff+xml": { "source": "iana", "compressible": true },
44074    "application/xenc+xml": { "source": "iana", "compressible": true, "extensions": ["xenc"] },
44075    "application/xhtml+xml": { "source": "iana", "compressible": true, "extensions": ["xhtml", "xht"] },
44076    "application/xhtml-voice+xml": { "source": "apache", "compressible": true },
44077    "application/xliff+xml": { "source": "iana", "compressible": true, "extensions": ["xlf"] },
44078    "application/xml": { "source": "iana", "compressible": true, "extensions": ["xml", "xsl", "xsd", "rng"] },
44079    "application/xml-dtd": { "source": "iana", "compressible": true, "extensions": ["dtd"] },
44080    "application/xml-external-parsed-entity": { "source": "iana" },
44081    "application/xml-patch+xml": { "source": "iana", "compressible": true },
44082    "application/xmpp+xml": { "source": "iana", "compressible": true },
44083    "application/xop+xml": { "source": "iana", "compressible": true, "extensions": ["xop"] },
44084    "application/xproc+xml": { "source": "apache", "compressible": true, "extensions": ["xpl"] },
44085    "application/xslt+xml": { "source": "iana", "compressible": true, "extensions": ["xsl", "xslt"] },
44086    "application/xspf+xml": { "source": "apache", "compressible": true, "extensions": ["xspf"] },
44087    "application/xv+xml": { "source": "iana", "compressible": true, "extensions": ["mxml", "xhvml", "xvml", "xvm"] },
44088    "application/yang": { "source": "iana", "extensions": ["yang"] },

44089    "application/yang-data+json": { "source": "iana", "compressible": true },
44090    "application/yang-data+xml": { "source": "iana", "compressible": true },
44091    "application/yang-patch+json": { "source": "iana", "compressible": true },
44092    "application/yang-patch+xml": { "source": "iana", "compressible": true },
44093    "application/yin+xml": { "source": "iana", "compressible": true, "extensions": ["yin"] },
44094    "application/zip": { "source": "iana", "compressible": false, "extensions": ["zip"] },
44095    "application/zlib": { "source": "iana" },
44096    "application/zstd": { "source": "iana" },
44097    "audio/1d-interleaved-parityfec": { "source": "iana" },
44098    "audio/32kadpcm": { "source": "iana" },
44099    "audio/3gpp": { "source": "iana", "compressible": false, "extensions": ["3gpp"] },
44100    "audio/3gpp2": { "source": "iana" },
44101    "audio/aac": { "source": "iana" },
44102    "audio/ac3": { "source": "iana" },
44103    "audio/adpcm": { "source": "apache", "extensions": ["adp"] },
44104    "audio/amr": { "source": "iana", "extensions": ["amr"] },
44105    "audio/amr-wb": { "source": "iana" },
44106    "audio/amr-wb+": { "source": "iana" },
44107    "audio/aptx": { "source": "iana" },
44108    "audio/asc": { "source": "iana" },
44109    "audio/atrac-advanced-lossless": { "source": "iana" },
44110    "audio/atrac-x": { "source": "iana" },
44111    "audio/atrac3": { "source": "iana" },
44112    "audio/basic": { "source": "iana", "compressible": false, "extensions": ["au", "snd"] },
44113    "audio/bv16": { "source": "iana" },
44114    "audio/bv32": { "source": "iana" },
44115    "audio/clearmode": { "source": "iana" },
44116    "audio/cn": { "source": "iana" },
44117    "audio/dat12": { "source": "iana" },
44118    "audio/dls": { "source": "iana" },
44119    "audio/dsr-es201108": { "source": "iana" },
44120    "audio/dsr-es202050": { "source": "iana" },
44121    "audio/dsr-es202211": { "source": "iana" },
44122    "audio/dsr-es202212": { "source": "iana" },
44123    "audio/dv": { "source": "iana" },
44124    "audio/dvi4": { "source": "iana" },
44125    "audio/eac3": { "source": "iana" },
44126    "audio/encaprtp": { "source": "iana" },
44127    "audio/evrc": { "source": "iana" },
44128    "audio/evrc-qcp": { "source": "iana" },
44129    "audio/evrc0": { "source": "iana" },
44130    "audio/evrc1": { "source": "iana" },
44131    "audio/evrcb": { "source": "iana" },
44132    "audio/evrcb0": { "source": "iana" },
44133    "audio/evrcb1": { "source": "iana" },
44134    "audio/evrcnw": { "source": "iana" },
44135    "audio/evrcnw0": { "source": "iana" },
44136    "audio/evrcnw1": { "source": "iana" },
44137    "audio/evrcwb": { "source": "iana" },
44138    "audio/evrcwb0": { "source": "iana" },
44139    "audio/evrcwb1": { "source": "iana" },
44140    "audio/evs": { "source": "iana" },
44141    "audio/flexfec": { "source": "iana" },
44142    "audio/fwdred": { "source": "iana" },
44143    "audio/g711-0": { "source": "iana" },
44144    "audio/g719": { "source": "iana" },
44145    "audio/g722": { "source": "iana" },
44146    "audio/g7221": { "source": "iana" },
44147    "audio/g723": { "source": "iana" },
44148    "audio/g726-16": { "source": "iana" },
44149    "audio/g726-24": { "source": "iana" },
44150    "audio/g726-32": { "source": "iana" },
44151    "audio/g726-40": { "source": "iana" },
44152    "audio/g728": { "source": "iana" },
44153    "audio/g729": { "source": "iana" },
44154    "audio/g7291": { "source": "iana" },

44155    "audio/g729d": { "source": "iana" },
44156    "audio/g729e": { "source": "iana" },
44157    "audio/gsm": { "source": "iana" },
44158    "audio/gsm-efr": { "source": "iana" },
44159    "audio/gsm-hr-08": { "source": "iana" },
44160    "audio/ilbc": { "source": "iana" },
44161    "audio/ip-mr_v2.5": { "source": "iana" },
44162    "audio/isac": { "source": "apache" },
44163    "audio/l16": { "source": "iana" },
44164    "audio/l20": { "source": "iana" },
44165    "audio/l24": { "source": "iana", "compressible": false },
44166    "audio/l8": { "source": "iana" },
44167    "audio/lpc": { "source": "iana" },
44168    "audio/melp": { "source": "iana" },
44169    "audio/melp1200": { "source": "iana" },
44170    "audio/melp2400": { "source": "iana" },
44171    "audio/melp600": { "source": "iana" },
44172    "audio/mhas": { "source": "iana" },
44173    "audio/midi": { "source": "apache", "extensions": ["mid", "midi", "kar", "rmi"] },
44174    "audio/mobile-xmf": { "source": "iana", "extensions": ["mxmf"] },
44175    "audio/mp3": { "compressible": false, "extensions": ["mp3"] },
44176    "audio/mp4": { "source": "iana", "compressible": false, "extensions": ["m4a", "mp4a"] },
44177    "audio/mp4a-latm": { "source": "iana" },
44178    "audio/mpa": { "source": "iana" },
44179    "audio/mpa-robust": { "source": "iana" },
44180    "audio/mpeg": { "source": "iana", "compressible": false, "extensions": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] },
44181    "audio/mpeg4-generic": { "source": "iana" },
44182    "audio/musepack": { "source": "apache" },
44183    "audio/ogg": { "source": "iana", "compressible": false, "extensions": ["oga", "ogg", "spx", "opus"] },
44184    "audio/opus": { "source": "iana" },
44185    "audio/parityfec": { "source": "iana" },
44186    "audio/pcma": { "source": "iana" },
44187    "audio/pcma-wb": { "source": "iana" },
44188    "audio/pcmu": { "source": "iana" },
44189    "audio/pcmu-wb": { "source": "iana" },
44190    "audio/prs.sid": { "source": "iana" },
44191    "audio/qcelp": { "source": "iana" },
44192    "audio/raptorfec": { "source": "iana" },
44193    "audio/red": { "source": "iana" },
44194    "audio/rtp-enc-aescm128": { "source": "iana" },
44195    "audio/rtp-midi": { "source": "iana" },
44196    "audio/rtploopback": { "source": "iana" },
44197    "audio/rtx": { "source": "iana" },
44198    "audio/s3m": { "source": "apache", "extensions": ["s3m"] },
44199    "audio/scip": { "source": "iana" },
44200    "audio/silk": { "source": "apache", "extensions": ["sil"] },
44201    "audio/smv": { "source": "iana" },
44202    "audio/smv-qcp": { "source": "iana" },
44203    "audio/smv0": { "source": "iana" },

44204    "audio/sofa": { "source": "iana" },
44205    "audio/sp-midi": { "source": "iana" },
44206    "audio/speex": { "source": "iana" },
44207    "audio/t140c": { "source": "iana" },
44208    "audio/t38": { "source": "iana" },
44209    "audio/telephone-event": { "source": "iana" },
44210    "audio/tetra_acelp": { "source": "iana" },
44211    "audio/tetra_acelp_bb": { "source": "iana" },
44212    "audio/tone": { "source": "iana" },
44213    "audio/tsvcis": { "source": "iana" },
44214    "audio/uemclip": { "source": "iana" },
44215    "audio/ulpfec": { "source": "iana" },
44216    "audio/usac": { "source": "iana" },
44217    "audio/vdvi": { "source": "iana" },
44218    "audio/vmr-wb": { "source": "iana" },
44219    "audio/vnd.3gpp.iufp": { "source": "iana" },
44220    "audio/vnd.4sb": { "source": "iana" },
44221    "audio/vnd.audiokoz": { "source": "iana" },
44222    "audio/vnd.celp": { "source": "iana" },
44223    "audio/vnd.cisco.nse": { "source": "iana" },
44224    "audio/vnd.cmles.radio-events": { "source": "iana" },
44225    "audio/vnd.cns.anp1": { "source": "iana" },
44226    "audio/vnd.cns.inf1": { "source": "iana" },
44227    "audio/vnd.dece.audio": { "source": "iana", "extensions": ["uva", "uvva"] },
44228    "audio/vnd.digital-winds": { "source": "iana", "extensions": ["eol"] },
44229    "audio/vnd.dlna.adts": { "source": "iana" },
44230    "audio/vnd.dolby.heaac.1": { "source": "iana" },
44231    "audio/vnd.dolby.heaac.2": { "source": "iana" },
44232    "audio/vnd.dolby.mlp": { "source": "iana" },
44233    "audio/vnd.dolby.mps": { "source": "iana" },
44234    "audio/vnd.dolby.pl2": { "source": "iana" },
44235    "audio/vnd.dolby.pl2x": { "source": "iana" },
44236    "audio/vnd.dolby.pl2z": { "source": "iana" },
44237    "audio/vnd.dolby.pulse.1": { "source": "iana" },

44238    "audio/vnd.dra": { "source": "iana", "extensions": ["dra"] },
44239    "audio/vnd.dts": { "source": "iana", "extensions": ["dts"] },
44240    "audio/vnd.dts.hd": { "source": "iana", "extensions": ["dtshd"] },
44241    "audio/vnd.dts.uhd": { "source": "iana" },
44242    "audio/vnd.dvb.file": { "source": "iana" },
44243    "audio/vnd.everad.plj": { "source": "iana" },
44244    "audio/vnd.hns.audio": { "source": "iana" },
44245    "audio/vnd.lucent.voice": { "source": "iana", "extensions": ["lvp"] },
44246    "audio/vnd.ms-playready.media.pya": { "source": "iana", "extensions": ["pya"] },
44247    "audio/vnd.nokia.mobile-xmf": { "source": "iana" },
44248    "audio/vnd.nortel.vbk": { "source": "iana" },
44249    "audio/vnd.nuera.ecelp4800": { "source": "iana", "extensions": ["ecelp4800"] },
44250    "audio/vnd.nuera.ecelp7470": { "source": "iana", "extensions": ["ecelp7470"] },
44251    "audio/vnd.nuera.ecelp9600": { "source": "iana", "extensions": ["ecelp9600"] },
44252    "audio/vnd.octel.sbc": { "source": "iana" },
44253    "audio/vnd.presonus.multitrack": { "source": "iana" },
44254    "audio/vnd.qcelp": { "source": "iana" },
44255    "audio/vnd.rhetorex.32kadpcm": { "source": "iana" },
44256    "audio/vnd.rip": { "source": "iana", "extensions": ["rip"] },
44257    "audio/vnd.rn-realaudio": { "compressible": false },
44258    "audio/vnd.sealedmedia.softseal.mpeg": { "source": "iana" },
44259    "audio/vnd.vmx.cvsd": { "source": "iana" },
44260    "audio/vnd.wave": { "compressible": false },
44261    "audio/vorbis": { "source": "iana", "compressible": false },
44262    "audio/vorbis-config": { "source": "iana" },
44263    "audio/wav": { "compressible": false, "extensions": ["wav"] },
44264    "audio/wave": { "compressible": false, "extensions": ["wav"] },
44265    "audio/webm": { "source": "apache", "compressible": false, "extensions": ["weba"] },
44266    "audio/x-aac": { "source": "apache", "compressible": false, "extensions": ["aac"] },
44267    "audio/x-aiff": { "source": "apache", "extensions": ["aif", "aiff", "aifc"] },
44268    "audio/x-caf": { "source": "apache", "compressible": false, "extensions": ["caf"] },

44269    "audio/x-flac": { "source": "apache", "extensions": ["flac"] },
44270    "audio/x-m4a": { "source": "nginx", "extensions": ["m4a"] },
44271    "audio/x-matroska": { "source": "apache", "extensions": ["mka"] },
44272    "audio/x-mpegurl": { "source": "apache", "extensions": ["m3u"] },
44273    "audio/x-ms-wax": { "source": "apache", "extensions": ["wax"] },
44274    "audio/x-ms-wma": { "source": "apache", "extensions": ["wma"] },
44275    "audio/x-pn-realaudio": { "source": "apache", "extensions": ["ram", "ra"] },
44276    "audio/x-pn-realaudio-plugin": { "source": "apache", "extensions": ["rmp"] },
44277    "audio/x-realaudio": { "source": "nginx", "extensions": ["ra"] },
44278    "audio/x-tta": { "source": "apache" },
44279    "audio/x-wav": { "source": "apache", "extensions": ["wav"] },
44280    "audio/xm": { "source": "apache", "extensions": ["xm"] },
44281    "chemical/x-cdx": { "source": "apache", "extensions": ["cdx"] },
44282    "chemical/x-cif": { "source": "apache", "extensions": ["cif"] },
44283    "chemical/x-cmdf": { "source": "apache", "extensions": ["cmdf"] },
44284    "chemical/x-cml": { "source": "apache", "extensions": ["cml"] },
44285    "chemical/x-csml": { "source": "apache", "extensions": ["csml"] },
44286    "chemical/x-pdb": { "source": "apache" },
44287    "chemical/x-xyz": { "source": "apache", "extensions": ["xyz"] },
44288    "font/collection": { "source": "iana", "extensions": ["ttc"] },
44289    "font/otf": { "source": "iana", "compressible": true, "extensions": ["otf"] },
44290    "font/sfnt": { "source": "iana" },
44291    "font/ttf": { "source": "iana", "compressible": true, "extensions": ["ttf"] },
44292    "font/woff": { "source": "iana", "extensions": ["woff"] },
44293    "font/woff2": { "source": "iana", "extensions": ["woff2"] },
44294    "image/aces": { "source": "iana", "extensions": ["exr"] },
44295    "image/apng": { "compressible": false, "extensions": ["apng"] },
44296    "image/avci": { "source": "iana", "extensions": ["avci"] },
44297    "image/avcs": { "source": "iana", "extensions": ["avcs"] },
44298    "image/avif": { "source": "iana", "compressible": false, "extensions": ["avif"] },
44299    "image/bmp": { "source": "iana", "compressible": true, "extensions": ["bmp"] },
44300    "image/cgm": { "source": "iana", "extensions": ["cgm"] },
44301    "image/dicom-rle": { "source": "iana", "extensions": ["drle"] },
44302    "image/emf": { "source": "iana", "extensions": ["emf"] },
44303    "image/fits": { "source": "iana", "extensions": ["fits"] },
44304    "image/g3fax": { "source": "iana", "extensions": ["g3"] },
44305    "image/gif": { "source": "iana", "compressible": false, "extensions": ["gif"] },
44306    "image/heic": { "source": "iana", "extensions": ["heic"] },
44307    "image/heic-sequence": { "source": "iana", "extensions": ["heics"] },
44308    "image/heif": { "source": "iana", "extensions": ["heif"] },
44309    "image/heif-sequence": { "source": "iana", "extensions": ["heifs"] },
44310    "image/hej2k": { "source": "iana", "extensions": ["hej2"] },
44311    "image/hsj2": { "source": "iana", "extensions": ["hsj2"] },
44312    "image/ief": { "source": "iana", "extensions": ["ief"] },
44313    "image/jls": { "source": "iana", "extensions": ["jls"] },

vendor: 3,182 bytes, lines 44314-44358

44314    "image/jp2": { "source": "iana", "compressible": false, "extensions": ["jp2", "jpg2"] },
44315    "image/jpeg": { "source": "iana", "compressible": false, "extensions": ["jpeg", "jpg", "jpe"] },
44316    "image/jph": { "source": "iana", "extensions": ["jph"] },
44317    "image/jphc": { "source": "iana", "extensions": ["jhc"] },
44318    "image/jpm": { "source": "iana", "compressible": false, "extensions": ["jpm"] },
44319    "image/jpx": { "source": "iana", "compressible": false, "extensions": ["jpx", "jpf"] },
44320    "image/jxr": { "source": "iana", "extensions": ["jxr"] },
44321    "image/jxra": { "source": "iana", "extensions": ["jxra"] },
44322    "image/jxrs": { "source": "iana", "extensions": ["jxrs"] },
44323    "image/jxs": { "source": "iana", "extensions": ["jxs"] },
44324    "image/jxsc": { "source": "iana", "extensions": ["jxsc"] },
44325    "image/jxsi": { "source": "iana", "extensions": ["jxsi"] },
44326    "image/jxss": { "source": "iana", "extensions": ["jxss"] },
44327    "image/ktx": { "source": "iana", "extensions": ["ktx"] },
44328    "image/ktx2": { "source": "iana", "extensions": ["ktx2"] },
44329    "image/naplps": { "source": "iana" },
44330    "image/pjpeg": { "compressible": false },
44331    "image/png": { "source": "iana", "compressible": false, "extensions": ["png"] },
44332    "image/prs.btif": { "source": "iana", "extensions": ["btif"] },
44333    "image/prs.pti": { "source": "iana", "extensions": ["pti"] },
44334    "image/pwg-raster": { "source": "iana" },
44335    "image/sgi": { "source": "apache", "extensions": ["sgi"] },
44336    "image/svg+xml": { "source": "iana", "compressible": true, "extensions": ["svg", "svgz"] },
44337    "image/t38": { "source": "iana", "extensions": ["t38"] },
44338    "image/tiff": { "source": "iana", "compressible": false, "extensions": ["tif", "tiff"] },
44339    "image/tiff-fx": { "source": "iana", "extensions": ["tfx"] },
44340    "image/vnd.adobe.photoshop": { "source": "iana", "compressible": true, "extensions": ["psd"] },
44341    "image/vnd.airzip.accelerator.azv": { "source": "iana", "extensions": ["azv"] },
44342    "image/vnd.cns.inf2": { "source": "iana" },
44343    "image/vnd.dece.graphic": { "source": "iana", "extensions": ["uvi", "uvvi", "uvg", "uvvg"] },
44344    "image/vnd.djvu": { "source": "iana", "extensions": ["djvu", "djv"] },
44345    "image/vnd.dvb.subtitle": { "source": "iana", "extensions": ["sub"] },
44346    "image/vnd.dwg": { "source": "iana", "extensions": ["dwg"] },
44347    "image/vnd.dxf": { "source": "iana", "extensions": ["dxf"] },
44348    "image/vnd.fastbidsheet": { "source": "iana", "extensions": ["fbs"] },
44349    "image/vnd.fpx": { "source": "iana", "extensions": ["fpx"] },
44350    "image/vnd.fst": { "source": "iana", "extensions": ["fst"] },
44351    "image/vnd.fujixerox.edmics-mmr": { "source": "iana", "extensions": ["mmr"] },
44352    "image/vnd.fujixerox.edmics-rlc": { "source": "iana", "extensions": ["rlc"] },
44353    "image/vnd.globalgraphics.pgb": { "source": "iana" },
44354    "image/vnd.microsoft.icon": { "source": "iana", "compressible": true, "extensions": ["ico"] },
44355    "image/vnd.mix": { "source": "iana" },
44356    "image/vnd.mozilla.apng": { "source": "iana" },
44357    "image/vnd.ms-dds": { "compressible": true, "extensions": ["dds"] },
44358    "image/vnd.ms-modi": { "source": "iana", "extensions": ["mdi"] },

44359    "image/vnd.ms-photo": { "source": "apache", "extensions": ["wdp"] },
44360    "image/vnd.net-fpx": { "source": "iana", "extensions": ["npx"] },
44361    "image/vnd.pco.b16": { "source": "iana", "extensions": ["b16"] },
44362    "image/vnd.radiance": { "source": "iana" },
44363    "image/vnd.sealed.png": { "source": "iana" },
44364    "image/vnd.sealedmedia.softseal.gif": { "source": "iana" },
44365    "image/vnd.sealedmedia.softseal.jpg": { "source": "iana" },
44366    "image/vnd.svf": { "source": "iana" },
44367    "image/vnd.tencent.tap": { "source": "iana", "extensions": ["tap"] },
44368    "image/vnd.valve.source.texture": { "source": "iana", "extensions": ["vtf"] },
44369    "image/vnd.wap.wbmp": { "source": "iana", "extensions": ["wbmp"] },
44370    "image/vnd.xiff": { "source": "iana", "extensions": ["xif"] },
44371    "image/vnd.zbrush.pcx": { "source": "iana", "extensions": ["pcx"] },
44372    "image/webp": { "source": "apache", "extensions": ["webp"] },
44373    "image/wmf": { "source": "iana", "extensions": ["wmf"] },
44374    "image/x-3ds": { "source": "apache", "extensions": ["3ds"] },
44375    "image/x-cmu-raster": { "source": "apache", "extensions": ["ras"] },
44376    "image/x-cmx": { "source": "apache", "extensions": ["cmx"] },
44377    "image/x-freehand": { "source": "apache", "extensions": ["fh", "fhc", "fh4", "fh5", "fh7"] },
44378    "image/x-icon": { "source": "apache", "compressible": true, "extensions": ["ico"] },
44379    "image/x-jng": { "source": "nginx", "extensions": ["jng"] },
44380    "image/x-mrsid-image": { "source": "apache", "extensions": ["sid"] },
44381    "image/x-ms-bmp": { "source": "nginx", "compressible": true, "extensions": ["bmp"] },
44382    "image/x-pcx": { "source": "apache", "extensions": ["pcx"] },
44383    "image/x-pict": { "source": "apache", "extensions": ["pic", "pct"] },
44384    "image/x-portable-anymap": { "source": "apache", "extensions": ["pnm"] },
44385    "image/x-portable-bitmap": { "source": "apache", "extensions": ["pbm"] },
44386    "image/x-portable-graymap": { "source": "apache", "extensions": ["pgm"] },
44387    "image/x-portable-pixmap": { "source": "apache", "extensions": ["ppm"] },
44388    "image/x-rgb": { "source": "apache", "extensions": ["rgb"] },
44389    "image/x-tga": { "source": "apache", "extensions": ["tga"] },
44390    "image/x-xbitmap": { "source": "apache", "extensions": ["xbm"] },
44391    "image/x-xcf": { "compressible": false },
44392    "image/x-xpixmap": { "source": "apache", "extensions": ["xpm"] },
44393    "image/x-xwindowdump": { "source": "apache", "extensions": ["xwd"] },
44394    "message/cpim": { "source": "iana" },
44395    "message/delivery-status": { "source": "iana" },
44396    "message/disposition-notification": { "source": "iana", "extensions": ["disposition-notification"] },
44397    "message/external-body": { "source": "iana" },
44398    "message/feedback-report": { "source": "iana" },
44399    "message/global": { "source": "iana", "extensions": ["u8msg"] },
44400    "message/global-delivery-status": { "source": "iana", "extensions": ["u8dsn"] },
44401    "message/global-disposition-notification": { "source": "iana", "extensions": ["u8mdn"] },
44402    "message/global-headers": { "source": "iana", "extensions": ["u8hdr"] },
44403    "message/http": { "source": "iana", "compressible": false },
44404    "message/imdn+xml": { "source": "iana", "compressible": true },
44405    "message/news": { "source": "iana" },
44406    "message/partial": { "source": "iana", "compressible": false },
44407    "message/rfc822": { "source": "iana", "compressible": true, "extensions": ["eml", "mime"] },
44408    "message/s-http": { "source": "iana" },
44409    "message/sip": { "source": "iana" },
44410    "message/sipfrag": { "source": "iana" },
44411    "message/tracking-status": { "source": "iana" },
44412    "message/vnd.si.simp": { "source": "iana" },

44413    "message/vnd.wfa.wsc": { "source": "iana", "extensions": ["wsc"] },
44414    "model/3mf": { "source": "iana", "extensions": ["3mf"] },
44415    "model/e57": { "source": "iana" },
44416    "model/gltf+json": { "source": "iana", "compressible": true, "extensions": ["gltf"] },
44417    "model/gltf-binary": { "source": "iana", "compressible": true, "extensions": ["glb"] },
44418    "model/iges": { "source": "iana", "compressible": false, "extensions": ["igs", "iges"] },
44419    "model/mesh": { "source": "iana", "compressible": false, "extensions": ["msh", "mesh", "silo"] },
44420    "model/mtl": { "source": "iana", "extensions": ["mtl"] },
44421    "model/obj": { "source": "iana", "extensions": ["obj"] },
44422    "model/step": { "source": "iana" },
44423    "model/step+xml": { "source": "iana", "compressible": true, "extensions": ["stpx"] },
44424    "model/step+zip": { "source": "iana", "compressible": false, "extensions": ["stpz"] },
44425    "model/step-xml+zip": { "source": "iana", "compressible": false, "extensions": ["stpxz"] },
44426    "model/stl": { "source": "iana", "extensions": ["stl"] },
44427    "model/vnd.collada+xml": { "source": "iana", "compressible": true, "extensions": ["dae"] },
44428    "model/vnd.dwf": { "source": "iana", "extensions": ["dwf"] },
44429    "model/vnd.flatland.3dml": { "source": "iana" },
44430    "model/vnd.gdl": { "source": "iana", "extensions": ["gdl"] },
44431    "model/vnd.gs-gdl": { "source": "apache" },
44432    "model/vnd.gs.gdl": { "source": "iana" },
44433    "model/vnd.gtw": { "source": "iana", "extensions": ["gtw"] },
44434    "model/vnd.moml+xml": { "source": "iana", "compressible": true },
44435    "model/vnd.mts": { "source": "iana", "extensions": ["mts"] },
44436    "model/vnd.opengex": { "source": "iana", "extensions": ["ogex"] },
44437    "model/vnd.parasolid.transmit.binary": { "source": "iana", "extensions": ["x_b"] },
44438    "model/vnd.parasolid.transmit.text": { "source": "iana", "extensions": ["x_t"] },
44439    "model/vnd.pytha.pyox": { "source": "iana" },
44440    "model/vnd.rosette.annotated-data-model": { "source": "iana" },
44441    "model/vnd.sap.vds": { "source": "iana", "extensions": ["vds"] },
44442    "model/vnd.usdz+zip": { "source": "iana", "compressible": false, "extensions": ["usdz"] },
44443    "model/vnd.valve.source.compiled-map": { "source": "iana", "extensions": ["bsp"] },
44444    "model/vnd.vtu": { "source": "iana", "extensions": ["vtu"] },
44445    "model/vrml": { "source": "iana", "compressible": false, "extensions": ["wrl", "vrml"] },
44446    "model/x3d+binary": { "source": "apache", "compressible": false, "extensions": ["x3db", "x3dbz"] },
44447    "model/x3d+fastinfoset": { "source": "iana", "extensions": ["x3db"] },
44448    "model/x3d+vrml": { "source": "apache", "compressible": false, "extensions": ["x3dv", "x3dvz"] },
44449    "model/x3d+xml": { "source": "iana", "compressible": true, "extensions": ["x3d", "x3dz"] },
44450    "model/x3d-vrml": { "source": "iana", "extensions": ["x3dv"] },
44451    "multipart/alternative": { "source": "iana", "compressible": false },
44452    "multipart/appledouble": { "source": "iana" },
44453    "multipart/byteranges": { "source": "iana" },
44454    "multipart/digest": { "source": "iana" },
44455    "multipart/encrypted": { "source": "iana", "compressible": false },

vendor: 8,691 bytes, lines 44456-44594

44456    "multipart/form-data": { "source": "iana", "compressible": false },
44457    "multipart/header-set": { "source": "iana" },
44458    "multipart/mixed": { "source": "iana" },
44459    "multipart/multilingual": { "source": "iana" },
44460    "multipart/parallel": { "source": "iana" },
44461    "multipart/related": { "source": "iana", "compressible": false },
44462    "multipart/report": { "source": "iana" },
44463    "multipart/signed": { "source": "iana", "compressible": false },
44464    "multipart/vnd.bint.med-plus": { "source": "iana" },
44465    "multipart/voice-message": { "source": "iana" },
44466    "multipart/x-mixed-replace": { "source": "iana" },
44467    "text/1d-interleaved-parityfec": { "source": "iana" },
44468    "text/cache-manifest": { "source": "iana", "compressible": true, "extensions": ["appcache", "manifest"] },
44469    "text/calendar": { "source": "iana", "extensions": ["ics", "ifb"] },
44470    "text/calender": { "compressible": true },
44471    "text/cmd": { "compressible": true },
44472    "text/coffeescript": { "extensions": ["coffee", "litcoffee"] },
44473    "text/cql": { "source": "iana" },
44474    "text/cql-expression": { "source": "iana" },
44475    "text/cql-identifier": { "source": "iana" },
44476    "text/css": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["css"] },
44477    "text/csv": { "source": "iana", "compressible": true, "extensions": ["csv"] },
44478    "text/csv-schema": { "source": "iana" },
44479    "text/directory": { "source": "iana" },
44480    "text/dns": { "source": "iana" },
44481    "text/ecmascript": { "source": "iana" },
44482    "text/encaprtp": { "source": "iana" },
44483    "text/enriched": { "source": "iana" },
44484    "text/fhirpath": { "source": "iana" },
44485    "text/flexfec": { "source": "iana" },
44486    "text/fwdred": { "source": "iana" },
44487    "text/gff3": { "source": "iana" },
44488    "text/grammar-ref-list": { "source": "iana" },
44489    "text/html": { "source": "iana", "compressible": true, "extensions": ["html", "htm", "shtml"] },
44490    "text/jade": { "extensions": ["jade"] },
44491    "text/javascript": { "source": "iana", "compressible": true },
44492    "text/jcr-cnd": { "source": "iana" },
44493    "text/jsx": { "compressible": true, "extensions": ["jsx"] },
44494    "text/less": { "compressible": true, "extensions": ["less"] },
44495    "text/markdown": { "source": "iana", "compressible": true, "extensions": ["markdown", "md"] },
44496    "text/mathml": { "source": "nginx", "extensions": ["mml"] },
44497    "text/mdx": { "compressible": true, "extensions": ["mdx"] },
44498    "text/mizar": { "source": "iana" },
44499    "text/n3": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["n3"] },
44500    "text/parameters": { "source": "iana", "charset": "UTF-8" },
44501    "text/parityfec": { "source": "iana" },
44502    "text/plain": { "source": "iana", "compressible": true, "extensions": ["txt", "text", "conf", "def", "list", "log", "in", "ini"] },
44503    "text/provenance-notation": { "source": "iana", "charset": "UTF-8" },
44504    "text/prs.fallenstein.rst": { "source": "iana" },
44505    "text/prs.lines.tag": { "source": "iana", "extensions": ["dsc"] },
44506    "text/prs.prop.logic": { "source": "iana" },
44507    "text/raptorfec": { "source": "iana" },
44508    "text/red": { "source": "iana" },
44509    "text/rfc822-headers": { "source": "iana" },
44510    "text/richtext": { "source": "iana", "compressible": true, "extensions": ["rtx"] },
44511    "text/rtf": { "source": "iana", "compressible": true, "extensions": ["rtf"] },
44512    "text/rtp-enc-aescm128": { "source": "iana" },
44513    "text/rtploopback": { "source": "iana" },
44514    "text/rtx": { "source": "iana" },
44515    "text/sgml": { "source": "iana", "extensions": ["sgml", "sgm"] },
44516    "text/shaclc": { "source": "iana" },
44517    "text/shex": { "source": "iana", "extensions": ["shex"] },
44518    "text/slim": { "extensions": ["slim", "slm"] },
44519    "text/spdx": { "source": "iana", "extensions": ["spdx"] },
44520    "text/strings": { "source": "iana" },
44521    "text/stylus": { "extensions": ["stylus", "styl"] },
44522    "text/t140": { "source": "iana" },
44523    "text/tab-separated-values": { "source": "iana", "compressible": true, "extensions": ["tsv"] },
44524    "text/troff": { "source": "iana", "extensions": ["t", "tr", "roff", "man", "me", "ms"] },
44525    "text/turtle": { "source": "iana", "charset": "UTF-8", "extensions": ["ttl"] },
44526    "text/ulpfec": { "source": "iana" },
44527    "text/uri-list": { "source": "iana", "compressible": true, "extensions": ["uri", "uris", "urls"] },
44528    "text/vcard": { "source": "iana", "compressible": true, "extensions": ["vcard"] },
44529    "text/vnd.a": { "source": "iana" },
44530    "text/vnd.abc": { "source": "iana" },
44531    "text/vnd.ascii-art": { "source": "iana" },
44532    "text/vnd.curl": { "source": "iana", "extensions": ["curl"] },
44533    "text/vnd.curl.dcurl": { "source": "apache", "extensions": ["dcurl"] },
44534    "text/vnd.curl.mcurl": { "source": "apache", "extensions": ["mcurl"] },
44535    "text/vnd.curl.scurl": { "source": "apache", "extensions": ["scurl"] },
44536    "text/vnd.debian.copyright": { "source": "iana", "charset": "UTF-8" },
44537    "text/vnd.dmclientscript": { "source": "iana" },
44538    "text/vnd.dvb.subtitle": { "source": "iana", "extensions": ["sub"] },
44539    "text/vnd.esmertec.theme-descriptor": { "source": "iana", "charset": "UTF-8" },
44540    "text/vnd.familysearch.gedcom": { "source": "iana", "extensions": ["ged"] },
44541    "text/vnd.ficlab.flt": { "source": "iana" },
44542    "text/vnd.fly": { "source": "iana", "extensions": ["fly"] },
44543    "text/vnd.fmi.flexstor": { "source": "iana", "extensions": ["flx"] },
44544    "text/vnd.gml": { "source": "iana" },
44545    "text/vnd.graphviz": { "source": "iana", "extensions": ["gv"] },
44546    "text/vnd.hans": { "source": "iana" },
44547    "text/vnd.hgl": { "source": "iana" },
44548    "text/vnd.in3d.3dml": { "source": "iana", "extensions": ["3dml"] },
44549    "text/vnd.in3d.spot": { "source": "iana", "extensions": ["spot"] },
44550    "text/vnd.iptc.newsml": { "source": "iana" },
44551    "text/vnd.iptc.nitf": { "source": "iana" },
44552    "text/vnd.latex-z": { "source": "iana" },
44553    "text/vnd.motorola.reflex": { "source": "iana" },
44554    "text/vnd.ms-mediapackage": { "source": "iana" },
44555    "text/vnd.net2phone.commcenter.command": { "source": "iana" },
44556    "text/vnd.radisys.msml-basic-layout": { "source": "iana" },
44557    "text/vnd.senx.warpscript": { "source": "iana" },
44558    "text/vnd.si.uricatalogue": { "source": "iana" },
44559    "text/vnd.sosi": { "source": "iana" },
44560    "text/vnd.sun.j2me.app-descriptor": { "source": "iana", "charset": "UTF-8", "extensions": ["jad"] },
44561    "text/vnd.trolltech.linguist": { "source": "iana", "charset": "UTF-8" },
44562    "text/vnd.wap.si": { "source": "iana" },
44563    "text/vnd.wap.sl": { "source": "iana" },
44564    "text/vnd.wap.wml": { "source": "iana", "extensions": ["wml"] },
44565    "text/vnd.wap.wmlscript": { "source": "iana", "extensions": ["wmls"] },
44566    "text/vtt": { "source": "iana", "charset": "UTF-8", "compressible": true, "extensions": ["vtt"] },
44567    "text/x-asm": { "source": "apache", "extensions": ["s", "asm"] },
44568    "text/x-c": { "source": "apache", "extensions": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] },
44569    "text/x-component": { "source": "nginx", "extensions": ["htc"] },
44570    "text/x-fortran": { "source": "apache", "extensions": ["f", "for", "f77", "f90"] },
44571    "text/x-gwt-rpc": { "compressible": true },
44572    "text/x-handlebars-template": { "extensions": ["hbs"] },
44573    "text/x-java-source": { "source": "apache", "extensions": ["java"] },
44574    "text/x-jquery-tmpl": { "compressible": true },
44575    "text/x-lua": { "extensions": ["lua"] },
44576    "text/x-markdown": { "compressible": true, "extensions": ["mkd"] },
44577    "text/x-nfo": { "source": "apache", "extensions": ["nfo"] },
44578    "text/x-opml": { "source": "apache", "extensions": ["opml"] },
44579    "text/x-org": { "compressible": true, "extensions": ["org"] },
44580    "text/x-pascal": { "source": "apache", "extensions": ["p", "pas"] },
44581    "text/x-processing": { "compressible": true, "extensions": ["pde"] },
44582    "text/x-sass": { "extensions": ["sass"] },
44583    "text/x-scss": { "extensions": ["scss"] },
44584    "text/x-setext": { "source": "apache", "extensions": ["etx"] },
44585    "text/x-sfv": { "source": "apache", "extensions": ["sfv"] },
44586    "text/x-suse-ymp": { "compressible": true, "extensions": ["ymp"] },
44587    "text/x-uuencode": { "source": "apache", "extensions": ["uu"] },
44588    "text/x-vcalendar": { "source": "apache", "extensions": ["vcs"] },
44589    "text/x-vcard": { "source": "apache", "extensions": ["vcf"] },
44590    "text/xml": { "source": "iana", "compressible": true, "extensions": ["xml"] },
44591    "text/xml-external-parsed-entity": { "source": "iana" },
44592    "text/yaml": { "compressible": true, "extensions": ["yaml", "yml"] },
44593    "video/1d-interleaved-parityfec": { "source": "iana" },
44594    "video/3gpp": { "source": "iana", "extensions": ["3gp", "3gpp"] },

44595    "video/3gpp-tt": { "source": "iana" },
44596    "video/3gpp2": { "source": "iana", "extensions": ["3g2"] },
44597    "video/av1": { "source": "iana" },
44598    "video/bmpeg": { "source": "iana" },
44599    "video/bt656": { "source": "iana" },
44600    "video/celb": { "source": "iana" },
44601    "video/dv": { "source": "iana" },
44602    "video/encaprtp": { "source": "iana" },
44603    "video/ffv1": { "source": "iana" },
44604    "video/flexfec": { "source": "iana" },
44605    "video/h261": { "source": "iana", "extensions": ["h261"] },
44606    "video/h263": { "source": "iana", "extensions": ["h263"] },
44607    "video/h263-1998": { "source": "iana" },
44608    "video/h263-2000": { "source": "iana" },
44609    "video/h264": { "source": "iana", "extensions": ["h264"] },
44610    "video/h264-rcdo": { "source": "iana" },
44611    "video/h264-svc": { "source": "iana" },
44612    "video/h265": { "source": "iana" },
44613    "video/iso.segment": { "source": "iana", "extensions": ["m4s"] },
44614    "video/jpeg": { "source": "iana", "extensions": ["jpgv"] },
44615    "video/jpeg2000": { "source": "iana" },
44616    "video/jpm": { "source": "apache", "extensions": ["jpm", "jpgm"] },
44617    "video/jxsv": { "source": "iana" },
44618    "video/mj2": { "source": "iana", "extensions": ["mj2", "mjp2"] },
44619    "video/mp1s": { "source": "iana" },
44620    "video/mp2p": { "source": "iana" },
44621    "video/mp2t": { "source": "iana", "extensions": ["ts"] },
44622    "video/mp4": { "source": "iana", "compressible": false, "extensions": ["mp4", "mp4v", "mpg4"] },
44623    "video/mp4v-es": { "source": "iana" },
44624    "video/mpeg": { "source": "iana", "compressible": false, "extensions": ["mpeg", "mpg", "mpe", "m1v", "m2v"] },
44625    "video/mpeg4-generic": { "source": "iana" },
44626    "video/mpv": { "source": "iana" },
44627    "video/nv": { "source": "iana" },
44628    "video/ogg": { "source": "iana", "compressible": false, "extensions": ["ogv"] },
44629    "video/parityfec": { "source": "iana" },
44630    "video/pointer": { "source": "iana" },
44631    "video/quicktime": { "source": "iana", "compressible": false, "extensions": ["qt", "mov"] },
44632    "video/raptorfec": { "source": "iana" },
44633    "video/raw": { "source": "iana" },
44634    "video/rtp-enc-aescm128": { "source": "iana" },
44635    "video/rtploopback": { "source": "iana" },
44636    "video/rtx": { "source": "iana" },
44637    "video/scip": { "source": "iana" },
44638    "video/smpte291": { "source": "iana" },
44639    "video/smpte292m": { "source": "iana" },
44640    "video/ulpfec": { "source": "iana" },
44641    "video/vc1": { "source": "iana" },
44642    "video/vc2": { "source": "iana" },
44643    "video/vnd.cctv": { "source": "iana" },
44644    "video/vnd.dece.hd": { "source": "iana", "extensions": ["uvh", "uvvh"] },
44645    "video/vnd.dece.mobile": { "source": "iana", "extensions": ["uvm", "uvvm"] },
44646    "video/vnd.dece.mp4": { "source": "iana" },
44647    "video/vnd.dece.pd": { "source": "iana", "extensions": ["uvp", "uvvp"] },
44648    "video/vnd.dece.sd": { "source": "iana", "extensions": ["uvs", "uvvs"] },
44649    "video/vnd.dece.video": { "source": "iana", "extensions": ["uvv", "uvvv"] },
44650    "video/vnd.directv.mpeg": { "source": "iana" },
44651    "video/vnd.directv.mpeg-tts": { "source": "iana" },
44652    "video/vnd.dlna.mpeg-tts": { "source": "iana" },
44653    "video/vnd.dvb.file": { "source": "iana", "extensions": ["dvb"] },
44654    "video/vnd.fvt": { "source": "iana", "extensions": ["fvt"] },
44655    "video/vnd.hns.video": { "source": "iana" },
44656    "video/vnd.iptvforum.1dparityfec-1010": { "source": "iana" },
44657    "video/vnd.iptvforum.1dparityfec-2005": { "source": "iana" },
44658    "video/vnd.iptvforum.2dparityfec-1010": { "source": "iana" },
44659    "video/vnd.iptvforum.2dparityfec-2005": { "source": "iana" },
44660    "video/vnd.iptvforum.ttsavc": { "source": "iana" },
44661    "video/vnd.iptvforum.ttsmpeg2": { "source": "iana" },
44662    "video/vnd.motorola.video": { "source": "iana" },
44663    "video/vnd.motorola.videop": { "source": "iana" },
44664    "video/vnd.mpegurl": { "source": "iana", "extensions": ["mxu", "m4u"] },
44665    "video/vnd.ms-playready.media.pyv": { "source": "iana", "extensions": ["pyv"] },
44666    "video/vnd.nokia.interleaved-multimedia": { "source": "iana" },
44667    "video/vnd.nokia.mp4vr": { "source": "iana" },
44668    "video/vnd.nokia.videovoip": { "source": "iana" },

vendor: 4,225 bytes, lines 44669-44768

44669    "video/vnd.objectvideo": { "source": "iana" },
44670    "video/vnd.radgamettools.bink": { "source": "iana" },
44671    "video/vnd.radgamettools.smacker": { "source": "iana" },
44672    "video/vnd.sealed.mpeg1": { "source": "iana" },
44673    "video/vnd.sealed.mpeg4": { "source": "iana" },
44674    "video/vnd.sealed.swf": { "source": "iana" },
44675    "video/vnd.sealedmedia.softseal.mov": { "source": "iana" },
44676    "video/vnd.uvvu.mp4": { "source": "iana", "extensions": ["uvu", "uvvu"] },
44677    "video/vnd.vivo": { "source": "iana", "extensions": ["viv"] },
44678    "video/vnd.youtube.yt": { "source": "iana" },
44679    "video/vp8": { "source": "iana" },
44680    "video/vp9": { "source": "iana" },
44681    "video/webm": { "source": "apache", "compressible": false, "extensions": ["webm"] },
44682    "video/x-f4v": { "source": "apache", "extensions": ["f4v"] },
44683    "video/x-fli": { "source": "apache", "extensions": ["fli"] },
44684    "video/x-flv": { "source": "apache", "compressible": false, "extensions": ["flv"] },
44685    "video/x-m4v": { "source": "apache", "extensions": ["m4v"] },
44686    "video/x-matroska": { "source": "apache", "compressible": false, "extensions": ["mkv", "mk3d", "mks"] },
44687    "video/x-mng": { "source": "apache", "extensions": ["mng"] },
44688    "video/x-ms-asf": { "source": "apache", "extensions": ["asf", "asx"] },
44689    "video/x-ms-vob": { "source": "apache", "extensions": ["vob"] },
44690    "video/x-ms-wm": { "source": "apache", "extensions": ["wm"] },
44691    "video/x-ms-wmv": { "source": "apache", "compressible": false, "extensions": ["wmv"] },
44692    "video/x-ms-wmx": { "source": "apache", "extensions": ["wmx"] },
44693    "video/x-ms-wvx": { "source": "apache", "extensions": ["wvx"] },
44694    "video/x-msvideo": { "source": "apache", "extensions": ["avi"] },
44695    "video/x-sgi-movie": { "source": "apache", "extensions": ["movie"] },
44696    "video/x-smv": { "source": "apache", "extensions": ["smv"] },
44697    "x-conference/x-cooltalk": { "source": "apache", "extensions": ["ice"] },
44698    "x-shader/x-fragment": { "compressible": true },
44699    "x-shader/x-vertex": { "compressible": true }
44700  };
44701  /*!
44702  * mime-db
44703  * Copyright(c) 2014 Jonathan Ong
44704  * Copyright(c) 2015-2022 Douglas Christopher Wilson
44705  * MIT Licensed
44706  */
44707  var mimeDb;
44708  var hasRequiredMimeDb;
44709  function requireMimeDb() {
44710    if (hasRequiredMimeDb) return mimeDb;
44711    hasRequiredMimeDb = 1;
44712    mimeDb = require$$0;
44713    return mimeDb;
44714  }
44715  /*!
44716  * mime-types
44717  * Copyright(c) 2014 Jonathan Ong
44718  * Copyright(c) 2015 Douglas Christopher Wilson
44719  * MIT Licensed
44720  */
44721  var hasRequiredMimeTypes;
44722  function requireMimeTypes() {
44723    if (hasRequiredMimeTypes) return mimeTypes;
44724    hasRequiredMimeTypes = 1;
44725    (function(exports$12) {
44726      var db = requireMimeDb();
44727      var extname = requirePathBrowserify().extname;
44728      var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
44729      var TEXT_TYPE_REGEXP = /^text\//i;
44730      exports$12.charset = charset;
44731      exports$12.charsets = { lookup: charset };
44732      exports$12.contentType = contentType2;
44733      exports$12.extension = extension;
44734      exports$12.extensions = /* @__PURE__ */ Object.create(null);
44735      exports$12.lookup = lookup2;
44736      exports$12.types = /* @__PURE__ */ Object.create(null);
44737      populateMaps(exports$12.extensions, exports$12.types);
44738      function charset(type2) {
44739        if (!type2 || typeof type2 !== "string") {
44740          return false;
44741        }
44742        var match = EXTRACT_TYPE_REGEXP.exec(type2);
44743        var mime = match && db[match[1].toLowerCase()];
44744        if (mime && mime.charset) {
44745          return mime.charset;
44746        }
44747        if (match && TEXT_TYPE_REGEXP.test(match[1])) {
44748          return "UTF-8";
44749        }
44750        return false;
44751      }
44752      function contentType2(str) {
44753        if (!str || typeof str !== "string") {
44754          return false;
44755        }
44756        var mime = str.indexOf("/") === -1 ? exports$12.lookup(str) : str;
44757        if (!mime) {
44758          return false;
44759        }
44760        if (mime.indexOf("charset") === -1) {
44761          var charset2 = exports$12.charset(mime);
44762          if (charset2) mime += "; charset=" + charset2.toLowerCase();
44763        }
44764        return mime;
44765      }
44766      function extension(type2) {
44767        if (!type2 || typeof type2 !== "string") {
44768          return false;

vendor: 21,153 bytes, lines 44769-45378

44769        }
44770        var match = EXTRACT_TYPE_REGEXP.exec(type2);
44771        var exts = match && exports$12.extensions[match[1].toLowerCase()];
44772        if (!exts || !exts.length) {
44773          return false;
44774        }
44775        return exts[0];
44776      }
44777      function lookup2(path) {
44778        if (!path || typeof path !== "string") {
44779          return false;
44780        }
44781        var extension2 = extname("x." + path).toLowerCase().substr(1);
44782        if (!extension2) {
44783          return false;
44784        }
44785        return exports$12.types[extension2] || false;
44786      }
44787      function populateMaps(extensions, types2) {
44788        var preference = ["nginx", "apache", void 0, "iana"];
44789        Object.keys(db).forEach(function forEachMimeType(type2) {
44790          var mime = db[type2];
44791          var exts = mime.extensions;
44792          if (!exts || !exts.length) {
44793            return;
44794          }
44795          extensions[type2] = exts;
44796          for (var i2 = 0; i2 < exts.length; i2++) {
44797            var extension2 = exts[i2];
44798            if (types2[extension2]) {
44799              var from = preference.indexOf(db[types2[extension2]].source);
44800              var to = preference.indexOf(mime.source);
44801              if (types2[extension2] !== "application/octet-stream" && (from > to || from === to && types2[extension2].substr(0, 12) === "application/")) {
44802                continue;
44803              }
44804            }
44805            types2[extension2] = type2;
44806          }
44807        });
44808      }
44809    })(mimeTypes);
44810    return mimeTypes;
44811  }
44812  var defer_1;
44813  var hasRequiredDefer;
44814  function requireDefer() {
44815    if (hasRequiredDefer) return defer_1;
44816    hasRequiredDefer = 1;
44817    defer_1 = defer;
44818    function defer(fn) {
44819      var nextTick = typeof setImmediate == "function" ? setImmediate : typeof process$1 == "object" && typeof process$1.nextTick == "function" ? process$1.nextTick : null;
44820      if (nextTick) {
44821        nextTick(fn);
44822      } else {
44823        setTimeout(fn, 0);
44824      }
44825    }
44826    return defer_1;
44827  }
44828  var async_1;
44829  var hasRequiredAsync;
44830  function requireAsync() {
44831    if (hasRequiredAsync) return async_1;
44832    hasRequiredAsync = 1;
44833    var defer = requireDefer();
44834    async_1 = async2;
44835    function async2(callback) {
44836      var isAsync = false;
44837      defer(function() {
44838        isAsync = true;
44839      });
44840      return function async_callback(err, result) {
44841        if (isAsync) {
44842          callback(err, result);
44843        } else {
44844          defer(function nextTick_callback() {
44845            callback(err, result);
44846          });
44847        }
44848      };
44849    }
44850    return async_1;
44851  }
44852  var abort_1;
44853  var hasRequiredAbort;
44854  function requireAbort() {
44855    if (hasRequiredAbort) return abort_1;
44856    hasRequiredAbort = 1;
44857    abort_1 = abort;
44858    function abort(state2) {
44859      Object.keys(state2.jobs).forEach(clean.bind(state2));
44860      state2.jobs = {};
44861    }
44862    function clean(key2) {
44863      if (typeof this.jobs[key2] == "function") {
44864        this.jobs[key2]();
44865      }
44866    }
44867    return abort_1;
44868  }
44869  var iterate_1;
44870  var hasRequiredIterate;
44871  function requireIterate() {
44872    if (hasRequiredIterate) return iterate_1;
44873    hasRequiredIterate = 1;
44874    var async2 = requireAsync(), abort = requireAbort();
44875    iterate_1 = iterate;
44876    function iterate(list, iterator2, state2, callback) {
44877      var key2 = state2["keyedList"] ? state2["keyedList"][state2.index] : state2.index;
44878      state2.jobs[key2] = runJob(iterator2, key2, list[key2], function(error, output) {
44879        if (!(key2 in state2.jobs)) {
44880          return;
44881        }
44882        delete state2.jobs[key2];
44883        if (error) {
44884          abort(state2);
44885        } else {
44886          state2.results[key2] = output;
44887        }
44888        callback(error, state2.results);
44889      });
44890    }
44891    function runJob(iterator2, key2, item, callback) {
44892      var aborter;
44893      if (iterator2.length == 2) {
44894        aborter = iterator2(item, async2(callback));
44895      } else {
44896        aborter = iterator2(item, key2, async2(callback));
44897      }
44898      return aborter;
44899    }
44900    return iterate_1;
44901  }
44902  var state_1;
44903  var hasRequiredState;
44904  function requireState() {
44905    if (hasRequiredState) return state_1;
44906    hasRequiredState = 1;
44907    state_1 = state2;
44908    function state2(list, sortMethod) {
44909      var isNamedList = !Array.isArray(list), initState = {
44910        index: 0,
44911        keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
44912        jobs: {},
44913        results: isNamedList ? {} : [],
44914        size: isNamedList ? Object.keys(list).length : list.length
44915      };
44916      if (sortMethod) {
44917        initState.keyedList.sort(isNamedList ? sortMethod : function(a, b) {
44918          return sortMethod(list[a], list[b]);
44919        });
44920      }
44921      return initState;
44922    }
44923    return state_1;
44924  }
44925  var terminator_1;
44926  var hasRequiredTerminator;
44927  function requireTerminator() {
44928    if (hasRequiredTerminator) return terminator_1;
44929    hasRequiredTerminator = 1;
44930    var abort = requireAbort(), async2 = requireAsync();
44931    terminator_1 = terminator;
44932    function terminator(callback) {
44933      if (!Object.keys(this.jobs).length) {
44934        return;
44935      }
44936      this.index = this.size;
44937      abort(this);
44938      async2(callback)(null, this.results);
44939    }
44940    return terminator_1;
44941  }
44942  var parallel_1;
44943  var hasRequiredParallel;
44944  function requireParallel() {
44945    if (hasRequiredParallel) return parallel_1;
44946    hasRequiredParallel = 1;
44947    var iterate = requireIterate(), initState = requireState(), terminator = requireTerminator();
44948    parallel_1 = parallel;
44949    function parallel(list, iterator2, callback) {
44950      var state2 = initState(list);
44951      while (state2.index < (state2["keyedList"] || list).length) {
44952        iterate(list, iterator2, state2, function(error, result) {
44953          if (error) {
44954            callback(error, result);
44955            return;
44956          }
44957          if (Object.keys(state2.jobs).length === 0) {
44958            callback(null, state2.results);
44959            return;
44960          }
44961        });
44962        state2.index++;
44963      }
44964      return terminator.bind(state2, callback);
44965    }
44966    return parallel_1;
44967  }
44968  var serialOrdered = { exports: {} };
44969  var hasRequiredSerialOrdered;
44970  function requireSerialOrdered() {
44971    if (hasRequiredSerialOrdered) return serialOrdered.exports;
44972    hasRequiredSerialOrdered = 1;
44973    var iterate = requireIterate(), initState = requireState(), terminator = requireTerminator();
44974    serialOrdered.exports = serialOrdered$1;
44975    serialOrdered.exports.ascending = ascending;
44976    serialOrdered.exports.descending = descending;
44977    function serialOrdered$1(list, iterator2, sortMethod, callback) {
44978      var state2 = initState(list, sortMethod);
44979      iterate(list, iterator2, state2, function iteratorHandler(error, result) {
44980        if (error) {
44981          callback(error, result);
44982          return;
44983        }
44984        state2.index++;
44985        if (state2.index < (state2["keyedList"] || list).length) {
44986          iterate(list, iterator2, state2, iteratorHandler);
44987          return;
44988        }
44989        callback(null, state2.results);
44990      });
44991      return terminator.bind(state2, callback);
44992    }
44993    function ascending(a, b) {
44994      return a < b ? -1 : a > b ? 1 : 0;
44995    }
44996    function descending(a, b) {
44997      return -1 * ascending(a, b);
44998    }
44999    return serialOrdered.exports;
45000  }
45001  var serial_1;
45002  var hasRequiredSerial;
45003  function requireSerial() {
45004    if (hasRequiredSerial) return serial_1;
45005    hasRequiredSerial = 1;
45006    var serialOrdered2 = requireSerialOrdered();
45007    serial_1 = serial;
45008    function serial(list, iterator2, callback) {
45009      return serialOrdered2(list, iterator2, null, callback);
45010    }
45011    return serial_1;
45012  }
45013  var asynckit;
45014  var hasRequiredAsynckit;
45015  function requireAsynckit() {
45016    if (hasRequiredAsynckit) return asynckit;
45017    hasRequiredAsynckit = 1;
45018    asynckit = {
45019      parallel: requireParallel(),
45020      serial: requireSerial(),
45021      serialOrdered: requireSerialOrdered()
45022    };
45023    return asynckit;
45024  }
45025  var esSetTostringtag;
45026  var hasRequiredEsSetTostringtag;
45027  function requireEsSetTostringtag() {
45028    if (hasRequiredEsSetTostringtag) return esSetTostringtag;
45029    hasRequiredEsSetTostringtag = 1;
45030    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
45031    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
45032    var hasToStringTag = requireShams()();
45033    var hasOwn = /* @__PURE__ */ requireHasown();
45034    var $TypeError = /* @__PURE__ */ requireType();
45035    var toStringTag2 = hasToStringTag ? Symbol.toStringTag : null;
45036    esSetTostringtag = function setToStringTag(object, value) {
45037      var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
45038      var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
45039      if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
45040        throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
45041      }
45042      if (toStringTag2 && (overrideIfSet || !hasOwn(object, toStringTag2))) {
45043        if ($defineProperty) {
45044          $defineProperty(object, toStringTag2, {
45045            configurable: !nonConfigurable,
45046            enumerable: false,
45047            value,
45048            writable: false
45049          });
45050        } else {
45051          object[toStringTag2] = value;
45052        }
45053      }
45054    };
45055    return esSetTostringtag;
45056  }
45057  var populate;
45058  var hasRequiredPopulate;
45059  function requirePopulate() {
45060    if (hasRequiredPopulate) return populate;
45061    hasRequiredPopulate = 1;
45062    populate = function(dst, src2) {
45063      Object.keys(src2).forEach(function(prop) {
45064        dst[prop] = dst[prop] || src2[prop];
45065      });
45066      return dst;
45067    };
45068    return populate;
45069  }
45070  var form_data;
45071  var hasRequiredForm_data;
45072  function requireForm_data() {
45073    if (hasRequiredForm_data) return form_data;
45074    hasRequiredForm_data = 1;
45075    var CombinedStream = requireCombined_stream();
45076    var util2 = requireUtil$1();
45077    var path = requirePathBrowserify();
45078    var http3 = requireStreamHttp();
45079    var https2 = requireHttpsBrowserify();
45080    var parseUrl2 = requireUrl().parse;
45081    var fs = requireEmpty();
45082    var Stream = requireStreamBrowserify().Stream;
45083    var crypto2 = requireCryptoBrowserify();
45084    var mime = requireMimeTypes();
45085    var asynckit2 = requireAsynckit();
45086    var setToStringTag = /* @__PURE__ */ requireEsSetTostringtag();
45087    var hasOwn = /* @__PURE__ */ requireHasown();
45088    var populate2 = requirePopulate();
45089    function FormData2(options) {
45090      if (!(this instanceof FormData2)) {
45091        return new FormData2(options);
45092      }
45093      this._overheadLength = 0;
45094      this._valueLength = 0;
45095      this._valuesToMeasure = [];
45096      CombinedStream.call(this);
45097      options = options || {};
45098      for (var option in options) {
45099        this[option] = options[option];
45100      }
45101    }
45102    util2.inherits(FormData2, CombinedStream);
45103    FormData2.LINE_BREAK = "\r\n";
45104    FormData2.DEFAULT_CONTENT_TYPE = "application/octet-stream";
45105    FormData2.prototype.append = function(field, value, options) {
45106      options = options || {};
45107      if (typeof options === "string") {
45108        options = { filename: options };
45109      }
45110      var append = CombinedStream.prototype.append.bind(this);
45111      if (typeof value === "number" || value == null) {
45112        value = String(value);
45113      }
45114      if (Array.isArray(value)) {
45115        this._error(new Error("Arrays are not supported."));
45116        return;
45117      }
45118      var header = this._multiPartHeader(field, value, options);
45119      var footer = this._multiPartFooter();
45120      append(header);
45121      append(value);
45122      append(footer);
45123      this._trackLength(header, value, options);
45124    };
45125    FormData2.prototype._trackLength = function(header, value, options) {
45126      var valueLength = 0;
45127      if (options.knownLength != null) {
45128        valueLength += Number(options.knownLength);
45129      } else if (Buffer.isBuffer(value)) {
45130        valueLength = value.length;
45131      } else if (typeof value === "string") {
45132        valueLength = Buffer.byteLength(value);
45133      }
45134      this._valueLength += valueLength;
45135      this._overheadLength += Buffer.byteLength(header) + FormData2.LINE_BREAK.length;
45136      if (!value || !value.path && !(value.readable && hasOwn(value, "httpVersion")) && !(value instanceof Stream)) {
45137        return;
45138      }
45139      if (!options.knownLength) {
45140        this._valuesToMeasure.push(value);
45141      }
45142    };
45143    FormData2.prototype._lengthRetriever = function(value, callback) {
45144      if (hasOwn(value, "fd")) {
45145        if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
45146          callback(null, value.end + 1 - (value.start ? value.start : 0));
45147        } else {
45148          fs.stat(value.path, function(err, stat) {
45149            if (err) {
45150              callback(err);
45151              return;
45152            }
45153            var fileSize = stat.size - (value.start ? value.start : 0);
45154            callback(null, fileSize);
45155          });
45156        }
45157      } else if (hasOwn(value, "httpVersion")) {
45158        callback(null, Number(value.headers["content-length"]));
45159      } else if (hasOwn(value, "httpModule")) {
45160        value.on("response", function(response2) {
45161          value.pause();
45162          callback(null, Number(response2.headers["content-length"]));
45163        });
45164        value.resume();
45165      } else {
45166        callback("Unknown stream");
45167      }
45168    };
45169    FormData2.prototype._multiPartHeader = function(field, value, options) {
45170      if (typeof options.header === "string") {
45171        return options.header;
45172      }
45173      var contentDisposition = this._getContentDisposition(value, options);
45174      var contentType2 = this._getContentType(value, options);
45175      var contents = "";
45176      var headers = {
45177        // add custom disposition as third element or keep it two elements if not
45178        "Content-Disposition": ["form-data", 'name="' + field + '"'].concat(contentDisposition || []),
45179        // if no content type. allow it to be empty array
45180        "Content-Type": [].concat(contentType2 || [])
45181      };
45182      if (typeof options.header === "object") {
45183        populate2(headers, options.header);
45184      }
45185      var header;
45186      for (var prop in headers) {
45187        if (hasOwn(headers, prop)) {
45188          header = headers[prop];
45189          if (header == null) {
45190            continue;
45191          }
45192          if (!Array.isArray(header)) {
45193            header = [header];
45194          }
45195          if (header.length) {
45196            contents += prop + ": " + header.join("; ") + FormData2.LINE_BREAK;
45197          }
45198        }
45199      }
45200      return "--" + this.getBoundary() + FormData2.LINE_BREAK + contents + FormData2.LINE_BREAK;
45201    };
45202    FormData2.prototype._getContentDisposition = function(value, options) {
45203      var filename;
45204      if (typeof options.filepath === "string") {
45205        filename = path.normalize(options.filepath).replace(/\\/g, "/");
45206      } else if (options.filename || value && (value.name || value.path)) {
45207        filename = path.basename(options.filename || value && (value.name || value.path));
45208      } else if (value && value.readable && hasOwn(value, "httpVersion")) {
45209        filename = path.basename(value.client._httpMessage.path || "");
45210      }
45211      if (filename) {
45212        return 'filename="' + filename + '"';
45213      }
45214    };
45215    FormData2.prototype._getContentType = function(value, options) {
45216      var contentType2 = options.contentType;
45217      if (!contentType2 && value && value.name) {
45218        contentType2 = mime.lookup(value.name);
45219      }
45220      if (!contentType2 && value && value.path) {
45221        contentType2 = mime.lookup(value.path);
45222      }
45223      if (!contentType2 && value && value.readable && hasOwn(value, "httpVersion")) {
45224        contentType2 = value.headers["content-type"];
45225      }
45226      if (!contentType2 && (options.filepath || options.filename)) {
45227        contentType2 = mime.lookup(options.filepath || options.filename);
45228      }
45229      if (!contentType2 && value && typeof value === "object") {
45230        contentType2 = FormData2.DEFAULT_CONTENT_TYPE;
45231      }
45232      return contentType2;
45233    };
45234    FormData2.prototype._multiPartFooter = function() {
45235      return (function(next) {
45236        var footer = FormData2.LINE_BREAK;
45237        var lastPart = this._streams.length === 0;
45238        if (lastPart) {
45239          footer += this._lastBoundary();
45240        }
45241        next(footer);
45242      }).bind(this);
45243    };
45244    FormData2.prototype._lastBoundary = function() {
45245      return "--" + this.getBoundary() + "--" + FormData2.LINE_BREAK;
45246    };
45247    FormData2.prototype.getHeaders = function(userHeaders) {
45248      var header;
45249      var formHeaders = {
45250        "content-type": "multipart/form-data; boundary=" + this.getBoundary()
45251      };
45252      for (header in userHeaders) {
45253        if (hasOwn(userHeaders, header)) {
45254          formHeaders[header.toLowerCase()] = userHeaders[header];
45255        }
45256      }
45257      return formHeaders;
45258    };
45259    FormData2.prototype.setBoundary = function(boundary) {
45260      if (typeof boundary !== "string") {
45261        throw new TypeError("FormData boundary must be a string");
45262      }
45263      this._boundary = boundary;
45264    };
45265    FormData2.prototype.getBoundary = function() {
45266      if (!this._boundary) {
45267        this._generateBoundary();
45268      }
45269      return this._boundary;
45270    };
45271    FormData2.prototype.getBuffer = function() {
45272      var dataBuffer = new Buffer.alloc(0);
45273      var boundary = this.getBoundary();
45274      for (var i2 = 0, len2 = this._streams.length; i2 < len2; i2++) {
45275        if (typeof this._streams[i2] !== "function") {
45276          if (Buffer.isBuffer(this._streams[i2])) {
45277            dataBuffer = Buffer.concat([dataBuffer, this._streams[i2]]);
45278          } else {
45279            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(this._streams[i2])]);
45280          }
45281          if (typeof this._streams[i2] !== "string" || this._streams[i2].substring(2, boundary.length + 2) !== boundary) {
45282            dataBuffer = Buffer.concat([dataBuffer, Buffer.from(FormData2.LINE_BREAK)]);
45283          }
45284        }
45285      }
45286      return Buffer.concat([dataBuffer, Buffer.from(this._lastBoundary())]);
45287    };
45288    FormData2.prototype._generateBoundary = function() {
45289      this._boundary = "--------------------------" + crypto2.randomBytes(12).toString("hex");
45290    };
45291    FormData2.prototype.getLengthSync = function() {
45292      var knownLength = this._overheadLength + this._valueLength;
45293      if (this._streams.length) {
45294        knownLength += this._lastBoundary().length;
45295      }
45296      if (!this.hasKnownLength()) {
45297        this._error(new Error("Cannot calculate proper length in synchronous way."));
45298      }
45299      return knownLength;
45300    };
45301    FormData2.prototype.hasKnownLength = function() {
45302      var hasKnownLength = true;
45303      if (this._valuesToMeasure.length) {
45304        hasKnownLength = false;
45305      }
45306      return hasKnownLength;
45307    };
45308    FormData2.prototype.getLength = function(cb) {
45309      var knownLength = this._overheadLength + this._valueLength;
45310      if (this._streams.length) {
45311        knownLength += this._lastBoundary().length;
45312      }
45313      if (!this._valuesToMeasure.length) {
45314        process$1.nextTick(cb.bind(this, null, knownLength));
45315        return;
45316      }
45317      asynckit2.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
45318        if (err) {
45319          cb(err);
45320          return;
45321        }
45322        values.forEach(function(length) {
45323          knownLength += length;
45324        });
45325        cb(null, knownLength);
45326      });
45327    };
45328    FormData2.prototype.submit = function(params, cb) {
45329      var request2;
45330      var options;
45331      var defaults2 = { method: "post" };
45332      if (typeof params === "string") {
45333        params = parseUrl2(params);
45334        options = populate2({
45335          port: params.port,
45336          path: params.pathname,
45337          host: params.hostname,
45338          protocol: params.protocol
45339        }, defaults2);
45340      } else {
45341        options = populate2(params, defaults2);
45342        if (!options.port) {
45343          options.port = options.protocol === "https:" ? 443 : 80;
45344        }
45345      }
45346      options.headers = this.getHeaders(params.headers);
45347      if (options.protocol === "https:") {
45348        request2 = https2.request(options);
45349      } else {
45350        request2 = http3.request(options);
45351      }
45352      this.getLength((function(err, length) {
45353        if (err && err !== "Unknown stream") {
45354          this._error(err);
45355          return;
45356        }
45357        if (length) {
45358          request2.setHeader("Content-Length", length);
45359        }
45360        this.pipe(request2);
45361        if (cb) {
45362          var onResponse;
45363          var callback = function(error, responce) {
45364            request2.removeListener("error", callback);
45365            request2.removeListener("response", onResponse);
45366            return cb.call(this, error, responce);
45367          };
45368          onResponse = callback.bind(this, null);
45369          request2.on("error", callback);
45370          request2.on("response", onResponse);
45371        }
45372      }).bind(this));
45373      return request2;
45374    };
45375    FormData2.prototype._error = function(err) {
45376      if (!this.error) {
45377        this.error = err;
45378        this.pause();

vendor: 8,188 bytes, lines 45379-45622

45379        this.emit("error", err);
45380      }
45381    };
45382    FormData2.prototype.toString = function() {
45383      return "[object FormData]";
45384    };
45385    setToStringTag(FormData2.prototype, "FormData");
45386    form_data = FormData2;
45387    return form_data;
45388  }
45389  var form_dataExports = requireForm_data();
45390  const FormData$1 = /* @__PURE__ */ getDefaultExportFromCjs$1(form_dataExports);
45391  function isVisitable(thing) {
45392    return utils$5.isPlainObject(thing) || utils$5.isArray(thing);
45393  }
45394  function removeBrackets(key2) {
45395    return utils$5.endsWith(key2, "[]") ? key2.slice(0, -2) : key2;
45396  }
45397  function renderKey(path, key2, dots) {
45398    if (!path) return key2;
45399    return path.concat(key2).map(function each(token, i2) {
45400      token = removeBrackets(token);
45401      return !dots && i2 ? "[" + token + "]" : token;
45402    }).join(dots ? "." : "");
45403  }
45404  function isFlatArray(arr) {
45405    return utils$5.isArray(arr) && !arr.some(isVisitable);
45406  }
45407  const predicates = utils$5.toFlatObject(utils$5, {}, null, function filter(prop) {
45408    return /^is[A-Z]/.test(prop);
45409  });
45410  function toFormData$1(obj, formData, options) {
45411    if (!utils$5.isObject(obj)) {
45412      throw new TypeError("target must be an object");
45413    }
45414    formData = formData || new (FormData$1 || FormData)();
45415    options = utils$5.toFlatObject(
45416      options,
45417      {
45418        metaTokens: true,
45419        dots: false,
45420        indexes: false
45421      },
45422      false,
45423      function defined(option, source) {
45424        return !utils$5.isUndefined(source[option]);
45425      }
45426    );
45427    const metaTokens = options.metaTokens;
45428    const visitor = options.visitor || defaultVisitor;
45429    const dots = options.dots;
45430    const indexes = options.indexes;
45431    const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
45432    const maxDepth = options.maxDepth === void 0 ? 100 : options.maxDepth;
45433    const useBlob = _Blob && utils$5.isSpecCompliantForm(formData);
45434    if (!utils$5.isFunction(visitor)) {
45435      throw new TypeError("visitor must be a function");
45436    }
45437    function convertValue(value) {
45438      if (value === null) return "";
45439      if (utils$5.isDate(value)) {
45440        return value.toISOString();
45441      }
45442      if (utils$5.isBoolean(value)) {
45443        return value.toString();
45444      }
45445      if (!useBlob && utils$5.isBlob(value)) {
45446        throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
45447      }
45448      if (utils$5.isArrayBuffer(value) || utils$5.isTypedArray(value)) {
45449        return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
45450      }
45451      return value;
45452    }
45453    function defaultVisitor(value, key2, path) {
45454      let arr = value;
45455      if (utils$5.isReactNative(formData) && utils$5.isReactNativeBlob(value)) {
45456        formData.append(renderKey(path, key2, dots), convertValue(value));
45457        return false;
45458      }
45459      if (value && !path && typeof value === "object") {
45460        if (utils$5.endsWith(key2, "{}")) {
45461          key2 = metaTokens ? key2 : key2.slice(0, -2);
45462          value = JSON.stringify(value);
45463        } else if (utils$5.isArray(value) && isFlatArray(value) || (utils$5.isFileList(value) || utils$5.endsWith(key2, "[]")) && (arr = utils$5.toArray(value))) {
45464          key2 = removeBrackets(key2);
45465          arr.forEach(function each(el, index) {
45466            !(utils$5.isUndefined(el) || el === null) && formData.append(
45467              // eslint-disable-next-line no-nested-ternary
45468              indexes === true ? renderKey([key2], index, dots) : indexes === null ? key2 : key2 + "[]",
45469              convertValue(el)
45470            );
45471          });
45472          return false;
45473        }
45474      }
45475      if (isVisitable(value)) {
45476        return true;
45477      }
45478      formData.append(renderKey(path, key2, dots), convertValue(value));
45479      return false;
45480    }
45481    const stack = [];
45482    const exposedHelpers = Object.assign(predicates, {
45483      defaultVisitor,
45484      convertValue,
45485      isVisitable
45486    });
45487    function build(value, path, depth = 0) {
45488      if (utils$5.isUndefined(value)) return;
45489      if (depth > maxDepth) {
45490        throw new AxiosError$1(
45491          "Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth,
45492          AxiosError$1.ERR_FORM_DATA_DEPTH_EXCEEDED
45493        );
45494      }
45495      if (stack.indexOf(value) !== -1) {
45496        throw Error("Circular reference detected in " + path.join("."));
45497      }
45498      stack.push(value);
45499      utils$5.forEach(value, function each(el, key2) {
45500        const result = !(utils$5.isUndefined(el) || el === null) && visitor.call(formData, el, utils$5.isString(key2) ? key2.trim() : key2, path, exposedHelpers);
45501        if (result === true) {
45502          build(el, path ? path.concat(key2) : [key2], depth + 1);
45503        }
45504      });
45505      stack.pop();
45506    }
45507    if (!utils$5.isObject(obj)) {
45508      throw new TypeError("data must be an object");
45509    }
45510    build(obj);
45511    return formData;
45512  }
45513  function encode$1(str) {
45514    const charMap = {
45515      "!": "%21",
45516      "'": "%27",
45517      "(": "%28",
45518      ")": "%29",
45519      "~": "%7E",
45520      "%20": "+"
45521    };
45522    return encodeURIComponent(str).replace(/[!'()~]|%20/g, function replacer(match) {
45523      return charMap[match];
45524    });
45525  }
45526  function AxiosURLSearchParams(params, options) {
45527    this._pairs = [];
45528    params && toFormData$1(params, this, options);
45529  }
45530  const prototype = AxiosURLSearchParams.prototype;
45531  prototype.append = function append(name, value) {
45532    this._pairs.push([name, value]);
45533  };
45534  prototype.toString = function toString2(encoder) {
45535    const _encode = encoder ? function(value) {
45536      return encoder.call(this, value, encode$1);
45537    } : encode$1;
45538    return this._pairs.map(function each(pair) {
45539      return _encode(pair[0]) + "=" + _encode(pair[1]);
45540    }, "").join("&");
45541  };
45542  function encode(val) {
45543    return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
45544  }
45545  function buildURL(url2, params, options) {
45546    if (!params) {
45547      return url2;
45548    }
45549    const _encode = options && options.encode || encode;
45550    const _options = utils$5.isFunction(options) ? {
45551      serialize: options
45552    } : options;
45553    const serializeFn = _options && _options.serialize;
45554    let serializedParams;
45555    if (serializeFn) {
45556      serializedParams = serializeFn(params, _options);
45557    } else {
45558      serializedParams = utils$5.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, _options).toString(_encode);
45559    }
45560    if (serializedParams) {
45561      const hashmarkIndex = url2.indexOf("#");
45562      if (hashmarkIndex !== -1) {
45563        url2 = url2.slice(0, hashmarkIndex);
45564      }
45565      url2 += (url2.indexOf("?") === -1 ? "?" : "&") + serializedParams;
45566    }
45567    return url2;
45568  }
45569  class InterceptorManager {
45570    constructor() {
45571      this.handlers = [];
45572    }
45573    /**
45574     * Add a new interceptor to the stack
45575     *
45576     * @param {Function} fulfilled The function to handle `then` for a `Promise`
45577     * @param {Function} rejected The function to handle `reject` for a `Promise`
45578     * @param {Object} options The options for the interceptor, synchronous and runWhen
45579     *
45580     * @return {Number} An ID used to remove interceptor later
45581     */
45582    use(fulfilled, rejected, options) {
45583      this.handlers.push({
45584        fulfilled,
45585        rejected,
45586        synchronous: options ? options.synchronous : false,
45587        runWhen: options ? options.runWhen : null
45588      });
45589      return this.handlers.length - 1;
45590    }
45591    /**
45592     * Remove an interceptor from the stack
45593     *
45594     * @param {Number} id The ID that was returned by `use`
45595     *
45596     * @returns {void}
45597     */
45598    eject(id) {
45599      if (this.handlers[id]) {
45600        this.handlers[id] = null;
45601      }
45602    }
45603    /**
45604     * Clear all interceptors from the stack
45605     *
45606     * @returns {void}
45607     */
45608    clear() {
45609      if (this.handlers) {
45610        this.handlers = [];
45611      }
45612    }
45613    /**
45614     * Iterate over all the registered interceptors
45615     *
45616     * This method is particularly useful for skipping over any
45617     * interceptors that may have become `null` calling `eject`.
45618     *
45619     * @param {Function} fn The function to call for each interceptor
45620     *
45621     * @returns {void}
45622     */

45623    forEach(fn) {
45624      utils$5.forEach(this.handlers, function forEachHandler(h) {
45625        if (h !== null) {
45626          fn(h);
45627        }
45628      });
45629    }
45630  }
45631  const transitionalDefaults = {
45632    silentJSONParsing: true,
45633    forcedJSONParsing: true,
45634    clarifyTimeoutError: false,
45635    legacyInterceptorReqResOrdering: true
45636  };
45637  var cryptoBrowserifyExports = requireCryptoBrowserify();
45638  const crypto = /* @__PURE__ */ getDefaultExportFromCjs$1(cryptoBrowserifyExports);
45639  var urlExports = requireUrl();
45640  const url = /* @__PURE__ */ getDefaultExportFromCjs$1(urlExports);
45641  const URLSearchParams = url.URLSearchParams;
45642  const ALPHA = "abcdefghijklmnopqrstuvwxyz";
45643  const DIGIT = "0123456789";
45644  const ALPHABET = {
45645    DIGIT,
45646    ALPHA,
45647    ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
45648  };
45649  const generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
45650    let str = "";
45651    const { length } = alphabet;
45652    const randomValues = new Uint32Array(size);
45653    crypto.randomFillSync(randomValues);
45654    for (let i2 = 0; i2 < size; i2++) {
45655      str += alphabet[randomValues[i2] % length];
45656    }
45657    return str;
45658  };
45659  const platform$1 = {
45660    isNode: true,
45661    classes: {
45662      URLSearchParams,
45663      FormData: FormData$1,
45664      Blob: typeof Blob !== "undefined" && Blob || null
45665    },
45666    ALPHABET,
45667    generateString,
45668    protocols: ["http", "https", "file", "data"]
45669  };
45670  const hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
45671  const _navigator = typeof navigator === "object" && navigator || void 0;
45672  const hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0);
45673  const hasStandardBrowserWebWorkerEnv = (() => {
45674    return typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef
45675    self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
45676  })();
45677  const origin = hasBrowserEnv && window.location.href || "http://localhost";
45678  const utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ __proto__: null, hasBrowserEnv, hasStandardBrowserEnv, hasStandardBrowserWebWorkerEnv, navigator: _navigator, origin }, Symbol.toStringTag, { value: "Module" }));
45679  const platform = {
45680    ...utils,
45681    ...platform$1
45682  };
45683  function toURLEncodedForm(data, options) {
45684    return toFormData$1(data, new platform.classes.URLSearchParams(), {
45685      visitor: function(value, key2, path, helpers2) {
45686        if (platform.isNode && utils$5.isBuffer(value)) {
45687          this.append(key2, value.toString("base64"));
45688          return false;
45689        }
45690        return helpers2.defaultVisitor.apply(this, arguments);
45691      },
45692      ...options
45693    });
45694  }
45695  function parsePropPath(name) {
45696    return utils$5.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
45697      return match[0] === "[]" ? "" : match[1] || match[0];
45698    });
45699  }
45700  function arrayToObject(arr) {
45701    const obj = {};
45702    const keys = Object.keys(arr);
45703    let i2;
45704    const len2 = keys.length;
45705    let key2;
45706    for (i2 = 0; i2 < len2; i2++) {
45707      key2 = keys[i2];
45708      obj[key2] = arr[key2];
45709    }
45710    return obj;
45711  }
45712  function formDataToJSON(formData) {
45713    function buildPath(path, value, target, index) {
45714      let name = path[index++];
45715      if (name === "__proto__") return true;
45716      const isNumericKey = Number.isFinite(+name);
45717      const isLast = index >= path.length;
45718      name = !name && utils$5.isArray(target) ? target.length : name;
45719      if (isLast) {
45720        if (utils$5.hasOwnProp(target, name)) {
45721          target[name] = utils$5.isArray(target[name]) ? target[name].concat(value) : [target[name], value];
45722        } else {
45723          target[name] = value;
45724        }
45725        return !isNumericKey;
45726      }
45727      if (!target[name] || !utils$5.isObject(target[name])) {
45728        target[name] = [];
45729      }
45730      const result = buildPath(path, value, target[name], index);
45731      if (result && utils$5.isArray(target[name])) {
45732        target[name] = arrayToObject(target[name]);
45733      }
45734      return !isNumericKey;
45735    }
45736    if (utils$5.isFormData(formData) && utils$5.isFunction(formData.entries)) {
45737      const obj = {};
45738      utils$5.forEachEntry(formData, (name, value) => {
45739        buildPath(parsePropPath(name), value, obj, 0);
45740      });
45741      return obj;
45742    }
45743    return null;
45744  }
45745  const own = (obj, key2) => obj != null && utils$5.hasOwnProp(obj, key2) ? obj[key2] : void 0;
45746  function stringifySafely(rawValue, parser, encoder) {
45747    if (utils$5.isString(rawValue)) {

vendor: 4,363 bytes, lines 45748-45864

45748      try {
45749        (parser || JSON.parse)(rawValue);
45750        return utils$5.trim(rawValue);
45751      } catch (e) {
45752        if (e.name !== "SyntaxError") {
45753          throw e;
45754        }
45755      }
45756    }
45757    return (encoder || JSON.stringify)(rawValue);
45758  }
45759  const defaults = {
45760    transitional: transitionalDefaults,
45761    adapter: ["xhr", "http", "fetch"],
45762    transformRequest: [
45763      function transformRequest(data, headers) {
45764        const contentType2 = headers.getContentType() || "";
45765        const hasJSONContentType = contentType2.indexOf("application/json") > -1;
45766        const isObjectPayload = utils$5.isObject(data);
45767        if (isObjectPayload && utils$5.isHTMLForm(data)) {
45768          data = new FormData(data);
45769        }
45770        const isFormData2 = utils$5.isFormData(data);
45771        if (isFormData2) {
45772          return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
45773        }
45774        if (utils$5.isArrayBuffer(data) || utils$5.isBuffer(data) || utils$5.isStream(data) || utils$5.isFile(data) || utils$5.isBlob(data) || utils$5.isReadableStream(data)) {
45775          return data;
45776        }
45777        if (utils$5.isArrayBufferView(data)) {
45778          return data.buffer;
45779        }
45780        if (utils$5.isURLSearchParams(data)) {
45781          headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
45782          return data.toString();
45783        }
45784        let isFileList2;
45785        if (isObjectPayload) {
45786          const formSerializer = own(this, "formSerializer");
45787          if (contentType2.indexOf("application/x-www-form-urlencoded") > -1) {
45788            return toURLEncodedForm(data, formSerializer).toString();
45789          }
45790          if ((isFileList2 = utils$5.isFileList(data)) || contentType2.indexOf("multipart/form-data") > -1) {
45791            const env = own(this, "env");
45792            const _FormData = env && env.FormData;
45793            return toFormData$1(
45794              isFileList2 ? { "files[]": data } : data,
45795              _FormData && new _FormData(),
45796              formSerializer
45797            );
45798          }
45799        }
45800        if (isObjectPayload || hasJSONContentType) {
45801          headers.setContentType("application/json", false);
45802          return stringifySafely(data);
45803        }
45804        return data;
45805      }
45806    ],
45807    transformResponse: [
45808      function transformResponse(data) {
45809        const transitional = own(this, "transitional") || defaults.transitional;
45810        const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
45811        const responseType = own(this, "responseType");
45812        const JSONRequested = responseType === "json";
45813        if (utils$5.isResponse(data) || utils$5.isReadableStream(data)) {
45814          return data;
45815        }
45816        if (data && utils$5.isString(data) && (forcedJSONParsing && !responseType || JSONRequested)) {
45817          const silentJSONParsing = transitional && transitional.silentJSONParsing;
45818          const strictJSONParsing = !silentJSONParsing && JSONRequested;
45819          try {
45820            return JSON.parse(data, own(this, "parseReviver"));
45821          } catch (e) {
45822            if (strictJSONParsing) {
45823              if (e.name === "SyntaxError") {
45824                throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, own(this, "response"));
45825              }
45826              throw e;
45827            }
45828          }
45829        }
45830        return data;
45831      }
45832    ],
45833    /**
45834     * A timeout in milliseconds to abort a request. If set to 0 (default) a
45835     * timeout is not created.
45836     */
45837    timeout: 0,
45838    xsrfCookieName: "XSRF-TOKEN",
45839    xsrfHeaderName: "X-XSRF-TOKEN",
45840    maxContentLength: -1,
45841    maxBodyLength: -1,
45842    env: {
45843      FormData: platform.classes.FormData,
45844      Blob: platform.classes.Blob
45845    },
45846    validateStatus: function validateStatus(status) {
45847      return status >= 200 && status < 300;
45848    },
45849    headers: {
45850      common: {
45851        Accept: "application/json, text/plain, */*",
45852        "Content-Type": void 0
45853      }
45854    }
45855  };
45856  utils$5.forEach(["delete", "get", "head", "post", "put", "patch", "query"], (method) => {
45857    defaults.headers[method] = {};
45858  });
45859  function transformData(fns, response2) {
45860    const config = this || defaults;
45861    const context = response2 || config;
45862    const headers = AxiosHeaders$1.from(context.headers);
45863    let data = context.data;
45864    utils$5.forEach(fns, function transform(fn) {

45865      data = fn.call(config, data, headers.normalize(), response2 ? response2.status : void 0);
45866    });
45867    headers.normalize();
45868    return data;
45869  }
45870  function isCancel$1(value) {
45871    return !!(value && value.__CANCEL__);
45872  }
45873  let CanceledError$1 = class CanceledError extends AxiosError$1 {
45874    /**
45875     * A `CanceledError` is an object that is thrown when an operation is canceled.
45876     *
45877     * @param {string=} message The message.
45878     * @param {Object=} config The config.
45879     * @param {Object=} request The request.
45880     *
45881     * @returns {CanceledError} The created error.
45882     */
45883    constructor(message, config, request2) {
45884      super(message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config, request2);
45885      this.name = "CanceledError";
45886      this.__CANCEL__ = true;
45887    }
45888  };
45889  function settle(resolve, reject, response2) {
45890    const validateStatus = response2.config.validateStatus;
45891    if (!response2.status || !validateStatus || validateStatus(response2.status)) {
45892      resolve(response2);
45893    } else {
45894      reject(new AxiosError$1(
45895        "Request failed with status code " + response2.status,
45896        response2.status >= 400 && response2.status < 500 ? AxiosError$1.ERR_BAD_REQUEST : AxiosError$1.ERR_BAD_RESPONSE,
45897        response2.config,
45898        response2.request,
45899        response2
45900      ));
45901    }
45902  }
45903  function isAbsoluteURL(url2) {
45904    if (typeof url2 !== "string") {
45905      return false;
45906    }
45907    return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url2);
45908  }
45909  function combineURLs(baseURL, relativeURL) {
45910    return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
45911  }
45912  function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
45913    let isRelativeUrl = !isAbsoluteURL(requestedURL);
45914    if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
45915      return combineURLs(baseURL, requestedURL);
45916    }
45917    return requestedURL;
45918  }
45919  var define_process_env_default$1 = {};
45920  var DEFAULT_PORTS$1 = {
45921    ftp: 21,
45922    gopher: 70,
45923    http: 80,
45924    https: 443,
45925    ws: 80,
45926    wss: 443
45927  };
45928  function parseUrl(urlString) {
45929    try {
45930      return new URL(urlString);
45931    } catch {
45932      return null;
45933    }
45934  }
45935  function getProxyForUrl(url2) {
45936    var parsedUrl = (typeof url2 === "string" ? parseUrl(url2) : url2) || {};
45937    var proto = parsedUrl.protocol;
45938    var hostname = parsedUrl.host;
45939    var port = parsedUrl.port;
45940    if (typeof hostname !== "string" || !hostname || typeof proto !== "string") {
45941      return "";
45942    }
45943    proto = proto.split(":", 1)[0];
45944    hostname = hostname.replace(/:\d*$/, "");
45945    port = parseInt(port) || DEFAULT_PORTS$1[proto] || 0;
45946    if (!shouldProxy(hostname, port)) {
45947      return "";
45948    }
45949    var proxy = getEnv(proto + "_proxy") || getEnv("all_proxy");
45950    if (proxy && proxy.indexOf("://") === -1) {
45951      proxy = proto + "://" + proxy;
45952    }
45953    return proxy;
45954  }
45955  function shouldProxy(hostname, port) {
45956    var NO_PROXY = getEnv("no_proxy").toLowerCase();
45957    if (!NO_PROXY) {
45958      return true;
45959    }
45960    if (NO_PROXY === "*") {
45961      return false;
45962    }
45963    return NO_PROXY.split(/[,\s]/).every(function(proxy) {
45964      if (!proxy) {
45965        return true;
45966      }
45967      var parsedProxy = proxy.match(/^(.+):(\d+)$/);
45968      var parsedProxyHostname = parsedProxy ? parsedProxy[1] : proxy;
45969      var parsedProxyPort = parsedProxy ? parseInt(parsedProxy[2]) : 0;
45970      if (parsedProxyPort && parsedProxyPort !== port) {
45971        return true;
45972      }
45973      if (!/^[.*]/.test(parsedProxyHostname)) {
45974        return hostname !== parsedProxyHostname;
45975      }
45976      if (parsedProxyHostname.charAt(0) === "*") {
45977        parsedProxyHostname = parsedProxyHostname.slice(1);
45978      }
45979      return !hostname.endsWith(parsedProxyHostname);
45980    });
45981  }
45982  function getEnv(key2) {
45983    return define_process_env_default$1[key2.toLowerCase()] || define_process_env_default$1[key2.toUpperCase()] || "";
45984  }
45985  var streamHttpExports = requireStreamHttp();
45986  const http = /* @__PURE__ */ getDefaultExportFromCjs$1(streamHttpExports);
45987  var httpsBrowserifyExports = requireHttpsBrowserify();
45988  const https = /* @__PURE__ */ getDefaultExportFromCjs$1(httpsBrowserifyExports);
45989  var emptyExports = requireEmpty();
45990  const http2 = /* @__PURE__ */ getDefaultExportFromCjs$1(emptyExports);
45991  var utilExports = requireUtil$1();
45992  const util = /* @__PURE__ */ getDefaultExportFromCjs$1(utilExports);
45993  var pathBrowserifyExports = requirePathBrowserify();
45994  var followRedirects$1 = { exports: {} };
45995  var assert = { exports: {} };
45996  var errors = {};
45997  var hasRequiredErrors;
45998  function requireErrors() {
45999    if (hasRequiredErrors) return errors;
46000    hasRequiredErrors = 1;
46001    function _typeof(o) {
46002      "@babel/helpers - typeof";
46003      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
46004        return typeof o2;
46005      } : function(o2) {
46006        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
46007      }, _typeof(o);
46008    }
46009    function _createClass(Constructor, protoProps, staticProps) {
46010      Object.defineProperty(Constructor, "prototype", { writable: false });
46011      return Constructor;
46012    }
46013    function _classCallCheck(instance, Constructor) {
46014      if (!(instance instanceof Constructor)) {
46015        throw new TypeError("Cannot call a class as a function");
46016      }
46017    }
46018    function _inherits(subClass, superClass) {
46019      if (typeof superClass !== "function" && superClass !== null) {
46020        throw new TypeError("Super expression must either be null or a function");
46021      }
46022      subClass.prototype = Object.create(superClass && superClass.prototype, { c

vendor: 10,136 bytes, lines 46022-46281

46022onstructor: { value: subClass, writable: true, configurable: true } });
46023      Object.defineProperty(subClass, "prototype", { writable: false });
46024      if (superClass) _setPrototypeOf2(subClass, superClass);
46025    }
46026    function _setPrototypeOf2(o, p) {
46027      _setPrototypeOf2 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf3(o2, p2) {
46028        o2.__proto__ = p2;
46029        return o2;
46030      };
46031      return _setPrototypeOf2(o, p);
46032    }
46033    function _createSuper(Derived) {
46034      var hasNativeReflectConstruct = _isNativeReflectConstruct();
46035      return function _createSuperInternal() {
46036        var Super = _getPrototypeOf(Derived), result;
46037        if (hasNativeReflectConstruct) {
46038          var NewTarget = _getPrototypeOf(this).constructor;
46039          result = Reflect.construct(Super, arguments, NewTarget);
46040        } else {
46041          result = Super.apply(this, arguments);
46042        }
46043        return _possibleConstructorReturn(this, result);
46044      };
46045    }
46046    function _possibleConstructorReturn(self2, call) {
46047      if (call && (_typeof(call) === "object" || typeof call === "function")) {
46048        return call;
46049      } else if (call !== void 0) {
46050        throw new TypeError("Derived constructors may only return object or undefined");
46051      }
46052      return _assertThisInitialized(self2);
46053    }
46054    function _assertThisInitialized(self2) {
46055      if (self2 === void 0) {
46056        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
46057      }
46058      return self2;
46059    }
46060    function _isNativeReflectConstruct() {
46061      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
46062      if (Reflect.construct.sham) return false;
46063      if (typeof Proxy === "function") return true;
46064      try {
46065        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
46066        }));
46067        return true;
46068      } catch (e) {
46069        return false;
46070      }
46071    }
46072    function _getPrototypeOf(o) {
46073      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
46074        return o2.__proto__ || Object.getPrototypeOf(o2);
46075      };
46076      return _getPrototypeOf(o);
46077    }
46078    var codes = {};
46079    var assert2;
46080    var util2;
46081    function createErrorType(code2, message, Base) {
46082      if (!Base) {
46083        Base = Error;
46084      }
46085      function getMessage(arg1, arg2, arg3) {
46086        if (typeof message === "string") {
46087          return message;
46088        } else {
46089          return message(arg1, arg2, arg3);
46090        }
46091      }
46092      var NodeError = /* @__PURE__ */ (function(_Base) {
46093        _inherits(NodeError2, _Base);
46094        var _super = _createSuper(NodeError2);
46095        function NodeError2(arg1, arg2, arg3) {
46096          var _this;
46097          _classCallCheck(this, NodeError2);
46098          _this = _super.call(this, getMessage(arg1, arg2, arg3));
46099          _this.code = code2;
46100          return _this;
46101        }
46102        return _createClass(NodeError2);
46103      })(Base);
46104      codes[code2] = NodeError;
46105    }
46106    function oneOf(expected, thing) {
46107      if (Array.isArray(expected)) {
46108        var len2 = expected.length;
46109        expected = expected.map(function(i2) {
46110          return String(i2);
46111        });
46112        if (len2 > 2) {
46113          return "one of ".concat(thing, " ").concat(expected.slice(0, len2 - 1).join(", "), ", or ") + expected[len2 - 1];
46114        } else if (len2 === 2) {
46115          return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
46116        } else {
46117          return "of ".concat(thing, " ").concat(expected[0]);
46118        }
46119      } else {
46120        return "of ".concat(thing, " ").concat(String(expected));
46121      }
46122    }
46123    function startsWith(str, search, pos) {
46124      return str.substr(0, search.length) === search;
46125    }
46126    function endsWith2(str, search, this_len) {
46127      if (this_len === void 0 || this_len > str.length) {
46128        this_len = str.length;
46129      }
46130      return str.substring(this_len - search.length, this_len) === search;
46131    }
46132    function includes(str, search, start) {
46133      if (typeof start !== "number") {
46134        start = 0;
46135      }
46136      if (start + search.length > str.length) {
46137        return false;
46138      } else {
46139        return str.indexOf(search, start) !== -1;
46140      }
46141    }
46142    createErrorType("ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', TypeError);
46143    createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
46144      if (assert2 === void 0) assert2 = requireAssert();
46145      assert2(typeof name === "string", "'name' must be a string");
46146      var determiner;
46147      if (typeof expected === "string" && startsWith(expected, "not ")) {
46148        determiner = "must not be";
46149        expected = expected.replace(/^not /, "");
46150      } else {
46151        determiner = "must be";
46152      }
46153      var msg;
46154      if (endsWith2(name, " argument")) {
46155        msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
46156      } else {
46157        var type2 = includes(name, ".") ? "property" : "argument";
46158        msg = 'The "'.concat(name, '" ').concat(type2, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
46159      }
46160      msg += ". Received type ".concat(_typeof(actual));
46161      return msg;
46162    }, TypeError);
46163    createErrorType("ERR_INVALID_ARG_VALUE", function(name, value) {
46164      var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
46165      if (util2 === void 0) util2 = requireUtil$1();
46166      var inspected = util2.inspect(value);
46167      if (inspected.length > 128) {
46168        inspected = "".concat(inspected.slice(0, 128), "...");
46169      }
46170      return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
46171    }, TypeError);
46172    createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name, value) {
46173      var type2;
46174      if (value && value.constructor && value.constructor.name) {
46175        type2 = "instance of ".concat(value.constructor.name);
46176      } else {
46177        type2 = "type ".concat(_typeof(value));
46178      }
46179      return "Expected ".concat(input, ' to be returned from the "').concat(name, '"') + " function but got ".concat(type2, ".");
46180    }, TypeError);
46181    createErrorType("ERR_MISSING_ARGS", function() {
46182      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
46183        args[_key] = arguments[_key];
46184      }
46185      if (assert2 === void 0) assert2 = requireAssert();
46186      assert2(args.length > 0, "At least one arg needs to be specified");
46187      var msg = "The ";
46188      var len2 = args.length;
46189      args = args.map(function(a) {
46190        return '"'.concat(a, '"');
46191      });
46192      switch (len2) {
46193        case 1:
46194          msg += "".concat(args[0], " argument");
46195          break;
46196        case 2:
46197          msg += "".concat(args[0], " and ").concat(args[1], " arguments");
46198          break;
46199        default:
46200          msg += args.slice(0, len2 - 1).join(", ");
46201          msg += ", and ".concat(args[len2 - 1], " arguments");
46202          break;
46203      }
46204      return "".concat(msg, " must be specified");
46205    }, TypeError);
46206    errors.codes = codes;
46207    return errors;
46208  }
46209  var assertion_error;
46210  var hasRequiredAssertion_error;
46211  function requireAssertion_error() {
46212    if (hasRequiredAssertion_error) return assertion_error;
46213    hasRequiredAssertion_error = 1;
46214    function ownKeys(e, r) {
46215      var t = Object.keys(e);
46216      if (Object.getOwnPropertySymbols) {
46217        var o = Object.getOwnPropertySymbols(e);
46218        r && (o = o.filter(function(r2) {
46219          return Object.getOwnPropertyDescriptor(e, r2).enumerable;
46220        })), t.push.apply(t, o);
46221      }
46222      return t;
46223    }
46224    function _objectSpread(e) {
46225      for (var r = 1; r < arguments.length; r++) {
46226        var t = null != arguments[r] ? arguments[r] : {};
46227        r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
46228          _defineProperty(e, r2, t[r2]);
46229        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
46230          Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
46231        });
46232      }
46233      return e;
46234    }
46235    function _defineProperty(obj, key2, value) {
46236      key2 = _toPropertyKey(key2);
46237      if (key2 in obj) {
46238        Object.defineProperty(obj, key2, { value, enumerable: true, configurable: true, writable: true });
46239      } else {
46240        obj[key2] = value;
46241      }
46242      return obj;
46243    }
46244    function _classCallCheck(instance, Constructor) {
46245      if (!(instance instanceof Constructor)) {
46246        throw new TypeError("Cannot call a class as a function");
46247      }
46248    }
46249    function _defineProperties(target, props) {
46250      for (var i2 = 0; i2 < props.length; i2++) {
46251        var descriptor = props[i2];
46252        descriptor.enumerable = descriptor.enumerable || false;
46253        descriptor.configurable = true;
46254        if ("value" in descriptor) descriptor.writable = true;
46255        Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
46256      }
46257    }
46258    function _createClass(Constructor, protoProps, staticProps) {
46259      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
46260      Object.defineProperty(Constructor, "prototype", { writable: false });
46261      return Constructor;
46262    }
46263    function _toPropertyKey(arg) {
46264      var key2 = _toPrimitive(arg, "string");
46265      return _typeof(key2) === "symbol" ? key2 : String(key2);
46266    }
46267    function _toPrimitive(input, hint) {
46268      if (_typeof(input) !== "object" || input === null) return input;
46269      var prim = input[Symbol.toPrimitive];
46270      if (prim !== void 0) {
46271        var res = prim.call(input, hint);
46272        if (_typeof(res) !== "object") return res;
46273        throw new TypeError("@@toPrimitive must return a primitive value.");
46274      }
46275      return String(input);
46276    }
46277    function _inherits(subClass, superClass) {
46278      if (typeof superClass !== "function" && superClass !== null) {
46279        throw new TypeError("Super expression must either be null or a function");
46280      }
46281      subClass.prototype = Object.create(superClass && superClass.prototype, { c

vendor: 1,317 bytes, lines 46281-46312

46281onstructor: { value: subClass, writable: true, configurable: true } });
46282      Object.defineProperty(subClass, "prototype", { writable: false });
46283      if (superClass) _setPrototypeOf2(subClass, superClass);
46284    }
46285    function _createSuper(Derived) {
46286      var hasNativeReflectConstruct = _isNativeReflectConstruct();
46287      return function _createSuperInternal() {
46288        var Super = _getPrototypeOf(Derived), result;
46289        if (hasNativeReflectConstruct) {
46290          var NewTarget = _getPrototypeOf(this).constructor;
46291          result = Reflect.construct(Super, arguments, NewTarget);
46292        } else {
46293          result = Super.apply(this, arguments);
46294        }
46295        return _possibleConstructorReturn(this, result);
46296      };
46297    }
46298    function _possibleConstructorReturn(self2, call) {
46299      if (call && (_typeof(call) === "object" || typeof call === "function")) {
46300        return call;
46301      } else if (call !== void 0) {
46302        throw new TypeError("Derived constructors may only return object or undefined");
46303      }
46304      return _assertThisInitialized(self2);
46305    }
46306    function _assertThisInitialized(self2) {
46307      if (self2 === void 0) {
46308        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
46309      }
46310      return self2;
46311    }
46312    function _wrapNativeSuper(Class) {

vendor: 5,376 bytes, lines 46313-46442

46313      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
46314      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
46315        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
46316        if (typeof Class2 !== "function") {
46317          throw new TypeError("Super expression must either be null or a function");
46318        }
46319        if (typeof _cache !== "undefined") {
46320          if (_cache.has(Class2)) return _cache.get(Class2);
46321          _cache.set(Class2, Wrapper);
46322        }
46323        function Wrapper() {
46324          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
46325        }
46326        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
46327        return _setPrototypeOf2(Wrapper, Class2);
46328      };
46329      return _wrapNativeSuper(Class);
46330    }
46331    function _construct(Parent, args, Class) {
46332      if (_isNativeReflectConstruct()) {
46333        _construct = Reflect.construct.bind();
46334      } else {
46335        _construct = function _construct2(Parent2, args2, Class2) {
46336          var a = [null];
46337          a.push.apply(a, args2);
46338          var Constructor = Function.bind.apply(Parent2, a);
46339          var instance = new Constructor();
46340          if (Class2) _setPrototypeOf2(instance, Class2.prototype);
46341          return instance;
46342        };
46343      }
46344      return _construct.apply(null, arguments);
46345    }
46346    function _isNativeReflectConstruct() {
46347      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
46348      if (Reflect.construct.sham) return false;
46349      if (typeof Proxy === "function") return true;
46350      try {
46351        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
46352        }));
46353        return true;
46354      } catch (e) {
46355        return false;
46356      }
46357    }
46358    function _isNativeFunction(fn) {
46359      return Function.toString.call(fn).indexOf("[native code]") !== -1;
46360    }
46361    function _setPrototypeOf2(o, p) {
46362      _setPrototypeOf2 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf3(o2, p2) {
46363        o2.__proto__ = p2;
46364        return o2;
46365      };
46366      return _setPrototypeOf2(o, p);
46367    }
46368    function _getPrototypeOf(o) {
46369      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
46370        return o2.__proto__ || Object.getPrototypeOf(o2);
46371      };
46372      return _getPrototypeOf(o);
46373    }
46374    function _typeof(o) {
46375      "@babel/helpers - typeof";
46376      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
46377        return typeof o2;
46378      } : function(o2) {
46379        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
46380      }, _typeof(o);
46381    }
46382    var _require = requireUtil$1(), inspect = _require.inspect;
46383    var _require2 = requireErrors(), ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
46384    function endsWith2(str, search, this_len) {
46385      if (this_len === void 0 || this_len > str.length) {
46386        this_len = str.length;
46387      }
46388      return str.substring(this_len - search.length, this_len) === search;
46389    }
46390    function repeat(str, count) {
46391      count = Math.floor(count);
46392      if (str.length == 0 || count == 0) return "";
46393      var maxCount = str.length * count;
46394      count = Math.floor(Math.log(count) / Math.log(2));
46395      while (count) {
46396        str += str;
46397        count--;
46398      }
46399      str += str.substring(0, maxCount - str.length);
46400      return str;
46401    }
46402    var blue = "";
46403    var green = "";
46404    var red = "";
46405    var white = "";
46406    var kReadableOperator = {
46407      deepStrictEqual: "Expected values to be strictly deep-equal:",
46408      strictEqual: "Expected values to be strictly equal:",
46409      strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
46410      deepEqual: "Expected values to be loosely deep-equal:",
46411      equal: "Expected values to be loosely equal:",
46412      notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
46413      notStrictEqual: 'Expected "actual" to be strictly unequal to:',
46414      notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
46415      notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
46416      notEqual: 'Expected "actual" to be loosely unequal to:',
46417      notIdentical: "Values identical but not reference-equal:"
46418    };
46419    var kMaxShortLength = 10;
46420    function copyError(source) {
46421      var keys = Object.keys(source);
46422      var target = Object.create(Object.getPrototypeOf(source));
46423      keys.forEach(function(key2) {
46424        target[key2] = source[key2];
46425      });
46426      Object.defineProperty(target, "message", {
46427        value: source.message
46428      });
46429      return target;
46430    }
46431    function inspectValue(val) {
46432      return inspect(val, {
46433        compact: false,
46434        customInspect: false,
46435        depth: 1e3,
46436        maxArrayLength: Infinity,
46437        // Assert compares only enumerable properties (with a few exceptions).
46438        showHidden: false,
46439        // Having a long line as error is better than wrapping the line for
46440        // comparison for now.
46441        // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
46442        // have meta information about the inspected properties (i.e., know

vendor: 4,369 bytes, lines 46442-46549

46442where
46443        // in what line the property starts and ends).
46444        breakLength: Infinity,
46445        // Assert does not detect proxies currently.
46446        showProxy: false,
46447        sorted: true,
46448        // Inspect getters as we also check them when comparing entries.
46449        getters: true
46450      });
46451    }
46452    function createErrDiff(actual, expected, operator) {
46453      var other = "";
46454      var res = "";
46455      var lastPos = 0;
46456      var end = "";
46457      var skipped = false;
46458      var actualInspected = inspectValue(actual);
46459      var actualLines = actualInspected.split("\n");
46460      var expectedLines = inspectValue(expected).split("\n");
46461      var i2 = 0;
46462      var indicator = "";
46463      if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null) {
46464        operator = "strictEqualObject";
46465      }
46466      if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
46467        var inputLength = actualLines[0].length + expectedLines[0].length;
46468        if (inputLength <= kMaxShortLength) {
46469          if ((_typeof(actual) !== "object" || actual === null) && (_typeof(expected) !== "object" || expected === null) && (actual !== 0 || expected !== 0)) {
46470            return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
46471          }
46472        } else if (operator !== "strictEqualObject") {
46473          var maxLength = process$1.stderr && process$1.stderr.isTTY ? process$1.stderr.columns : 80;
46474          if (inputLength < maxLength) {
46475            while (actualLines[0][i2] === expectedLines[0][i2]) {
46476              i2++;
46477            }
46478            if (i2 > 2) {
46479              indicator = "\n  ".concat(repeat(" ", i2), "^");
46480              i2 = 0;
46481            }
46482          }
46483        }
46484      }
46485      var a = actualLines[actualLines.length - 1];
46486      var b = expectedLines[expectedLines.length - 1];
46487      while (a === b) {
46488        if (i2++ < 2) {
46489          end = "\n  ".concat(a).concat(end);
46490        } else {
46491          other = a;
46492        }
46493        actualLines.pop();
46494        expectedLines.pop();
46495        if (actualLines.length === 0 || expectedLines.length === 0) break;
46496        a = actualLines[actualLines.length - 1];
46497        b = expectedLines[expectedLines.length - 1];
46498      }
46499      var maxLines = Math.max(actualLines.length, expectedLines.length);
46500      if (maxLines === 0) {
46501        var _actualLines = actualInspected.split("\n");
46502        if (_actualLines.length > 30) {
46503          _actualLines[26] = "".concat(blue, "...").concat(white);
46504          while (_actualLines.length > 27) {
46505            _actualLines.pop();
46506          }
46507        }
46508        return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join("\n"), "\n");
46509      }
46510      if (i2 > 3) {
46511        end = "\n".concat(blue, "...").concat(white).concat(end);
46512        skipped = true;
46513      }
46514      if (other !== "") {
46515        end = "\n  ".concat(other).concat(end);
46516        other = "";
46517      }
46518      var printedLines = 0;
46519      var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
46520      var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
46521      for (i2 = 0; i2 < maxLines; i2++) {
46522        var cur = i2 - lastPos;
46523        if (actualLines.length < i2 + 1) {
46524          if (cur > 1 && i2 > 2) {
46525            if (cur > 4) {
46526              res += "\n".concat(blue, "...").concat(white);
46527              skipped = true;
46528            } else if (cur > 3) {
46529              res += "\n  ".concat(expectedLines[i2 - 2]);
46530              printedLines++;
46531            }
46532            res += "\n  ".concat(expectedLines[i2 - 1]);
46533            printedLines++;
46534          }
46535          lastPos = i2;
46536          other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i2]);
46537          printedLines++;
46538        } else if (expectedLines.length < i2 + 1) {
46539          if (cur > 1 && i2 > 2) {
46540            if (cur > 4) {
46541              res += "\n".concat(blue, "...").concat(white);
46542              skipped = true;
46543            } else if (cur > 3) {
46544              res += "\n  ".concat(actualLines[i2 - 2]);
46545              printedLines++;
46546            }
46547            res += "\n  ".concat(actualLines[i2 - 1]);
46548            printedLines++;
46549          }

vendor: 19,627 bytes, lines 46550-47094

46550          lastPos = i2;
46551          res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i2]);
46552          printedLines++;
46553        } else {
46554          var expectedLine = expectedLines[i2];
46555          var actualLine = actualLines[i2];
46556          var divergingLines = actualLine !== expectedLine && (!endsWith2(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
46557          if (divergingLines && endsWith2(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine) {
46558            divergingLines = false;
46559            actualLine += ",";
46560          }
46561          if (divergingLines) {
46562            if (cur > 1 && i2 > 2) {
46563              if (cur > 4) {
46564                res += "\n".concat(blue, "...").concat(white);
46565                skipped = true;
46566              } else if (cur > 3) {
46567                res += "\n  ".concat(actualLines[i2 - 2]);
46568                printedLines++;
46569              }
46570              res += "\n  ".concat(actualLines[i2 - 1]);
46571              printedLines++;
46572            }
46573            lastPos = i2;
46574            res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
46575            other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
46576            printedLines += 2;
46577          } else {
46578            res += other;
46579            other = "";
46580            if (cur === 1 || i2 === 0) {
46581              res += "\n  ".concat(actualLine);
46582              printedLines++;
46583            }
46584          }
46585        }
46586        if (printedLines > 20 && i2 < maxLines - 2) {
46587          return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
46588        }
46589      }
46590      return "".concat(msg).concat(skipped ? skippedMsg : "", "\n").concat(res).concat(other).concat(end).concat(indicator);
46591    }
46592    var AssertionError = /* @__PURE__ */ (function(_Error, _inspect$custom) {
46593      _inherits(AssertionError2, _Error);
46594      var _super = _createSuper(AssertionError2);
46595      function AssertionError2(options) {
46596        var _this;
46597        _classCallCheck(this, AssertionError2);
46598        if (_typeof(options) !== "object" || options === null) {
46599          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
46600        }
46601        var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
46602        var actual = options.actual, expected = options.expected;
46603        var limit = Error.stackTraceLimit;
46604        Error.stackTraceLimit = 0;
46605        if (message != null) {
46606          _this = _super.call(this, String(message));
46607        } else {
46608          if (process$1.stderr && process$1.stderr.isTTY) {
46609            if (process$1.stderr && process$1.stderr.getColorDepth && process$1.stderr.getColorDepth() !== 1) {
46610              blue = "\x1B[34m";
46611              green = "\x1B[32m";
46612              white = "\x1B[39m";
46613              red = "\x1B[31m";
46614            } else {
46615              blue = "";
46616              green = "";
46617              white = "";
46618              red = "";
46619            }
46620          }
46621          if (_typeof(actual) === "object" && actual !== null && _typeof(expected) === "object" && expected !== null && "stack" in actual && actual instanceof Error && "stack" in expected && expected instanceof Error) {
46622            actual = copyError(actual);
46623            expected = copyError(expected);
46624          }
46625          if (operator === "deepStrictEqual" || operator === "strictEqual") {
46626            _this = _super.call(this, createErrDiff(actual, expected, operator));
46627          } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
46628            var base2 = kReadableOperator[operator];
46629            var res = inspectValue(actual).split("\n");
46630            if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null) {
46631              base2 = kReadableOperator.notStrictEqualObject;
46632            }
46633            if (res.length > 30) {
46634              res[26] = "".concat(blue, "...").concat(white);
46635              while (res.length > 27) {
46636                res.pop();
46637              }
46638            }
46639            if (res.length === 1) {
46640              _this = _super.call(this, "".concat(base2, " ").concat(res[0]));
46641            } else {
46642              _this = _super.call(this, "".concat(base2, "\n\n").concat(res.join("\n"), "\n"));
46643            }
46644          } else {
46645            var _res = inspectValue(actual);
46646            var other = "";
46647            var knownOperators = kReadableOperator[operator];
46648            if (operator === "notDeepEqual" || operator === "notEqual") {
46649              _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
46650              if (_res.length > 1024) {
46651                _res = "".concat(_res.slice(0, 1021), "...");
46652              }
46653            } else {
46654              other = "".concat(inspectValue(expected));
46655              if (_res.length > 512) {
46656                _res = "".concat(_res.slice(0, 509), "...");
46657              }
46658              if (other.length > 512) {
46659                other = "".concat(other.slice(0, 509), "...");
46660              }
46661              if (operator === "deepEqual" || operator === "equal") {
46662                _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
46663              } else {
46664                other = " ".concat(operator, " ").concat(other);
46665              }
46666            }
46667            _this = _super.call(this, "".concat(_res).concat(other));
46668          }
46669        }
46670        Error.stackTraceLimit = limit;
46671        _this.generatedMessage = !message;
46672        Object.defineProperty(_assertThisInitialized(_this), "name", {
46673          value: "AssertionError [ERR_ASSERTION]",
46674          enumerable: false,
46675          writable: true,
46676          configurable: true
46677        });
46678        _this.code = "ERR_ASSERTION";
46679        _this.actual = actual;
46680        _this.expected = expected;
46681        _this.operator = operator;
46682        if (Error.captureStackTrace) {
46683          Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
46684        }
46685        _this.stack;
46686        _this.name = "AssertionError";
46687        return _possibleConstructorReturn(_this);
46688      }
46689      _createClass(AssertionError2, [{
46690        key: "toString",
46691        value: function toString2() {
46692          return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
46693        }
46694      }, {
46695        key: _inspect$custom,
46696        value: function value(recurseTimes, ctx) {
46697          return inspect(this, _objectSpread(_objectSpread({}, ctx), {}, {
46698            customInspect: false,
46699            depth: 0
46700          }));
46701        }
46702      }]);
46703      return AssertionError2;
46704    })(/* @__PURE__ */ _wrapNativeSuper(Error), inspect.custom);
46705    assertion_error = AssertionError;
46706    return assertion_error;
46707  }
46708  var isArguments;
46709  var hasRequiredIsArguments;
46710  function requireIsArguments() {
46711    if (hasRequiredIsArguments) return isArguments;
46712    hasRequiredIsArguments = 1;
46713    var toStr = Object.prototype.toString;
46714    isArguments = function isArguments2(value) {
46715      var str = toStr.call(value);
46716      var isArgs = str === "[object Arguments]";
46717      if (!isArgs) {
46718        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
46719      }
46720      return isArgs;
46721    };
46722    return isArguments;
46723  }
46724  var implementation$3;
46725  var hasRequiredImplementation$3;
46726  function requireImplementation$3() {
46727    if (hasRequiredImplementation$3) return implementation$3;
46728    hasRequiredImplementation$3 = 1;
46729    var keysShim;
46730    if (!Object.keys) {
46731      var has = Object.prototype.hasOwnProperty;
46732      var toStr = Object.prototype.toString;
46733      var isArgs = requireIsArguments();
46734      var isEnumerable = Object.prototype.propertyIsEnumerable;
46735      var hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
46736      var hasProtoEnumBug = isEnumerable.call(function() {
46737      }, "prototype");
46738      var dontEnums = [
46739        "toString",
46740        "toLocaleString",
46741        "valueOf",
46742        "hasOwnProperty",
46743        "isPrototypeOf",
46744        "propertyIsEnumerable",
46745        "constructor"
46746      ];
46747      var equalsConstructorPrototype = function(o) {
46748        var ctor = o.constructor;
46749        return ctor && ctor.prototype === o;
46750      };
46751      var excludedKeys = {
46752        $applicationCache: true,
46753        $console: true,
46754        $external: true,
46755        $frame: true,
46756        $frameElement: true,
46757        $frames: true,
46758        $innerHeight: true,
46759        $innerWidth: true,
46760        $onmozfullscreenchange: true,
46761        $onmozfullscreenerror: true,
46762        $outerHeight: true,
46763        $outerWidth: true,
46764        $pageXOffset: true,
46765        $pageYOffset: true,
46766        $parent: true,
46767        $scrollLeft: true,
46768        $scrollTop: true,
46769        $scrollX: true,
46770        $scrollY: true,
46771        $self: true,
46772        $webkitIndexedDB: true,
46773        $webkitStorageInfo: true,
46774        $window: true
46775      };
46776      var hasAutomationEqualityBug = (function() {
46777        if (typeof window === "undefined") {
46778          return false;
46779        }
46780        for (var k in window) {
46781          try {
46782            if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
46783              try {
46784                equalsConstructorPrototype(window[k]);
46785              } catch (e) {
46786                return true;
46787              }
46788            }
46789          } catch (e) {
46790            return true;
46791          }
46792        }
46793        return false;
46794      })();
46795      var equalsConstructorPrototypeIfNotBuggy = function(o) {
46796        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
46797          return equalsConstructorPrototype(o);
46798        }
46799        try {
46800          return equalsConstructorPrototype(o);
46801        } catch (e) {
46802          return false;
46803        }
46804      };
46805      keysShim = function keys(object) {
46806        var isObject2 = object !== null && typeof object === "object";
46807        var isFunction2 = toStr.call(object) === "[object Function]";
46808        var isArguments2 = isArgs(object);
46809        var isString2 = isObject2 && toStr.call(object) === "[object String]";
46810        var theKeys = [];
46811        if (!isObject2 && !isFunction2 && !isArguments2) {
46812          throw new TypeError("Object.keys called on a non-object");
46813        }
46814        var skipProto = hasProtoEnumBug && isFunction2;
46815        if (isString2 && object.length > 0 && !has.call(object, 0)) {
46816          for (var i2 = 0; i2 < object.length; ++i2) {
46817            theKeys.push(String(i2));
46818          }
46819        }
46820        if (isArguments2 && object.length > 0) {
46821          for (var j = 0; j < object.length; ++j) {
46822            theKeys.push(String(j));
46823          }
46824        } else {
46825          for (var name in object) {
46826            if (!(skipProto && name === "prototype") && has.call(object, name)) {
46827              theKeys.push(String(name));
46828            }
46829          }
46830        }
46831        if (hasDontEnumBug) {
46832          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
46833          for (var k = 0; k < dontEnums.length; ++k) {
46834            if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
46835              theKeys.push(dontEnums[k]);
46836            }
46837          }
46838        }
46839        return theKeys;
46840      };
46841    }
46842    implementation$3 = keysShim;
46843    return implementation$3;
46844  }
46845  var objectKeys;
46846  var hasRequiredObjectKeys;
46847  function requireObjectKeys() {
46848    if (hasRequiredObjectKeys) return objectKeys;
46849    hasRequiredObjectKeys = 1;
46850    var slice = Array.prototype.slice;
46851    var isArgs = requireIsArguments();
46852    var origKeys = Object.keys;
46853    var keysShim = origKeys ? function keys(o) {
46854      return origKeys(o);
46855    } : requireImplementation$3();
46856    var originalKeys = Object.keys;
46857    keysShim.shim = function shimObjectKeys() {
46858      if (Object.keys) {
46859        var keysWorksWithArguments = (function() {
46860          var args = Object.keys(arguments);
46861          return args && args.length === arguments.length;
46862        })(1, 2);
46863        if (!keysWorksWithArguments) {
46864          Object.keys = function keys(object) {
46865            if (isArgs(object)) {
46866              return originalKeys(slice.call(object));
46867            }
46868            return originalKeys(object);
46869          };
46870        }
46871      } else {
46872        Object.keys = keysShim;
46873      }
46874      return Object.keys || keysShim;
46875    };
46876    objectKeys = keysShim;
46877    return objectKeys;
46878  }
46879  var implementation$2;
46880  var hasRequiredImplementation$2;
46881  function requireImplementation$2() {
46882    if (hasRequiredImplementation$2) return implementation$2;
46883    hasRequiredImplementation$2 = 1;
46884    var objectKeys2 = requireObjectKeys();
46885    var hasSymbols2 = requireShams$1()();
46886    var callBound2 = /* @__PURE__ */ requireCallBound$1();
46887    var $Object = /* @__PURE__ */ requireEsObjectAtoms();
46888    var $push = callBound2("Array.prototype.push");
46889    var $propIsEnumerable = callBound2("Object.prototype.propertyIsEnumerable");
46890    var originalGetSymbols = hasSymbols2 ? $Object.getOwnPropertySymbols : null;
46891    implementation$2 = function assign(target, source1) {
46892      if (target == null) {
46893        throw new TypeError("target must be an object");
46894      }
46895      var to = $Object(target);
46896      if (arguments.length === 1) {
46897        return to;
46898      }
46899      for (var s = 1; s < arguments.length; ++s) {
46900        var from = $Object(arguments[s]);
46901        var keys = objectKeys2(from);
46902        var getSymbols = hasSymbols2 && ($Object.getOwnPropertySymbols || originalGetSymbols);
46903        if (getSymbols) {
46904          var syms = getSymbols(from);
46905          for (var j = 0; j < syms.length; ++j) {
46906            var key2 = syms[j];
46907            if ($propIsEnumerable(from, key2)) {
46908              $push(keys, key2);
46909            }
46910          }
46911        }
46912        for (var i2 = 0; i2 < keys.length; ++i2) {
46913          var nextKey = keys[i2];
46914          if ($propIsEnumerable(from, nextKey)) {
46915            var propValue = from[nextKey];
46916            to[nextKey] = propValue;
46917          }
46918        }
46919      }
46920      return to;
46921    };
46922    return implementation$2;
46923  }
46924  var polyfill$2;
46925  var hasRequiredPolyfill$2;
46926  function requirePolyfill$2() {
46927    if (hasRequiredPolyfill$2) return polyfill$2;
46928    hasRequiredPolyfill$2 = 1;
46929    var implementation2 = requireImplementation$2();
46930    var lacksProperEnumerationOrder = function() {
46931      if (!Object.assign) {
46932        return false;
46933      }
46934      var str = "abcdefghijklmnopqrst";
46935      var letters = str.split("");
46936      var map = {};
46937      for (var i2 = 0; i2 < letters.length; ++i2) {
46938        map[letters[i2]] = letters[i2];
46939      }
46940      var obj = Object.assign({}, map);
46941      var actual = "";
46942      for (var k in obj) {
46943        actual += k;
46944      }
46945      return str !== actual;
46946    };
46947    var assignHasPendingExceptions = function() {
46948      if (!Object.assign || !Object.preventExtensions) {
46949        return false;
46950      }
46951      var thrower = Object.preventExtensions({ 1: 2 });
46952      try {
46953        Object.assign(thrower, "xy");
46954      } catch (e) {
46955        return thrower[1] === "y";
46956      }
46957      return false;
46958    };
46959    polyfill$2 = function getPolyfill() {
46960      if (!Object.assign) {
46961        return implementation2;
46962      }
46963      if (lacksProperEnumerationOrder()) {
46964        return implementation2;
46965      }
46966      if (assignHasPendingExceptions()) {
46967        return implementation2;
46968      }
46969      return Object.assign;
46970    };
46971    return polyfill$2;
46972  }
46973  var implementation$1;
46974  var hasRequiredImplementation$1;
46975  function requireImplementation$1() {
46976    if (hasRequiredImplementation$1) return implementation$1;
46977    hasRequiredImplementation$1 = 1;
46978    var numberIsNaN = function(value) {
46979      return value !== value;
46980    };
46981    implementation$1 = function is(a, b) {
46982      if (a === 0 && b === 0) {
46983        return 1 / a === 1 / b;
46984      }
46985      if (a === b) {
46986        return true;
46987      }
46988      if (numberIsNaN(a) && numberIsNaN(b)) {
46989        return true;
46990      }
46991      return false;
46992    };
46993    return implementation$1;
46994  }
46995  var polyfill$1;
46996  var hasRequiredPolyfill$1;
46997  function requirePolyfill$1() {
46998    if (hasRequiredPolyfill$1) return polyfill$1;
46999    hasRequiredPolyfill$1 = 1;
47000    var implementation2 = requireImplementation$1();
47001    polyfill$1 = function getPolyfill() {
47002      return typeof Object.is === "function" ? Object.is : implementation2;
47003    };
47004    return polyfill$1;
47005  }
47006  var callBound;
47007  var hasRequiredCallBound;
47008  function requireCallBound() {
47009    if (hasRequiredCallBound) return callBound;
47010    hasRequiredCallBound = 1;
47011    var GetIntrinsic = /* @__PURE__ */ requireGetIntrinsic();
47012    var callBind2 = requireCallBind();
47013    var $indexOf = callBind2(GetIntrinsic("String.prototype.indexOf"));
47014    callBound = function callBoundIntrinsic(name, allowMissing) {
47015      var intrinsic = GetIntrinsic(name, !!allowMissing);
47016      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
47017        return callBind2(intrinsic);
47018      }
47019      return intrinsic;
47020    };
47021    return callBound;
47022  }
47023  var defineProperties_1;
47024  var hasRequiredDefineProperties;
47025  function requireDefineProperties() {
47026    if (hasRequiredDefineProperties) return defineProperties_1;
47027    hasRequiredDefineProperties = 1;
47028    var keys = requireObjectKeys();
47029    var hasSymbols2 = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
47030    var toStr = Object.prototype.toString;
47031    var concat = Array.prototype.concat;
47032    var defineDataProperty2 = /* @__PURE__ */ requireDefineDataProperty();
47033    var isFunction2 = function(fn) {
47034      return typeof fn === "function" && toStr.call(fn) === "[object Function]";
47035    };
47036    var supportsDescriptors = /* @__PURE__ */ requireHasPropertyDescriptors()();
47037    var defineProperty = function(object, name, value, predicate) {
47038      if (name in object) {
47039        if (predicate === true) {
47040          if (object[name] === value) {
47041            return;
47042          }
47043        } else if (!isFunction2(predicate) || !predicate()) {
47044          return;
47045        }
47046      }
47047      if (supportsDescriptors) {
47048        defineDataProperty2(object, name, value, true);
47049      } else {
47050        defineDataProperty2(object, name, value);
47051      }
47052    };
47053    var defineProperties = function(object, map) {
47054      var predicates2 = arguments.length > 2 ? arguments[2] : {};
47055      var props = keys(map);
47056      if (hasSymbols2) {
47057        props = concat.call(props, Object.getOwnPropertySymbols(map));
47058      }
47059      for (var i2 = 0; i2 < props.length; i2 += 1) {
47060        defineProperty(object, props[i2], map[props[i2]], predicates2[props[i2]]);
47061      }
47062    };
47063    defineProperties.supportsDescriptors = !!supportsDescriptors;
47064    defineProperties_1 = defineProperties;
47065    return defineProperties_1;
47066  }
47067  var shim$1;
47068  var hasRequiredShim$1;
47069  function requireShim$1() {
47070    if (hasRequiredShim$1) return shim$1;
47071    hasRequiredShim$1 = 1;
47072    var getPolyfill = requirePolyfill$1();
47073    var define = requireDefineProperties();
47074    shim$1 = function shimObjectIs() {
47075      var polyfill2 = getPolyfill();
47076      define(Object, { is: polyfill2 }, {
47077        is: function testObjectIs() {
47078          return Object.is !== polyfill2;
47079        }
47080      });
47081      return polyfill2;
47082    };
47083    return shim$1;
47084  }
47085  var objectIs;
47086  var hasRequiredObjectIs;
47087  function requireObjectIs() {
47088    if (hasRequiredObjectIs) return objectIs;
47089    hasRequiredObjectIs = 1;
47090    var define = requireDefineProperties();
47091    var callBind2 = requireCallBind();
47092    var implementation2 = requireImplementation$1();
47093    var getPolyfill = requirePolyfill$1();
47094    var shim2 = requireShim$1();

47095    var polyfill2 = callBind2(getPolyfill(), Object);
47096    define(polyfill2, {
47097      getPolyfill,
47098      implementation: implementation2,
47099      shim: shim2
47100    });
47101    objectIs = polyfill2;
47102    return objectIs;
47103  }
47104  var implementation;
47105  var hasRequiredImplementation;
47106  function requireImplementation() {
47107    if (hasRequiredImplementation) return implementation;
47108    hasRequiredImplementation = 1;
47109    implementation = function isNaN2(value) {
47110      return value !== value;
47111    };
47112    return implementation;
47113  }
47114  var polyfill;
47115  var hasRequiredPolyfill;
47116  function requirePolyfill() {
47117    if (hasRequiredPolyfill) return polyfill;
47118    hasRequiredPolyfill = 1;
47119    var implementation2 = requireImplementation();
47120    polyfill = function getPolyfill() {
47121      if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
47122        return Number.isNaN;
47123      }
47124      return implementation2;
47125    };
47126    return polyfill;
47127  }
47128  var shim;
47129  var hasRequiredShim;
47130  function requireShim() {
47131    if (hasRequiredShim) return shim;
47132    hasRequiredShim = 1;
47133    var define = requireDefineProperties();
47134    var getPolyfill = requirePolyfill();
47135    shim = function shimNumberIsNaN() {
47136      var polyfill2 = getPolyfill();
47137      define(Number, { isNaN: polyfill2 }, {
47138        isNaN: function testIsNaN() {
47139          return Number.isNaN !== polyfill2;
47140        }
47141      });
47142      return polyfill2;
47143    };
47144    return shim;
47145  }
47146  var isNan;
47147  var hasRequiredIsNan;
47148  function requireIsNan() {
47149    if (hasRequiredIsNan) return isNan;
47150    hasRequiredIsNan = 1;
47151    var callBind2 = requireCallBind();
47152    var define = requireDefineProperties();
47153    var implementation2 = requireImplementation();
47154    var getPolyfill = requirePolyfill();
47155    var shim2 = requireShim();
47156    var polyfill2 = callBind2(getPolyfill(), Number);
47157    define(polyfill2, {
47158      getPolyfill,
47159      implementation: implementation2,
47160      shim: shim2
47161    });
47162    isNan = polyfill2;
47163    return isNan;
47164  }
47165  var comparisons;
47166  var hasRequiredComparisons;
47167  function requireComparisons() {
47168    if (hasRequiredComparisons) return comparisons;
47169    hasRequiredComparisons = 1;
47170    function _slicedToArray(arr, i2) {
47171      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i2) || _unsupportedIterableToArray(arr, i2) || _nonIterableRest();
47172    }
47173    function _nonIterableRest() {
47174      throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
47175    }
47176    function _unsupportedIterableToArray(o, minLen) {
47177      if (!o) return;
47178      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
47179      var n = Object.prototype.toString.call(o).slice(8, -1);
47180      if (n === "Object" && o.constructor) n = o.constructor.name;
47181      if (n === "Map" || n === "Set") return Array.from(o);
47182      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
47183    }
47184    function _arrayLikeToArray(arr, len2) {
47185      if (len2 == null || len2 > arr.length) len2 = arr.length;
47186      for (var i2 = 0, arr2 = new Array(len2); i2 < len2; i2++) arr2[i2] = arr[i2];
47187      return arr2;
47188    }
47189    function _iterableToArrayLimit(r, l) {
47190      var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
47191      if (null != t) {
47192        var e, n, i2, u, a = [], f = true, o = false;
47193        try {
47194          if (i2 = (t = t.call(r)).next, 0 === l) ;
47195          else for (; !(f = (e = i2.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
47196        } catch (r2) {
47197          o = true, n = r2;
47198        } finally {
47199          try {
47200            if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
47201          } finally {
47202            if (o) throw n;
47203          }
47204        }
47205        return a;
47206      }
47207    }
47208    function _arrayWithHoles(arr) {
47209      if (Array.isArray(arr)) return arr;
47210    }
47211    function _typeof(o) {
47212      "@babel/helpers - typeof";
47213      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
47214        return typeof o2;
47215      } : function(o2) {
47216        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
47217      }, _typeof(o);
47218    }
47219    var regexFlagsSupported = /a/g.flags !== void 0;
47220    var arrayFromSet = function arrayFromSet2(set) {
47221      var array = [];
47222      set.forEach(function(value) {
47223        return array.push(value);
47224      });
47225      return array;
47226    };
47227    var arrayFromMap = function arrayFromMap2(map) {
47228      var array = [];

vendor: 4,597 bytes, lines 47229-47334

47229      map.forEach(function(value, key2) {
47230        return array.push([key2, value]);
47231      });
47232      return array;
47233    };
47234    var objectIs2 = Object.is ? Object.is : requireObjectIs();
47235    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
47236      return [];
47237    };
47238    var numberIsNaN = Number.isNaN ? Number.isNaN : requireIsNan();
47239    function uncurryThis(f) {
47240      return f.call.bind(f);
47241    }
47242    var hasOwnProperty2 = uncurryThis(Object.prototype.hasOwnProperty);
47243    var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
47244    var objectToString = uncurryThis(Object.prototype.toString);
47245    var _require$types = requireUtil$1().types, isAnyArrayBuffer = _require$types.isAnyArrayBuffer, isArrayBufferView2 = _require$types.isArrayBufferView, isDate2 = _require$types.isDate, isMap = _require$types.isMap, isRegExp2 = _require$types.isRegExp, isSet = _require$types.isSet, isNativeError = _require$types.isNativeError, isBoxedPrimitive = _require$types.isBoxedPrimitive, isNumberObject = _require$types.isNumberObject, isStringObject = _require$types.isStringObject, isBooleanObject = _require$types.isBooleanObject, isBigIntObject = _require$types.isBigIntObject, isSymbolObject = _require$types.isSymbolObject, isFloat32Array = _require$types.isFloat32Array, isFloat64Array = _require$types.isFloat64Array;
47246    function isNonIndex(key2) {
47247      if (key2.length === 0 || key2.length > 10) return true;
47248      for (var i2 = 0; i2 < key2.length; i2++) {
47249        var code2 = key2.charCodeAt(i2);
47250        if (code2 < 48 || code2 > 57) return true;
47251      }
47252      return key2.length === 10 && key2 >= Math.pow(2, 32);
47253    }
47254    function getOwnNonIndexProperties(value) {
47255      return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
47256    }
47257    /*!
47258     * The buffer module from node.js, for the browser.
47259     *
47260     * @author   Feross Aboukhadijeh <[email protected]> <http://feross.org>
47261     * @license  MIT
47262     */
47263    function compare(a, b) {
47264      if (a === b) {
47265        return 0;
47266      }
47267      var x = a.length;
47268      var y = b.length;
47269      for (var i2 = 0, len2 = Math.min(x, y); i2 < len2; ++i2) {
47270        if (a[i2] !== b[i2]) {
47271          x = a[i2];
47272          y = b[i2];
47273          break;
47274        }
47275      }
47276      if (x < y) {
47277        return -1;
47278      }
47279      if (y < x) {
47280        return 1;
47281      }
47282      return 0;
47283    }
47284    var kStrict = true;
47285    var kLoose = false;
47286    var kNoIterator = 0;
47287    var kIsArray = 1;
47288    var kIsSet = 2;
47289    var kIsMap = 3;
47290    function areSimilarRegExps(a, b) {
47291      return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);
47292    }
47293    function areSimilarFloatArrays(a, b) {
47294      if (a.byteLength !== b.byteLength) {
47295        return false;
47296      }
47297      for (var offset = 0; offset < a.byteLength; offset++) {
47298        if (a[offset] !== b[offset]) {
47299          return false;
47300        }
47301      }
47302      return true;
47303    }
47304    function areSimilarTypedArrays(a, b) {
47305      if (a.byteLength !== b.byteLength) {
47306        return false;
47307      }
47308      return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
47309    }
47310    function areEqualArrayBuffers(buf1, buf2) {
47311      return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
47312    }
47313    function isEqualBoxedPrimitive(val1, val2) {
47314      if (isNumberObject(val1)) {
47315        return isNumberObject(val2) && objectIs2(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
47316      }
47317      if (isStringObject(val1)) {
47318        return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
47319      }
47320      if (isBooleanObject(val1)) {
47321        return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
47322      }
47323      if (isBigIntObject(val1)) {
47324        return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
47325      }
47326      return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
47327    }
47328    function innerDeepEqual(val1, val2, strict, memos) {
47329      if (val1 === val2) {
47330        if (val1 !== 0) return true;
47331        return strict ? objectIs2(val1, val2) : true;
47332      }
47333      if (strict) {
47334        if (_typeof(val1) !== "object") {

vendor: 4,125 bytes, lines 47335-47452

47335          return typeof val1 === "number" && numberIsNaN(val1) && numberIsNaN(val2);
47336        }
47337        if (_typeof(val2) !== "object" || val1 === null || val2 === null) {
47338          return false;
47339        }
47340        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
47341          return false;
47342        }
47343      } else {
47344        if (val1 === null || _typeof(val1) !== "object") {
47345          if (val2 === null || _typeof(val2) !== "object") {
47346            return val1 == val2;
47347          }
47348          return false;
47349        }
47350        if (val2 === null || _typeof(val2) !== "object") {
47351          return false;
47352        }
47353      }
47354      var val1Tag = objectToString(val1);
47355      var val2Tag = objectToString(val2);
47356      if (val1Tag !== val2Tag) {
47357        return false;
47358      }
47359      if (Array.isArray(val1)) {
47360        if (val1.length !== val2.length) {
47361          return false;
47362        }
47363        var keys1 = getOwnNonIndexProperties(val1);
47364        var keys2 = getOwnNonIndexProperties(val2);
47365        if (keys1.length !== keys2.length) {
47366          return false;
47367        }
47368        return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
47369      }
47370      if (val1Tag === "[object Object]") {
47371        if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
47372          return false;
47373        }
47374      }
47375      if (isDate2(val1)) {
47376        if (!isDate2(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
47377          return false;
47378        }
47379      } else if (isRegExp2(val1)) {
47380        if (!isRegExp2(val2) || !areSimilarRegExps(val1, val2)) {
47381          return false;
47382        }
47383      } else if (isNativeError(val1) || val1 instanceof Error) {
47384        if (val1.message !== val2.message || val1.name !== val2.name) {
47385          return false;
47386        }
47387      } else if (isArrayBufferView2(val1)) {
47388        if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
47389          if (!areSimilarFloatArrays(val1, val2)) {
47390            return false;
47391          }
47392        } else if (!areSimilarTypedArrays(val1, val2)) {
47393          return false;
47394        }
47395        var _keys = getOwnNonIndexProperties(val1);
47396        var _keys2 = getOwnNonIndexProperties(val2);
47397        if (_keys.length !== _keys2.length) {
47398          return false;
47399        }
47400        return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
47401      } else if (isSet(val1)) {
47402        if (!isSet(val2) || val1.size !== val2.size) {
47403          return false;
47404        }
47405        return keyCheck(val1, val2, strict, memos, kIsSet);
47406      } else if (isMap(val1)) {
47407        if (!isMap(val2) || val1.size !== val2.size) {
47408          return false;
47409        }
47410        return keyCheck(val1, val2, strict, memos, kIsMap);
47411      } else if (isAnyArrayBuffer(val1)) {
47412        if (!areEqualArrayBuffers(val1, val2)) {
47413          return false;
47414        }
47415      } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
47416        return false;
47417      }
47418      return keyCheck(val1, val2, strict, memos, kNoIterator);
47419    }
47420    function getEnumerables(val, keys) {
47421      return keys.filter(function(k) {
47422        return propertyIsEnumerable(val, k);
47423      });
47424    }
47425    function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
47426      if (arguments.length === 5) {
47427        aKeys = Object.keys(val1);
47428        var bKeys = Object.keys(val2);
47429        if (aKeys.length !== bKeys.length) {
47430          return false;
47431        }
47432      }
47433      var i2 = 0;
47434      for (; i2 < aKeys.length; i2++) {
47435        if (!hasOwnProperty2(val2, aKeys[i2])) {
47436          return false;
47437        }
47438      }
47439      if (strict && arguments.length === 5) {
47440        var symbolKeysA = objectGetOwnPropertySymbols(val1);
47441        if (symbolKeysA.length !== 0) {
47442          var count = 0;
47443          for (i2 = 0; i2 < symbolKeysA.length; i2++) {
47444            var key2 = symbolKeysA[i2];
47445            if (propertyIsEnumerable(val1, key2)) {
47446              if (!propertyIsEnumerable(val2, key2)) {
47447                return false;
47448              }
47449              aKeys.push(key2);
47450              count++;
47451            } else if (propertyIsEnumerable(val2, key2)) {
47452              return false;

vendor: 22,866 bytes, lines 47453-48093

47453            }
47454          }
47455          var symbolKeysB = objectGetOwnPropertySymbols(val2);
47456          if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
47457            return false;
47458          }
47459        } else {
47460          var _symbolKeysB = objectGetOwnPropertySymbols(val2);
47461          if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
47462            return false;
47463          }
47464        }
47465      }
47466      if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
47467        return true;
47468      }
47469      if (memos === void 0) {
47470        memos = {
47471          val1: /* @__PURE__ */ new Map(),
47472          val2: /* @__PURE__ */ new Map(),
47473          position: 0
47474        };
47475      } else {
47476        var val2MemoA = memos.val1.get(val1);
47477        if (val2MemoA !== void 0) {
47478          var val2MemoB = memos.val2.get(val2);
47479          if (val2MemoB !== void 0) {
47480            return val2MemoA === val2MemoB;
47481          }
47482        }
47483        memos.position++;
47484      }
47485      memos.val1.set(val1, memos.position);
47486      memos.val2.set(val2, memos.position);
47487      var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
47488      memos.val1.delete(val1);
47489      memos.val2.delete(val2);
47490      return areEq;
47491    }
47492    function setHasEqualElement(set, val1, strict, memo) {
47493      var setValues = arrayFromSet(set);
47494      for (var i2 = 0; i2 < setValues.length; i2++) {
47495        var val2 = setValues[i2];
47496        if (innerDeepEqual(val1, val2, strict, memo)) {
47497          set.delete(val2);
47498          return true;
47499        }
47500      }
47501      return false;
47502    }
47503    function findLooseMatchingPrimitives(prim) {
47504      switch (_typeof(prim)) {
47505        case "undefined":
47506          return null;
47507        case "object":
47508          return void 0;
47509        case "symbol":
47510          return false;
47511        case "string":
47512          prim = +prim;
47513        // Loose equal entries exist only if the string is possible to convert to
47514        // a regular number and not NaN.
47515        // Fall through
47516        case "number":
47517          if (numberIsNaN(prim)) {
47518            return false;
47519          }
47520      }
47521      return true;
47522    }
47523    function setMightHaveLoosePrim(a, b, prim) {
47524      var altValue = findLooseMatchingPrimitives(prim);
47525      if (altValue != null) return altValue;
47526      return b.has(altValue) && !a.has(altValue);
47527    }
47528    function mapMightHaveLoosePrim(a, b, prim, item, memo) {
47529      var altValue = findLooseMatchingPrimitives(prim);
47530      if (altValue != null) {
47531        return altValue;
47532      }
47533      var curB = b.get(altValue);
47534      if (curB === void 0 && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
47535        return false;
47536      }
47537      return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
47538    }
47539    function setEquiv(a, b, strict, memo) {
47540      var set = null;
47541      var aValues = arrayFromSet(a);
47542      for (var i2 = 0; i2 < aValues.length; i2++) {
47543        var val = aValues[i2];
47544        if (_typeof(val) === "object" && val !== null) {
47545          if (set === null) {
47546            set = /* @__PURE__ */ new Set();
47547          }
47548          set.add(val);
47549        } else if (!b.has(val)) {
47550          if (strict) return false;
47551          if (!setMightHaveLoosePrim(a, b, val)) {
47552            return false;
47553          }
47554          if (set === null) {
47555            set = /* @__PURE__ */ new Set();
47556          }
47557          set.add(val);
47558        }
47559      }
47560      if (set !== null) {
47561        var bValues = arrayFromSet(b);
47562        for (var _i = 0; _i < bValues.length; _i++) {
47563          var _val = bValues[_i];
47564          if (_typeof(_val) === "object" && _val !== null) {
47565            if (!setHasEqualElement(set, _val, strict, memo)) return false;
47566          } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
47567            return false;
47568          }
47569        }
47570        return set.size === 0;
47571      }
47572      return true;
47573    }
47574    function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
47575      var setValues = arrayFromSet(set);
47576      for (var i2 = 0; i2 < setValues.length; i2++) {
47577        var key2 = setValues[i2];
47578        if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {
47579          set.delete(key2);
47580          return true;
47581        }
47582      }
47583      return false;
47584    }
47585    function mapEquiv(a, b, strict, memo) {
47586      var set = null;
47587      var aEntries = arrayFromMap(a);
47588      for (var i2 = 0; i2 < aEntries.length; i2++) {
47589        var _aEntries$i = _slicedToArray(aEntries[i2], 2), key2 = _aEntries$i[0], item1 = _aEntries$i[1];
47590        if (_typeof(key2) === "object" && key2 !== null) {
47591          if (set === null) {
47592            set = /* @__PURE__ */ new Set();
47593          }
47594          set.add(key2);
47595        } else {
47596          var item2 = b.get(key2);
47597          if (item2 === void 0 && !b.has(key2) || !innerDeepEqual(item1, item2, strict, memo)) {
47598            if (strict) return false;
47599            if (!mapMightHaveLoosePrim(a, b, key2, item1, memo)) return false;
47600            if (set === null) {
47601              set = /* @__PURE__ */ new Set();
47602            }
47603            set.add(key2);
47604          }
47605        }
47606      }
47607      if (set !== null) {
47608        var bEntries = arrayFromMap(b);
47609        for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
47610          var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), _key = _bEntries$_i[0], item = _bEntries$_i[1];
47611          if (_typeof(_key) === "object" && _key !== null) {
47612            if (!mapHasEqualEntry(set, a, _key, item, strict, memo)) return false;
47613          } else if (!strict && (!a.has(_key) || !innerDeepEqual(a.get(_key), item, false, memo)) && !mapHasEqualEntry(set, a, _key, item, false, memo)) {
47614            return false;
47615          }
47616        }
47617        return set.size === 0;
47618      }
47619      return true;
47620    }
47621    function objEquiv(a, b, strict, keys, memos, iterationType) {
47622      var i2 = 0;
47623      if (iterationType === kIsSet) {
47624        if (!setEquiv(a, b, strict, memos)) {
47625          return false;
47626        }
47627      } else if (iterationType === kIsMap) {
47628        if (!mapEquiv(a, b, strict, memos)) {
47629          return false;
47630        }
47631      } else if (iterationType === kIsArray) {
47632        for (; i2 < a.length; i2++) {
47633          if (hasOwnProperty2(a, i2)) {
47634            if (!hasOwnProperty2(b, i2) || !innerDeepEqual(a[i2], b[i2], strict, memos)) {
47635              return false;
47636            }
47637          } else if (hasOwnProperty2(b, i2)) {
47638            return false;
47639          } else {
47640            var keysA = Object.keys(a);
47641            for (; i2 < keysA.length; i2++) {
47642              var key2 = keysA[i2];
47643              if (!hasOwnProperty2(b, key2) || !innerDeepEqual(a[key2], b[key2], strict, memos)) {
47644                return false;
47645              }
47646            }
47647            if (keysA.length !== Object.keys(b).length) {
47648              return false;
47649            }
47650            return true;
47651          }
47652        }
47653      }
47654      for (i2 = 0; i2 < keys.length; i2++) {
47655        var _key2 = keys[i2];
47656        if (!innerDeepEqual(a[_key2], b[_key2], strict, memos)) {
47657          return false;
47658        }
47659      }
47660      return true;
47661    }
47662    function isDeepEqual(val1, val2) {
47663      return innerDeepEqual(val1, val2, kLoose);
47664    }
47665    function isDeepStrictEqual(val1, val2) {
47666      return innerDeepEqual(val1, val2, kStrict);
47667    }
47668    comparisons = {
47669      isDeepEqual,
47670      isDeepStrictEqual
47671    };
47672    return comparisons;
47673  }
47674  var hasRequiredAssert;
47675  function requireAssert() {
47676    if (hasRequiredAssert) return assert.exports;
47677    hasRequiredAssert = 1;
47678    function _typeof(o) {
47679      "@babel/helpers - typeof";
47680      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
47681        return typeof o2;
47682      } : function(o2) {
47683        return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
47684      }, _typeof(o);
47685    }
47686    function _createClass(Constructor, protoProps, staticProps) {
47687      Object.defineProperty(Constructor, "prototype", { writable: false });
47688      return Constructor;
47689    }
47690    function _classCallCheck(instance, Constructor) {
47691      if (!(instance instanceof Constructor)) {
47692        throw new TypeError("Cannot call a class as a function");
47693      }
47694    }
47695    var _require = requireErrors(), _require$codes = _require.codes, ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE, ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
47696    var AssertionError = requireAssertion_error();
47697    var _require2 = requireUtil$1(), inspect = _require2.inspect;
47698    var _require$types = requireUtil$1().types, isPromise = _require$types.isPromise, isRegExp2 = _require$types.isRegExp;
47699    var objectAssign = requirePolyfill$2()();
47700    var objectIs2 = requirePolyfill$1()();
47701    var RegExpPrototypeTest = requireCallBound()("RegExp.prototype.test");
47702    var isDeepEqual;
47703    var isDeepStrictEqual;
47704    function lazyLoadComparison() {
47705      var comparison = requireComparisons();
47706      isDeepEqual = comparison.isDeepEqual;
47707      isDeepStrictEqual = comparison.isDeepStrictEqual;
47708    }
47709    var warned = false;
47710    var assert$1 = assert.exports = ok;
47711    var NO_EXCEPTION_SENTINEL = {};
47712    function innerFail(obj) {
47713      if (obj.message instanceof Error) throw obj.message;
47714      throw new AssertionError(obj);
47715    }
47716    function fail(actual, expected, message, operator, stackStartFn) {
47717      var argsLen = arguments.length;
47718      var internalMessage;
47719      if (argsLen === 0) {
47720        internalMessage = "Failed";
47721      } else if (argsLen === 1) {
47722        message = actual;
47723        actual = void 0;
47724      } else {
47725        if (warned === false) {
47726          warned = true;
47727          var warn = process$1.emitWarning ? process$1.emitWarning : console.warn.bind(console);
47728          warn("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
47729        }
47730        if (argsLen === 2) operator = "!=";
47731      }
47732      if (message instanceof Error) throw message;
47733      var errArgs = {
47734        actual,
47735        expected,
47736        operator: operator === void 0 ? "fail" : operator,
47737        stackStartFn: stackStartFn || fail
47738      };
47739      if (message !== void 0) {
47740        errArgs.message = message;
47741      }
47742      var err = new AssertionError(errArgs);
47743      if (internalMessage) {
47744        err.message = internalMessage;
47745        err.generatedMessage = true;
47746      }
47747      throw err;
47748    }
47749    assert$1.fail = fail;
47750    assert$1.AssertionError = AssertionError;
47751    function innerOk(fn, argLen, value, message) {
47752      if (!value) {
47753        var generatedMessage = false;
47754        if (argLen === 0) {
47755          generatedMessage = true;
47756          message = "No value argument passed to `assert.ok()`";
47757        } else if (message instanceof Error) {
47758          throw message;
47759        }
47760        var err = new AssertionError({
47761          actual: value,
47762          expected: true,
47763          message,
47764          operator: "==",
47765          stackStartFn: fn
47766        });
47767        err.generatedMessage = generatedMessage;
47768        throw err;
47769      }
47770    }
47771    function ok() {
47772      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
47773        args[_key] = arguments[_key];
47774      }
47775      innerOk.apply(void 0, [ok, args.length].concat(args));
47776    }
47777    assert$1.ok = ok;
47778    assert$1.equal = function equal(actual, expected, message) {
47779      if (arguments.length < 2) {
47780        throw new ERR_MISSING_ARGS("actual", "expected");
47781      }
47782      if (actual != expected) {
47783        innerFail({
47784          actual,
47785          expected,
47786          message,
47787          operator: "==",
47788          stackStartFn: equal
47789        });
47790      }
47791    };
47792    assert$1.notEqual = function notEqual(actual, expected, message) {
47793      if (arguments.length < 2) {
47794        throw new ERR_MISSING_ARGS("actual", "expected");
47795      }
47796      if (actual == expected) {
47797        innerFail({
47798          actual,
47799          expected,
47800          message,
47801          operator: "!=",
47802          stackStartFn: notEqual
47803        });
47804      }
47805    };
47806    assert$1.deepEqual = function deepEqual(actual, expected, message) {
47807      if (arguments.length < 2) {
47808        throw new ERR_MISSING_ARGS("actual", "expected");
47809      }
47810      if (isDeepEqual === void 0) lazyLoadComparison();
47811      if (!isDeepEqual(actual, expected)) {
47812        innerFail({
47813          actual,
47814          expected,
47815          message,
47816          operator: "deepEqual",
47817          stackStartFn: deepEqual
47818        });
47819      }
47820    };
47821    assert$1.notDeepEqual = function notDeepEqual(actual, expected, message) {
47822      if (arguments.length < 2) {
47823        throw new ERR_MISSING_ARGS("actual", "expected");
47824      }
47825      if (isDeepEqual === void 0) lazyLoadComparison();
47826      if (isDeepEqual(actual, expected)) {
47827        innerFail({
47828          actual,
47829          expected,
47830          message,
47831          operator: "notDeepEqual",
47832          stackStartFn: notDeepEqual
47833        });
47834      }
47835    };
47836    assert$1.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
47837      if (arguments.length < 2) {
47838        throw new ERR_MISSING_ARGS("actual", "expected");
47839      }
47840      if (isDeepEqual === void 0) lazyLoadComparison();
47841      if (!isDeepStrictEqual(actual, expected)) {
47842        innerFail({
47843          actual,
47844          expected,
47845          message,
47846          operator: "deepStrictEqual",
47847          stackStartFn: deepStrictEqual
47848        });
47849      }
47850    };
47851    assert$1.notDeepStrictEqual = notDeepStrictEqual;
47852    function notDeepStrictEqual(actual, expected, message) {
47853      if (arguments.length < 2) {
47854        throw new ERR_MISSING_ARGS("actual", "expected");
47855      }
47856      if (isDeepEqual === void 0) lazyLoadComparison();
47857      if (isDeepStrictEqual(actual, expected)) {
47858        innerFail({
47859          actual,
47860          expected,
47861          message,
47862          operator: "notDeepStrictEqual",
47863          stackStartFn: notDeepStrictEqual
47864        });
47865      }
47866    }
47867    assert$1.strictEqual = function strictEqual(actual, expected, message) {
47868      if (arguments.length < 2) {
47869        throw new ERR_MISSING_ARGS("actual", "expected");
47870      }
47871      if (!objectIs2(actual, expected)) {
47872        innerFail({
47873          actual,
47874          expected,
47875          message,
47876          operator: "strictEqual",
47877          stackStartFn: strictEqual
47878        });
47879      }
47880    };
47881    assert$1.notStrictEqual = function notStrictEqual(actual, expected, message) {
47882      if (arguments.length < 2) {
47883        throw new ERR_MISSING_ARGS("actual", "expected");
47884      }
47885      if (objectIs2(actual, expected)) {
47886        innerFail({
47887          actual,
47888          expected,
47889          message,
47890          operator: "notStrictEqual",
47891          stackStartFn: notStrictEqual
47892        });
47893      }
47894    };
47895    var Comparison = /* @__PURE__ */ _createClass(function Comparison2(obj, keys, actual) {
47896      var _this = this;
47897      _classCallCheck(this, Comparison2);
47898      keys.forEach(function(key2) {
47899        if (key2 in obj) {
47900          if (actual !== void 0 && typeof actual[key2] === "string" && isRegExp2(obj[key2]) && RegExpPrototypeTest(obj[key2], actual[key2])) {
47901            _this[key2] = actual[key2];
47902          } else {
47903            _this[key2] = obj[key2];
47904          }
47905        }
47906      });
47907    });
47908    function compareExceptionKey(actual, expected, key2, message, keys, fn) {
47909      if (!(key2 in actual) || !isDeepStrictEqual(actual[key2], expected[key2])) {
47910        if (!message) {
47911          var a = new Comparison(actual, keys);
47912          var b = new Comparison(expected, keys, actual);
47913          var err = new AssertionError({
47914            actual: a,
47915            expected: b,
47916            operator: "deepStrictEqual",
47917            stackStartFn: fn
47918          });
47919          err.actual = actual;
47920          err.expected = expected;
47921          err.operator = fn.name;
47922          throw err;
47923        }
47924        innerFail({
47925          actual,
47926          expected,
47927          message,
47928          operator: fn.name,
47929          stackStartFn: fn
47930        });
47931      }
47932    }
47933    function expectedException(actual, expected, msg, fn) {
47934      if (typeof expected !== "function") {
47935        if (isRegExp2(expected)) return RegExpPrototypeTest(expected, actual);
47936        if (arguments.length === 2) {
47937          throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
47938        }
47939        if (_typeof(actual) !== "object" || actual === null) {
47940          var err = new AssertionError({
47941            actual,
47942            expected,
47943            message: msg,
47944            operator: "deepStrictEqual",
47945            stackStartFn: fn
47946          });
47947          err.operator = fn.name;
47948          throw err;
47949        }
47950        var keys = Object.keys(expected);
47951        if (expected instanceof Error) {
47952          keys.push("name", "message");
47953        } else if (keys.length === 0) {
47954          throw new ERR_INVALID_ARG_VALUE("error", expected, "may not be an empty object");
47955        }
47956        if (isDeepEqual === void 0) lazyLoadComparison();
47957        keys.forEach(function(key2) {
47958          if (typeof actual[key2] === "string" && isRegExp2(expected[key2]) && RegExpPrototypeTest(expected[key2], actual[key2])) {
47959            return;
47960          }
47961          compareExceptionKey(actual, expected, key2, msg, keys, fn);
47962        });
47963        return true;
47964      }
47965      if (expected.prototype !== void 0 && actual instanceof expected) {
47966        return true;
47967      }
47968      if (Error.isPrototypeOf(expected)) {
47969        return false;
47970      }
47971      return expected.call({}, actual) === true;
47972    }
47973    function getActual(fn) {
47974      if (typeof fn !== "function") {
47975        throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
47976      }
47977      try {
47978        fn();
47979      } catch (e) {
47980        return e;
47981      }
47982      return NO_EXCEPTION_SENTINEL;
47983    }
47984    function checkIsPromise(obj) {
47985      return isPromise(obj) || obj !== null && _typeof(obj) === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
47986    }
47987    function waitForActual(promiseFn) {
47988      return Promise.resolve().then(function() {
47989        var resultPromise;
47990        if (typeof promiseFn === "function") {
47991          resultPromise = promiseFn();
47992          if (!checkIsPromise(resultPromise)) {
47993            throw new ERR_INVALID_RETURN_VALUE("instance of Promise", "promiseFn", resultPromise);
47994          }
47995        } else if (checkIsPromise(promiseFn)) {
47996          resultPromise = promiseFn;
47997        } else {
47998          throw new ERR_INVALID_ARG_TYPE("promiseFn", ["Function", "Promise"], promiseFn);
47999        }
48000        return Promise.resolve().then(function() {
48001          return resultPromise;
48002        }).then(function() {
48003          return NO_EXCEPTION_SENTINEL;
48004        }).catch(function(e) {
48005          return e;
48006        });
48007      });
48008    }
48009    function expectsError(stackStartFn, actual, error, message) {
48010      if (typeof error === "string") {
48011        if (arguments.length === 4) {
48012          throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
48013        }
48014        if (_typeof(actual) === "object" && actual !== null) {
48015          if (actual.message === error) {
48016            throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error message "'.concat(actual.message, '" is identical to the message.'));
48017          }
48018        } else if (actual === error) {
48019          throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error "'.concat(actual, '" is identical to the message.'));
48020        }
48021        message = error;
48022        error = void 0;
48023      } else if (error != null && _typeof(error) !== "object" && typeof error !== "function") {
48024        throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
48025      }
48026      if (actual === NO_EXCEPTION_SENTINEL) {
48027        var details = "";
48028        if (error && error.name) {
48029          details += " (".concat(error.name, ")");
48030        }
48031        details += message ? ": ".concat(message) : ".";
48032        var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
48033        innerFail({
48034          actual: void 0,
48035          expected: error,
48036          operator: stackStartFn.name,
48037          message: "Missing expected ".concat(fnType).concat(details),
48038          stackStartFn
48039        });
48040      }
48041      if (error && !expectedException(actual, error, message, stackStartFn)) {
48042        throw actual;
48043      }
48044    }
48045    function expectsNoError(stackStartFn, actual, error, message) {
48046      if (actual === NO_EXCEPTION_SENTINEL) return;
48047      if (typeof error === "string") {
48048        message = error;
48049        error = void 0;
48050      }
48051      if (!error || expectedException(actual, error)) {
48052        var details = message ? ": ".concat(message) : ".";
48053        var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
48054        innerFail({
48055          actual,
48056          expected: error,
48057          operator: stackStartFn.name,
48058          message: "Got unwanted ".concat(fnType).concat(details, "\n") + 'Actual message: "'.concat(actual && actual.message, '"'),
48059          stackStartFn
48060        });
48061      }
48062      throw actual;
48063    }
48064    assert$1.throws = function throws(promiseFn) {
48065      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
48066        args[_key2 - 1] = arguments[_key2];
48067      }
48068      expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
48069    };
48070    assert$1.rejects = function rejects(promiseFn) {
48071      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
48072        args[_key3 - 1] = arguments[_key3];
48073      }
48074      return waitForActual(promiseFn).then(function(result) {
48075        return expectsError.apply(void 0, [rejects, result].concat(args));
48076      });
48077    };
48078    assert$1.doesNotThrow = function doesNotThrow(fn) {
48079      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
48080        args[_key4 - 1] = arguments[_key4];
48081      }
48082      expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
48083    };
48084    assert$1.doesNotReject = function doesNotReject(fn) {
48085      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
48086        args[_key5 - 1] = arguments[_key5];
48087      }
48088      return waitForActual(fn).then(function(result) {
48089        return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
48090      });
48091    };
48092    assert$1.ifError = function ifError(err) {
48093      if (err !== null && err !== void 0) {

48094        var message = "ifError got unwanted exception: ";
48095        if (_typeof(err) === "object" && typeof err.message === "string") {
48096          if (err.message.length === 0 && err.constructor) {
48097            message += err.constructor.name;
48098          } else {
48099            message += err.message;
48100          }
48101        } else {
48102          message += inspect(err);
48103        }
48104        var newErr = new AssertionError({
48105          actual: err,
48106          expected: null,
48107          operator: "ifError",
48108          message,
48109          stackStartFn: ifError
48110        });
48111        var origStack = err.stack;
48112        if (typeof origStack === "string") {
48113          var tmp2 = origStack.split("\n");
48114          tmp2.shift();
48115          var tmp1 = newErr.stack.split("\n");
48116          for (var i2 = 0; i2 < tmp2.length; i2++) {
48117            var pos = tmp1.indexOf(tmp2[i2]);
48118            if (pos !== -1) {
48119              tmp1 = tmp1.slice(0, pos);
48120              break;
48121            }
48122          }
48123          newErr.stack = "".concat(tmp1.join("\n"), "\n").concat(tmp2.join("\n"));
48124        }
48125        throw newErr;
48126      }
48127    };
48128    function internalMatch(string, regexp, message, fn, fnName) {
48129      if (!isRegExp2(regexp)) {
48130        throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
48131      }
48132      var match = fnName === "match";
48133      if (typeof string !== "string" || RegExpPrototypeTest(regexp, string) !== match) {
48134        if (message instanceof Error) {
48135          throw message;
48136        }
48137        var generatedMessage = !message;
48138        message = message || (typeof string !== "string" ? 'The "string" argument must be of type string. Received type ' + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n"));
48139        var err = new AssertionError({
48140          actual: string,
48141          expected: regexp,
48142          message,
48143          operator: fnName,
48144          stackStartFn: fn
48145        });
48146        err.generatedMessage = generatedMessage;
48147        throw err;
48148      }
48149    }
48150    assert$1.match = function match(string, regexp, message) {
48151      internalMatch(string, regexp, message, match, "match");
48152    };
48153    assert$1.doesNotMatch = function doesNotMatch(string, regexp, message) {
48154      internalMatch(string, regexp, message, doesNotMatch, "doesNotMatch");
48155    };
48156    function strict() {
48157      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
48158        args[_key6] = arguments[_key6];
48159      }
48160      innerOk.apply(void 0, [strict, args.length].concat(args));
48161    }
48162    assert$1.strict = objectAssign(strict, assert$1, {
48163      equal: assert$1.strictEqual,
48164      deepEqual: assert$1.deepStrictEqual,
48165      notEqual: assert$1.notStrictEqual,
48166      notDeepEqual: assert$1.notDeepStrictEqual
48167    });
48168    assert$1.strict.strict = assert$1.strict;
48169    return assert.exports;
48170  }
48171  var src = { exports: {} };
48172  var browser = { exports: {} };
48173  var ms;
48174  var hasRequiredMs;
48175  function requireMs() {
48176    if (hasRequiredMs) return ms;
48177    hasRequiredMs = 1;
48178    var s = 1e3;
48179    var m = s * 60;
48180    var h = m * 60;
48181    var d = h * 24;
48182    var w = d * 7;
48183    var y = d * 365.25;
48184    ms = function(val, options) {
48185      options = options || {};
48186      var type2 = typeof val;
48187      if (type2 === "string" && val.length > 0) {
48188        return parse2(val);
48189      } else if (type2 === "number" && isFinite(val)) {
48190        return options.long ? fmtLong(val) : fmtShort(val);
48191      }
48192      throw new Error(
48193        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
48194      );
48195    };
48196    function parse2(str) {
48197      str = String(str);
48198      if (str.length > 100) {
48199        return;
48200      }
48201      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
48202        str
48203      );
48204      if (!match) {
48205        return;
48206      }
48207      var n = parseFloat(match[1]);
48208      var type2 = (match[2] || "ms").toLowerCase();
48209      switch (type2) {
48210        case "years":
48211        case "year":
48212        case "yrs":
48213        case "yr":
48214        case "y":
48215          return n * y;
48216        case "weeks":
48217        case "week":
48218        case "w":
48219          return n * w;
48220        case "days":
48221        case "day":
48222        case "d":
48223          return n * d;
48224        case "hours":
48225        case "hour":
48226        case "hrs":
48227        case "hr":
48228        case "h":
48229          return n * h;
48230        case "minutes":
48231        case "minute":
48232        case "mins":
48233        case "min":
48234        case "m":
48235          return n * m;
48236        case "seconds":
48237        case "second":
48238        case "secs":
48239        case "sec":
48240        case "s":
48241          return n * s;
48242        case "milliseconds":
48243        case "millisecond":
48244        case "msecs":
48245        case "msec":
48246        case "ms":
48247          return n;
48248        default:
48249          return void 0;
48250      }
48251    }
48252    function fmtShort(ms2) {
48253      var msAbs = Math.abs(ms2);
48254      if (msAbs >= d) {
48255        return Math.round(ms2 / d) + "d";
48256      }
48257      if (msAbs >= h) {
48258        return Math.round(ms2 / h) + "h";
48259      }
48260      if (msAbs >= m) {
48261        return Math.round(ms2 / m) + "m";
48262      }
48263      if (msAbs >= s) {
48264        return Math.round(ms2 / s) + "s";
48265      }
48266      return ms2 + "ms";
48267    }
48268    function fmtLong(ms2) {
48269      var msAbs = Math.abs(ms2);
48270      if (msAbs >= d) {
48271        return plural(ms2, msAbs, d, "day");
48272      }
48273      if (msAbs >= h) {
48274        return plural(ms2, msAbs, h, "hour");
48275      }
48276      if (msAbs >= m) {
48277        return plural(ms2, msAbs, m, "minute");
48278      }
48279      if (msAbs >= s) {
48280        return plural(ms2, msAbs, s, "second");
48281      }
48282      return ms2 + " ms";
48283    }
48284    function plural(ms2, msAbs, n, name) {
48285      var isPlural = msAbs >= n * 1.5;
48286      return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
48287    }
48288    return ms;
48289  }
48290  var common$1;
48291  var hasRequiredCommon$1;
48292  function requireCommon$1() {
48293    if (hasRequiredCommon$1) return common$1;
48294    hasRequiredCommon$1 = 1;
48295    function setup(env) {
48296      createDebug.debug = createDebug;
48297      createDebug.default = createDebug;
48298      createDebug.coerce = coerce;
48299      createDebug.disable = disable;
48300      createDebug.enable = enable;
48301      createDebug.enabled = enabled;
48302      createDebug.humanize = requireMs();
48303      createDebug.destroy = destroy;
48304      Object.keys(env).forEach((key2) => {
48305        createDebug[key2] = env[key2];
48306      });
48307      createDebug.names = [];
48308      createDebug.skips = [];
48309      createDebug.formatters = {};
48310      function selectColor(namespace) {
48311        let hash2 = 0;
48312        for (let i2 = 0; i2 < namespace.length; i2++) {
48313          hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i2);
48314          hash2 |= 0;
48315        }
48316        return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
48317      }
48318      createDebug.selectColor = selectColor;
48319      function createDebug(namespace) {
48320        let prevTime;
48321        let enableOverride = null;
48322        let namespacesCache;
48323        let enabledCache;
48324        function debug(...args) {
48325          if (!debug.enabled) {
48326            return;
48327          }
48328          const self2 = debug;
48329          const curr = Number(/* @__PURE__ */ new Date());
48330          const ms2 = curr - (prevTime || curr);
48331          self2.diff = ms2;
48332          self2.prev = prevTime;
48333          self2.curr = curr;
48334          prevTime = curr;
48335          args[0] = createDebug.coerce(args[0]);
48336          if (typeof args[0] !== "string") {
48337            args.unshift("%O");
48338          }
48339          let index = 0;
48340          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
48341            if (match === "%%") {
48342              return "%";
48343            }
48344            index++;
48345            const formatter = createDebug.formatters[format];
48346            if (typeof formatter === "function") {
48347              const val = args[index];
48348              match = formatter.call(self2, val);
48349              args.splice(index, 1);
48350              index--;
48351            }
48352            return match;
48353          });
48354          createDebug.formatArgs.call(self2, args);
48355          const logFn = self2.log || createDebug.log;
48356          logFn.apply(self2, args);
48357        }
48358        debug.namespace = namespace;
48359        debug.useColors = createDebug.useColors();
48360        debug.color = createDebug.selectColor(namespace);
48361        debug.extend = extend2;
48362        debug.destroy = createDebug.destroy;
48363        Object.defineProperty(debug, "enabled", {
48364          enumerable: true,
48365          configurable: false,
48366          get: () => {
48367            if (enableOverride !== null) {
48368              return enableOverride;
48369            }
48370            if (namespacesCache !== createDebug.namespaces) {
48371              namespacesCache = createDebug.namespaces;
48372              enabledCache = createDebug.enabled(namespace);
48373            }
48374            return enabledCache;
48375          },
48376          set: (v) => {
48377            enableOverride = v;
48378          }
48379        });
48380        if (typeof createDebug.init === "function") {
48381          createDebug.init(debug);
48382        }
48383        return debug;
48384      }
48385      function extend2(namespace, delimiter) {
48386        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
48387        newDebug.log = this.log;
48388        return newDebug;
48389      }
48390      function enable(namespaces) {
48391        createDebug.save(namespaces);
48392        createDebug.namespaces = namespaces;
48393        createDebug.names = [];
48394        createDebug.skips = [];
48395        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(

vendor: 4,849 bytes, lines 48395-48571

48395Boolean);
48396        for (const ns of split) {
48397          if (ns[0] === "-") {
48398            createDebug.skips.push(ns.slice(1));
48399          } else {
48400            createDebug.names.push(ns);
48401          }
48402        }
48403      }
48404      function matchesTemplate(search, template) {
48405        let searchIndex = 0;
48406        let templateIndex = 0;
48407        let starIndex = -1;
48408        let matchIndex = 0;
48409        while (searchIndex < search.length) {
48410          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
48411            if (template[templateIndex] === "*") {
48412              starIndex = templateIndex;
48413              matchIndex = searchIndex;
48414              templateIndex++;
48415            } else {
48416              searchIndex++;
48417              templateIndex++;
48418            }
48419          } else if (starIndex !== -1) {
48420            templateIndex = starIndex + 1;
48421            matchIndex++;
48422            searchIndex = matchIndex;
48423          } else {
48424            return false;
48425          }
48426        }
48427        while (templateIndex < template.length && template[templateIndex] === "*") {
48428          templateIndex++;
48429        }
48430        return templateIndex === template.length;
48431      }
48432      function disable() {
48433        const namespaces = [
48434          ...createDebug.names,
48435          ...createDebug.skips.map((namespace) => "-" + namespace)
48436        ].join(",");
48437        createDebug.enable("");
48438        return namespaces;
48439      }
48440      function enabled(name) {
48441        for (const skip of createDebug.skips) {
48442          if (matchesTemplate(name, skip)) {
48443            return false;
48444          }
48445        }
48446        for (const ns of createDebug.names) {
48447          if (matchesTemplate(name, ns)) {
48448            return true;
48449          }
48450        }
48451        return false;
48452      }
48453      function coerce(val) {
48454        if (val instanceof Error) {
48455          return val.stack || val.message;
48456        }
48457        return val;
48458      }
48459      function destroy() {
48460        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
48461      }
48462      createDebug.enable(createDebug.load());
48463      return createDebug;
48464    }
48465    common$1 = setup;
48466    return common$1;
48467  }
48468  var hasRequiredBrowser;
48469  function requireBrowser() {
48470    if (hasRequiredBrowser) return browser.exports;
48471    hasRequiredBrowser = 1;
48472    (function(module, exports$12) {
48473      var define_process_env_default2 = {};
48474      exports$12.formatArgs = formatArgs;
48475      exports$12.save = save;
48476      exports$12.load = load;
48477      exports$12.useColors = useColors;
48478      exports$12.storage = localstorage();
48479      exports$12.destroy = /* @__PURE__ */ (() => {
48480        let warned = false;
48481        return () => {
48482          if (!warned) {
48483            warned = true;
48484            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
48485          }
48486        };
48487      })();
48488      exports$12.colors = [
48489        "#0000CC",
48490        "#0000FF",
48491        "#0033CC",
48492        "#0033FF",
48493        "#0066CC",
48494        "#0066FF",
48495        "#0099CC",
48496        "#0099FF",
48497        "#00CC00",
48498        "#00CC33",
48499        "#00CC66",
48500        "#00CC99",
48501        "#00CCCC",
48502        "#00CCFF",
48503        "#3300CC",
48504        "#3300FF",
48505        "#3333CC",
48506        "#3333FF",
48507        "#3366CC",
48508        "#3366FF",
48509        "#3399CC",
48510        "#3399FF",
48511        "#33CC00",
48512        "#33CC33",
48513        "#33CC66",
48514        "#33CC99",
48515        "#33CCCC",
48516        "#33CCFF",
48517        "#6600CC",
48518        "#6600FF",
48519        "#6633CC",
48520        "#6633FF",
48521        "#66CC00",
48522        "#66CC33",
48523        "#9900CC",
48524        "#9900FF",
48525        "#9933CC",
48526        "#9933FF",
48527        "#99CC00",
48528        "#99CC33",
48529        "#CC0000",
48530        "#CC0033",
48531        "#CC0066",
48532        "#CC0099",
48533        "#CC00CC",
48534        "#CC00FF",
48535        "#CC3300",
48536        "#CC3333",
48537        "#CC3366",
48538        "#CC3399",
48539        "#CC33CC",
48540        "#CC33FF",
48541        "#CC6600",
48542        "#CC6633",
48543        "#CC9900",
48544        "#CC9933",
48545        "#CCCC00",
48546        "#CCCC33",
48547        "#FF0000",
48548        "#FF0033",
48549        "#FF0066",
48550        "#FF0099",
48551        "#FF00CC",
48552        "#FF00FF",
48553        "#FF3300",
48554        "#FF3333",
48555        "#FF3366",
48556        "#FF3399",
48557        "#FF33CC",
48558        "#FF33FF",
48559        "#FF6600",
48560        "#FF6633",
48561        "#FF9900",
48562        "#FF9933",
48563        "#FFCC00",
48564        "#FFCC33"
48565      ];
48566      function useColors() {
48567        if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
48568          return true;
48569        }
48570        if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
48571          return false;

48572        }
48573        let m;
48574        return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
48575        typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
48576        // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
48577        typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
48578        typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
48579      }
48580      function formatArgs(args) {
48581        args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
48582        if (!this.useColors) {
48583          return;
48584        }
48585        const c = "color: " + this.color;
48586        args.splice(1, 0, c, "color: inherit");
48587        let index = 0;
48588        let lastC = 0;
48589        args[0].replace(/%[a-zA-Z%]/g, (match) => {
48590          if (match === "%%") {
48591            return;
48592          }
48593          index++;
48594          if (match === "%c") {
48595            lastC = index;
48596          }
48597        });
48598        args.splice(lastC, 0, c);
48599      }
48600      exports$12.log = console.debug || console.log || (() => {
48601      });
48602      function save(namespaces) {
48603        try {
48604          if (namespaces) {
48605            exports$12.storage.setItem("debug", namespaces);
48606          } else {
48607            exports$12.storage.removeItem("debug");
48608          }
48609        } catch (error) {
48610        }
48611      }
48612      function load() {
48613        let r;
48614        try {
48615          r = exports$12.storage.getItem("debug") || exports$12.storage.getItem("DEBUG");
48616        } catch (error) {
48617        }
48618        if (!r && typeof process$1 !== "undefined" && "env" in process$1) {
48619          r = define_process_env_default2.DEBUG;
48620        }
48621        return r;
48622      }
48623      function localstorage() {
48624        try {
48625          return localStorage;
48626        } catch (error) {
48627        }
48628      }
48629      module.exports = requireCommon$1()(exports$12);
48630      const { formatters } = module.exports;
48631      formatters.j = function(v) {
48632        try {
48633          return JSON.stringify(v);
48634        } catch (error) {
48635          return "[UnexpectedJSONParseError]: " + error.message;
48636        }
48637      };
48638    })(browser, browser.exports);
48639    return browser.exports;
48640  }
48641  var node = { exports: {} };
48642  var ttyBrowserify = {};
48643  var hasRequiredTtyBrowserify;
48644  function requireTtyBrowserify() {
48645    if (hasRequiredTtyBrowserify) return ttyBrowserify;
48646    hasRequiredTtyBrowserify = 1;
48647    ttyBrowserify.isatty = function() {
48648      return false;
48649    };
48650    function ReadStream() {
48651      throw new Error("tty.ReadStream is not implemented");
48652    }
48653    ttyBrowserify.ReadStream = ReadStream;
48654    function WriteStream() {
48655      throw new Error("tty.WriteStream is not implemented");
48656    }
48657    ttyBrowserify.WriteStream = WriteStream;
48658    return ttyBrowserify;
48659  }
48660  var main;
48661  var hasRequiredMain;
48662  function requireMain() {
48663    if (hasRequiredMain) return main;
48664    hasRequiredMain = 1;
48665    main = requireMain();
48666    return main;
48667  }
48668  var hasFlag;
48669  var hasRequiredHasFlag;
48670  function requireHasFlag() {
48671    if (hasRequiredHasFlag) return hasFlag;
48672    hasRequiredHasFlag = 1;
48673    hasFlag = (flag, argv = process$1.argv) => {
48674      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
48675      const position = argv.indexOf(prefix + flag);
48676      const terminatorPosition = argv.indexOf("--");
48677      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
48678    };
48679    return hasFlag;
48680  }
48681  var supportsColor_1;
48682  var hasRequiredSupportsColor;
48683  function requireSupportsColor() {
48684    if (hasRequiredSupportsColor) return supportsColor_1;
48685    hasRequiredSupportsColor = 1;
48686    const os = requireMain();
48687    const tty = requireTtyBrowserify();
48688    const hasFlag2 = requireHasFlag();
48689    const { env } = process$1;
48690    let forceColor;
48691    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
48692      forceColor = 0;
48693    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
48694      forceColor = 1;
48695    }
48696    if ("FORCE_COLOR" in env) {
48697      if (env.FORCE_COLOR === "true") {
48698        forceColor = 1;
48699      }

vendor: 5,293 bytes, lines 48699-48897

48699 else if (env.FORCE_COLOR === "false") {
48700        forceColor = 0;
48701      } else {
48702        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
48703      }
48704    }
48705    function translateLevel(level) {
48706      if (level === 0) {
48707        return false;
48708      }
48709      return {
48710        level,
48711        hasBasic: true,
48712        has256: level >= 2,
48713        has16m: level >= 3
48714      };
48715    }
48716    function supportsColor(haveStream, streamIsTTY) {
48717      if (forceColor === 0) {
48718        return 0;
48719      }
48720      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
48721        return 3;
48722      }
48723      if (hasFlag2("color=256")) {
48724        return 2;
48725      }
48726      if (haveStream && !streamIsTTY && forceColor === void 0) {
48727        return 0;
48728      }
48729      const min2 = forceColor || 0;
48730      if (env.TERM === "dumb") {
48731        return min2;
48732      }
48733      if (process$1.platform === "win32") {
48734        const osRelease = os.release().split(".");
48735        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
48736          return Number(osRelease[2]) >= 14931 ? 3 : 2;
48737        }
48738        return 1;
48739      }
48740      if ("CI" in env) {
48741        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign2) => sign2 in env) || env.CI_NAME === "codeship") {
48742          return 1;
48743        }
48744        return min2;
48745      }
48746      if ("TEAMCITY_VERSION" in env) {
48747        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
48748      }
48749      if (env.COLORTERM === "truecolor") {
48750        return 3;
48751      }
48752      if ("TERM_PROGRAM" in env) {
48753        const version2 = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
48754        switch (env.TERM_PROGRAM) {
48755          case "iTerm.app":
48756            return version2 >= 3 ? 3 : 2;
48757          case "Apple_Terminal":
48758            return 2;
48759        }
48760      }
48761      if (/-256(color)?$/i.test(env.TERM)) {
48762        return 2;
48763      }
48764      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
48765        return 1;
48766      }
48767      if ("COLORTERM" in env) {
48768        return 1;
48769      }
48770      return min2;
48771    }
48772    function getSupportLevel(stream2) {
48773      const level = supportsColor(stream2, stream2 && stream2.isTTY);
48774      return translateLevel(level);
48775    }
48776    supportsColor_1 = {
48777      supportsColor: getSupportLevel,
48778      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
48779      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
48780    };
48781    return supportsColor_1;
48782  }
48783  var hasRequiredNode;
48784  function requireNode() {
48785    if (hasRequiredNode) return node.exports;
48786    hasRequiredNode = 1;
48787    (function(module, exports$12) {
48788      var define_process_env_default2 = {};
48789      const tty = requireTtyBrowserify();
48790      const util2 = requireUtil$1();
48791      exports$12.init = init;
48792      exports$12.log = log;
48793      exports$12.formatArgs = formatArgs;
48794      exports$12.save = save;
48795      exports$12.load = load;
48796      exports$12.useColors = useColors;
48797      exports$12.destroy = util2.deprecate(
48798        () => {
48799        },
48800        "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
48801      );
48802      exports$12.colors = [6, 2, 3, 4, 5, 1];
48803      try {
48804        const supportsColor = requireSupportsColor();
48805        if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
48806          exports$12.colors = [
48807            20,
48808            21,
48809            26,
48810            27,
48811            32,
48812            33,
48813            38,
48814            39,
48815            40,
48816            41,
48817            42,
48818            43,
48819            44,
48820            45,
48821            56,
48822            57,
48823            62,
48824            63,
48825            68,
48826            69,
48827            74,
48828            75,
48829            76,
48830            77,
48831            78,
48832            79,
48833            80,
48834            81,
48835            92,
48836            93,
48837            98,
48838            99,
48839            112,
48840            113,
48841            128,
48842            129,
48843            134,
48844            135,
48845            148,
48846            149,
48847            160,
48848            161,
48849            162,
48850            163,
48851            164,
48852            165,
48853            166,
48854            167,
48855            168,
48856            169,
48857            170,
48858            171,
48859            172,
48860            173,
48861            178,
48862            179,
48863            184,
48864            185,
48865            196,
48866            197,
48867            198,
48868            199,
48869            200,
48870            201,
48871            202,
48872            203,
48873            204,
48874            205,
48875            206,
48876            207,
48877            208,
48878            209,
48879            214,
48880            215,
48881            220,
48882            221
48883          ];
48884        }
48885      } catch (error) {
48886      }
48887      exports$12.inspectOpts = Object.keys(define_process_env_default2).filter((key2) => {
48888        return /^debug_/i.test(key2);
48889      }).reduce((obj, key2) => {
48890        const prop = key2.substring(6).toLowerCase().replace(/_([a-z])/g, (_2, k) => {
48891          return k.toUpperCase();
48892        });
48893        let val = define_process_env_default2[key2];
48894        if (/^(yes|on|true|enabled)$/i.test(val)) {
48895          val = true;
48896        } else if (/^(no|off|false|disabled)$/i.test(val)) {
48897          val = false;

vendor: 18,826 bytes, lines 48898-49425

48898        } else if (val === "null") {
48899          val = null;
48900        } else {
48901          val = Number(val);
48902        }
48903        obj[prop] = val;
48904        return obj;
48905      }, {});
48906      function useColors() {
48907        return "colors" in exports$12.inspectOpts ? Boolean(exports$12.inspectOpts.colors) : tty.isatty(process$1.stderr.fd);
48908      }
48909      function formatArgs(args) {
48910        const { namespace: name, useColors: useColors2 } = this;
48911        if (useColors2) {
48912          const c = this.color;
48913          const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
48914          const prefix = `  ${colorCode};1m${name} \x1B[0m`;
48915          args[0] = prefix + args[0].split("\n").join("\n" + prefix);
48916          args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
48917        } else {
48918          args[0] = getDate() + name + " " + args[0];
48919        }
48920      }
48921      function getDate() {
48922        if (exports$12.inspectOpts.hideDate) {
48923          return "";
48924        }
48925        return (/* @__PURE__ */ new Date()).toISOString() + " ";
48926      }
48927      function log(...args) {
48928        return process$1.stderr.write(util2.formatWithOptions(exports$12.inspectOpts, ...args) + "\n");
48929      }
48930      function save(namespaces) {
48931        if (namespaces) {
48932          define_process_env_default2.DEBUG = namespaces;
48933        } else {
48934          delete define_process_env_default2.DEBUG;
48935        }
48936      }
48937      function load() {
48938        return define_process_env_default2.DEBUG;
48939      }
48940      function init(debug) {
48941        debug.inspectOpts = {};
48942        const keys = Object.keys(exports$12.inspectOpts);
48943        for (let i2 = 0; i2 < keys.length; i2++) {
48944          debug.inspectOpts[keys[i2]] = exports$12.inspectOpts[keys[i2]];
48945        }
48946      }
48947      module.exports = requireCommon$1()(exports$12);
48948      const { formatters } = module.exports;
48949      formatters.o = function(v) {
48950        this.inspectOpts.colors = this.useColors;
48951        return util2.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
48952      };
48953      formatters.O = function(v) {
48954        this.inspectOpts.colors = this.useColors;
48955        return util2.inspect(v, this.inspectOpts);
48956      };
48957    })(node, node.exports);
48958    return node.exports;
48959  }
48960  var hasRequiredSrc;
48961  function requireSrc() {
48962    if (hasRequiredSrc) return src.exports;
48963    hasRequiredSrc = 1;
48964    if (typeof process$1 === "undefined" || process$1.type === "renderer" || process$1.browser === true || process$1.__nwjs) {
48965      src.exports = requireBrowser();
48966    } else {
48967      src.exports = requireNode();
48968    }
48969    return src.exports;
48970  }
48971  var debug_1;
48972  var hasRequiredDebug;
48973  function requireDebug() {
48974    if (hasRequiredDebug) return debug_1;
48975    hasRequiredDebug = 1;
48976    var debug;
48977    debug_1 = function() {
48978      if (!debug) {
48979        try {
48980          debug = requireSrc()("follow-redirects");
48981        } catch (error) {
48982        }
48983        if (typeof debug !== "function") {
48984          debug = function() {
48985          };
48986        }
48987      }
48988      debug.apply(null, arguments);
48989    };
48990    return debug_1;
48991  }
48992  var hasRequiredFollowRedirects;
48993  function requireFollowRedirects() {
48994    if (hasRequiredFollowRedirects) return followRedirects$1.exports;
48995    hasRequiredFollowRedirects = 1;
48996    var url2 = requireUrl();
48997    var URL2 = url2.URL;
48998    var http3 = requireStreamHttp();
48999    var https2 = requireHttpsBrowserify();
49000    var Writable = requireStreamBrowserify().Writable;
49001    var assert2 = requireAssert();
49002    var debug = requireDebug();
49003    (function detectUnsupportedEnvironment() {
49004      var looksLikeNode = typeof process$1 !== "undefined";
49005      var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
49006      var looksLikeV8 = isFunction2(Error.captureStackTrace);
49007      if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
49008        console.warn("The follow-redirects package should be excluded from browser builds.");
49009      }
49010    })();
49011    var useNativeURL = false;
49012    try {
49013      assert2(new URL2(""));
49014    } catch (error) {
49015      useNativeURL = error.code === "ERR_INVALID_URL";
49016    }
49017    var sensitiveHeaders = [
49018      "Authorization",
49019      "Proxy-Authorization",
49020      "Cookie"
49021    ];
49022    var preservedUrlFields = [
49023      "auth",
49024      "host",
49025      "hostname",
49026      "href",
49027      "path",
49028      "pathname",
49029      "port",
49030      "protocol",
49031      "query",
49032      "search",
49033      "hash"
49034    ];
49035    var events2 = ["abort", "aborted", "connect", "error", "socket", "timeout"];
49036    var eventHandlers = /* @__PURE__ */ Object.create(null);
49037    events2.forEach(function(event) {
49038      eventHandlers[event] = function(arg1, arg2, arg3) {
49039        this._redirectable.emit(event, arg1, arg2, arg3);
49040      };
49041    });
49042    var InvalidUrlError = createErrorType(
49043      "ERR_INVALID_URL",
49044      "Invalid URL",
49045      TypeError
49046    );
49047    var RedirectionError = createErrorType(
49048      "ERR_FR_REDIRECTION_FAILURE",
49049      "Redirected request failed"
49050    );
49051    var TooManyRedirectsError = createErrorType(
49052      "ERR_FR_TOO_MANY_REDIRECTS",
49053      "Maximum number of redirects exceeded",
49054      RedirectionError
49055    );
49056    var MaxBodyLengthExceededError = createErrorType(
49057      "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
49058      "Request body larger than maxBodyLength limit"
49059    );
49060    var WriteAfterEndError = createErrorType(
49061      "ERR_STREAM_WRITE_AFTER_END",
49062      "write after end"
49063    );
49064    var destroy = Writable.prototype.destroy || noop2;
49065    function RedirectableRequest(options, responseCallback) {
49066      Writable.call(this);
49067      this._sanitizeOptions(options);
49068      this._options = options;
49069      this._ended = false;
49070      this._ending = false;
49071      this._redirectCount = 0;
49072      this._redirects = [];
49073      this._requestBodyLength = 0;
49074      this._requestBodyBuffers = [];
49075      if (responseCallback) {
49076        this.on("response", responseCallback);
49077      }
49078      var self2 = this;
49079      this._onNativeResponse = function(response2) {
49080        try {
49081          self2._processResponse(response2);
49082        } catch (cause) {
49083          self2.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
49084        }
49085      };
49086      this._headerFilter = new RegExp("^(?:" + sensitiveHeaders.concat(options.sensitiveHeaders).map(escapeRegex).join("|") + ")$", "i");
49087      this._performRequest();
49088    }
49089    RedirectableRequest.prototype = Object.create(Writable.prototype);
49090    RedirectableRequest.prototype.abort = function() {
49091      destroyRequest(this._currentRequest);
49092      this._currentRequest.abort();
49093      this.emit("abort");
49094    };
49095    RedirectableRequest.prototype.destroy = function(error) {
49096      destroyRequest(this._currentRequest, error);
49097      destroy.call(this, error);
49098      return this;
49099    };
49100    RedirectableRequest.prototype.write = function(data, encoding, callback) {
49101      if (this._ending) {
49102        throw new WriteAfterEndError();
49103      }
49104      if (!isString2(data) && !isBuffer2(data)) {
49105        throw new TypeError("data should be a string, Buffer or Uint8Array");
49106      }
49107      if (isFunction2(encoding)) {
49108        callback = encoding;
49109        encoding = null;
49110      }
49111      if (data.length === 0) {
49112        if (callback) {
49113          callback();
49114        }
49115        return;
49116      }
49117      if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
49118        this._requestBodyLength += data.length;
49119        this._requestBodyBuffers.push({ data, encoding });
49120        this._currentRequest.write(data, encoding, callback);
49121      } else {
49122        this.emit("error", new MaxBodyLengthExceededError());
49123        this.abort();
49124      }
49125    };
49126    RedirectableRequest.prototype.end = function(data, encoding, callback) {
49127      if (isFunction2(data)) {
49128        callback = data;
49129        data = encoding = null;
49130      } else if (isFunction2(encoding)) {
49131        callback = encoding;
49132        encoding = null;
49133      }
49134      if (!data) {
49135        this._ended = this._ending = true;
49136        this._currentRequest.end(null, null, callback);
49137      } else {
49138        var self2 = this;
49139        var currentRequest = this._currentRequest;
49140        this.write(data, encoding, function() {
49141          self2._ended = true;
49142          currentRequest.end(null, null, callback);
49143        });
49144        this._ending = true;
49145      }
49146    };
49147    RedirectableRequest.prototype.setHeader = function(name, value) {
49148      this._options.headers[name] = value;
49149      this._currentRequest.setHeader(name, value);
49150    };
49151    RedirectableRequest.prototype.removeHeader = function(name) {
49152      delete this._options.headers[name];
49153      this._currentRequest.removeHeader(name);
49154    };
49155    RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
49156      var self2 = this;
49157      function destroyOnTimeout(socket) {
49158        socket.setTimeout(msecs);
49159        socket.removeListener("timeout", socket.destroy);
49160        socket.addListener("timeout", socket.destroy);
49161      }
49162      function startTimer(socket) {
49163        if (self2._timeout) {
49164          clearTimeout(self2._timeout);
49165        }
49166        self2._timeout = setTimeout(function() {
49167          self2.emit("timeout");
49168          clearTimer();
49169        }, msecs);
49170        destroyOnTimeout(socket);
49171      }
49172      function clearTimer() {
49173        if (self2._timeout) {
49174          clearTimeout(self2._timeout);
49175          self2._timeout = null;
49176        }
49177        self2.removeListener("abort", clearTimer);
49178        self2.removeListener("error", clearTimer);
49179        self2.removeListener("response", clearTimer);
49180        self2.removeListener("close", clearTimer);
49181        if (callback) {
49182          self2.removeListener("timeout", callback);
49183        }
49184        if (!self2.socket) {
49185          self2._currentRequest.removeListener("socket", startTimer);
49186        }
49187      }
49188      if (callback) {
49189        this.on("timeout", callback);
49190      }
49191      if (this.socket) {
49192        startTimer(this.socket);
49193      } else {
49194        this._currentRequest.once("socket", startTimer);
49195      }
49196      this.on("socket", destroyOnTimeout);
49197      this.on("abort", clearTimer);
49198      this.on("error", clearTimer);
49199      this.on("response", clearTimer);
49200      this.on("close", clearTimer);
49201      return this;
49202    };
49203    [
49204      "flushHeaders",
49205      "getHeader",
49206      "setNoDelay",
49207      "setSocketKeepAlive"
49208    ].forEach(function(method) {
49209      RedirectableRequest.prototype[method] = function(a, b) {
49210        return this._currentRequest[method](a, b);
49211      };
49212    });
49213    ["aborted", "connection", "socket"].forEach(function(property) {
49214      Object.defineProperty(RedirectableRequest.prototype, property, {
49215        get: function() {
49216          return this._currentRequest[property];
49217        }
49218      });
49219    });
49220    RedirectableRequest.prototype._sanitizeOptions = function(options) {
49221      if (!options.headers) {
49222        options.headers = {};
49223      }
49224      if (!isArray2(options.sensitiveHeaders)) {
49225        options.sensitiveHeaders = [];
49226      }
49227      if (options.host) {
49228        if (!options.hostname) {
49229          options.hostname = options.host;
49230        }
49231        delete options.host;
49232      }
49233      if (!options.pathname && options.path) {
49234        var searchPos = options.path.indexOf("?");
49235        if (searchPos < 0) {
49236          options.pathname = options.path;
49237        } else {
49238          options.pathname = options.path.substring(0, searchPos);
49239          options.search = options.path.substring(searchPos);
49240        }
49241      }
49242    };
49243    RedirectableRequest.prototype._performRequest = function() {
49244      var protocol = this._options.protocol;
49245      var nativeProtocol = this._options.nativeProtocols[protocol];
49246      if (!nativeProtocol) {
49247        throw new TypeError("Unsupported protocol " + protocol);
49248      }
49249      if (this._options.agents) {
49250        var scheme = protocol.slice(0, -1);
49251        this._options.agent = this._options.agents[scheme];
49252      }
49253      var request2 = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
49254      request2._redirectable = this;
49255      for (var event of events2) {
49256        request2.on(event, eventHandlers[event]);
49257      }
49258      this._currentUrl = /^\//.test(this._options.path) ? url2.format(this._options) : (
49259        // When making a request to a proxy, [â¦]
49260        // a client MUST send the target URI in absolute-form [â¦].
49261        this._options.path
49262      );
49263      if (this._isRedirect) {
49264        var i2 = 0;
49265        var self2 = this;
49266        var buffers = this._requestBodyBuffers;
49267        (function writeNext(error) {
49268          if (request2 === self2._currentRequest) {
49269            if (error) {
49270              self2.emit("error", error);
49271            } else if (i2 < buffers.length) {
49272              var buffer2 = buffers[i2++];
49273              if (!request2.finished) {
49274                request2.write(buffer2.data, buffer2.encoding, writeNext);
49275              }
49276            } else if (self2._ended) {
49277              request2.end();
49278            }
49279          }
49280        })();
49281      }
49282    };
49283    RedirectableRequest.prototype._processResponse = function(response2) {
49284      var statusCode = response2.statusCode;
49285      if (this._options.trackRedirects) {
49286        this._redirects.push({
49287          url: this._currentUrl,
49288          headers: response2.headers,
49289          statusCode
49290        });
49291      }
49292      var location2 = response2.headers.location;
49293      if (!location2 || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
49294        response2.responseUrl = this._currentUrl;
49295        response2.redirects = this._redirects;
49296        this.emit("response", response2);
49297        this._requestBodyBuffers = [];
49298        return;
49299      }
49300      destroyRequest(this._currentRequest);
49301      response2.destroy();
49302      if (++this._redirectCount > this._options.maxRedirects) {
49303        throw new TooManyRedirectsError();
49304      }
49305      var requestHeaders;
49306      var beforeRedirect = this._options.beforeRedirect;
49307      if (beforeRedirect) {
49308        requestHeaders = Object.assign({
49309          // The Host header was set by nativeProtocol.request
49310          Host: response2.req.getHeader("host")
49311        }, this._options.headers);
49312      }
49313      var method = this._options.method;
49314      if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || // RFC7231Â§6.4.4: The 303 (See Other) status code indicates that
49315      // the server is redirecting the user agent to a different resource [â¦]
49316      // A user agent can perform a retrieval request targeting that URI
49317      // (a GET or HEAD request if using HTTP) [â¦]
49318      statusCode === 303 && !/^(?:GET|HEAD)$/.test(this._options.method)) {
49319        this._options.method = "GET";
49320        this._requestBodyBuffers = [];
49321        removeMatchingHeaders(/^content-/i, this._options.headers);
49322      }
49323      var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
49324      var currentUrlParts = parseUrl2(this._currentUrl);
49325      var currentHost = currentHostHeader || currentUrlParts.host;
49326      var currentUrl = /^\w+:/.test(location2) ? this._currentUrl : url2.format(Object.assign(currentUrlParts, { host: currentHost }));
49327      var redirectUrl = resolveUrl(location2, currentUrl);
49328      debug("redirecting to", redirectUrl.href);
49329      this._isRedirect = true;
49330      spreadUrlObject(redirectUrl, this._options);
49331      if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
49332        removeMatchingHeaders(this._headerFilter, this._options.headers);
49333      }
49334      if (isFunction2(beforeRedirect)) {
49335        var responseDetails = {
49336          headers: response2.headers,
49337          statusCode
49338        };
49339        var requestDetails = {
49340          url: currentUrl,
49341          method,
49342          headers: requestHeaders
49343        };
49344        beforeRedirect(this._options, responseDetails, requestDetails);
49345        this._sanitizeOptions(this._options);
49346      }
49347      this._performRequest();
49348    };
49349    function wrap(protocols) {
49350      var exports$12 = {
49351        maxRedirects: 21,
49352        maxBodyLength: 10 * 1024 * 1024
49353      };
49354      var nativeProtocols = {};
49355      Object.keys(protocols).forEach(function(scheme) {
49356        var protocol = scheme + ":";
49357        var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
49358        var wrappedProtocol = exports$12[scheme] = Object.create(nativeProtocol);
49359        function request2(input, options, callback) {
49360          if (isURL(input)) {
49361            input = spreadUrlObject(input);
49362          } else if (isString2(input)) {
49363            input = spreadUrlObject(parseUrl2(input));
49364          } else {
49365            callback = options;
49366            options = validateUrl(input);
49367            input = { protocol };
49368          }
49369          if (isFunction2(options)) {
49370            callback = options;
49371            options = null;
49372          }
49373          options = Object.assign({
49374            maxRedirects: exports$12.maxRedirects,
49375            maxBodyLength: exports$12.maxBodyLength
49376          }, input, options);
49377          options.nativeProtocols = nativeProtocols;
49378          if (!isString2(options.host) && !isString2(options.hostname)) {
49379            options.hostname = "::1";
49380          }
49381          assert2.equal(options.protocol, protocol, "protocol mismatch");
49382          debug("options", options);
49383          return new RedirectableRequest(options, callback);
49384        }
49385        function get2(input, options, callback) {
49386          var wrappedRequest = wrappedProtocol.request(input, options, callback);
49387          wrappedRequest.end();
49388          return wrappedRequest;
49389        }
49390        Object.defineProperties(wrappedProtocol, {
49391          request: { value: request2, configurable: true, enumerable: true, writable: true },
49392          get: { value: get2, configurable: true, enumerable: true, writable: true }
49393        });
49394      });
49395      return exports$12;
49396    }
49397    function noop2() {
49398    }
49399    function parseUrl2(input) {
49400      var parsed;
49401      if (useNativeURL) {
49402        parsed = new URL2(input);
49403      } else {
49404        parsed = validateUrl(url2.parse(input));
49405        if (!isString2(parsed.protocol)) {
49406          throw new InvalidUrlError({ input });
49407        }
49408      }
49409      return parsed;
49410    }
49411    function resolveUrl(relative, base2) {
49412      return useNativeURL ? new URL2(relative, base2) : parseUrl2(url2.resolve(base2, relative));
49413    }
49414    function validateUrl(input) {
49415      if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
49416        throw new InvalidUrlError({ input: input.href || input });
49417      }
49418      if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
49419        throw new InvalidUrlError({ input: input.href || input });
49420      }
49421      return input;
49422    }
49423    function spreadUrlObject(urlObject, target) {
49424      var spread2 = target || {};
49425      for (var key2 of preservedUrlFields) {

49426        spread2[key2] = urlObject[key2];
49427      }
49428      if (spread2.hostname.startsWith("[")) {
49429        spread2.hostname = spread2.hostname.slice(1, -1);
49430      }
49431      if (spread2.port !== "") {
49432        spread2.port = Number(spread2.port);
49433      }
49434      spread2.path = spread2.search ? spread2.pathname + spread2.search : spread2.pathname;
49435      return spread2;
49436    }
49437    function removeMatchingHeaders(regex, headers) {
49438      var lastValue;
49439      for (var header in headers) {
49440        if (regex.test(header)) {
49441          lastValue = headers[header];
49442          delete headers[header];
49443        }
49444      }
49445      return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
49446    }
49447    function createErrorType(code2, message, baseClass) {
49448      function CustomError(properties) {
49449        if (isFunction2(Error.captureStackTrace)) {
49450          Error.captureStackTrace(this, this.constructor);
49451        }
49452        Object.assign(this, properties || {});
49453        this.code = code2;
49454        this.message = this.cause ? message + ": " + this.cause.message : message;
49455      }
49456      CustomError.prototype = new (baseClass || Error)();
49457      Object.defineProperties(CustomError.prototype, {
49458        constructor: {
49459          value: CustomError,
49460          enumerable: false
49461        },
49462        name: {
49463          value: "Error [" + code2 + "]",
49464          enumerable: false
49465        }
49466      });
49467      return CustomError;
49468    }
49469    function destroyRequest(request2, error) {
49470      for (var event of events2) {
49471        request2.removeListener(event, eventHandlers[event]);
49472      }
49473      request2.on("error", noop2);
49474      request2.destroy(error);
49475    }
49476    function isSubdomain(subdomain, domain) {
49477      assert2(isString2(subdomain) && isString2(domain));
49478      var dot = subdomain.length - domain.length - 1;
49479      return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
49480    }
49481    function isArray2(value) {
49482      return value instanceof Array;
49483    }
49484    function isString2(value) {
49485      return typeof value === "string" || value instanceof String;
49486    }
49487    function isFunction2(value) {
49488      return typeof value === "function";
49489    }
49490    function isBuffer2(value) {
49491      return typeof value === "object" && "length" in value;
49492    }
49493    function isURL(value) {
49494      return URL2 && value instanceof URL2;
49495    }
49496    function escapeRegex(regex) {
49497      return regex.replace(/[\]\\/()*+?.$]/g, "\\$&");
49498    }
49499    followRedirects$1.exports = wrap({ http: http3, https: https2 });
49500    followRedirects$1.exports.wrap = wrap;
49501    return followRedirects$1.exports;
49502  }
49503  var followRedirectsExports = requireFollowRedirects();
49504  const followRedirects = /* @__PURE__ */ getDefaultExportFromCjs$1(followRedirectsExports);
49505  var common = {};
49506  var hasRequiredCommon;
49507  function requireCommon() {
49508    if (hasRequiredCommon) return common;
49509    hasRequiredCommon = 1;
49510    (function(exports$12) {
49511      var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
49512      function _has(obj, key2) {
49513        return Object.prototype.hasOwnProperty.call(obj, key2);
49514      }
49515      exports$12.assign = function(obj) {
49516        var sources = Array.prototype.slice.call(arguments, 1);
49517        while (sources.length) {
49518          var source = sources.shift();
49519          if (!source) {
49520            continue;
49521          }
49522          if (typeof source !== "object") {
49523            throw new TypeError(source + "must be non-object");
49524          }
49525          for (var p in source) {
49526            if (_has(source, p)) {
49527              obj[p] = source[p];
49528            }
49529          }
49530        }
49531        return obj;
49532      };
49533      exports$12.shrinkBuf = function(buf, size) {
49534        if (buf.length === size) {
49535          return buf;
49536        }
49537        if (buf.subarray) {
49538          return buf.subarray(0, size);
49539        }
49540        buf.length = size;
49541        return buf;
49542      };
49543      var fnTyped = {
49544        arraySet: function(dest, src2, src_offs, len2, dest_offs) {
49545          if (src2.subarray && dest.subarray) {
49546            dest.set(src2.subarray(src_offs, src_offs + len2), dest_offs);
49547            return;
49548          }
49549          for (var i2 = 0; i2 < len2; i2++) {
49550            dest[dest_offs + i2] = src2[src_offs + i2];
49551          }
49552        },
49553        // Join array of chunks to single array.
49554        flattenChunks: function(chunks) {
49555          var i2, l, len2, pos, chunk, result;
49556          len2 = 0;
49557          for (i2 = 0, l = chunks.length; i2 < l; i2++) {
49558            len2 += chunks[i2].length;
49559          }
49560          result = new Uint8Array(len2);
49561          pos = 0;
49562          for (i2 = 0, l = chunks.length; i2 < l; i2++) {
49563            chunk = chunks[i2];
49564            result.set(chunk, pos);
49565            pos += chunk.length;
49566          }
49567          return result;
49568        }
49569      };
49570      var fnUntyped = {
49571        arraySet: function(dest, src2, src_offs, len2, dest_offs) {
49572          for (var i2 = 0; i2 < len2; i2++) {
49573            dest[dest_offs + i2] = src2[src_offs + i2];
49574          }
49575        },
49576        // Join array of chunks to single array.
49577        flattenChunks: function(chunks) {
49578          return [].concat.apply([], chunks);
49579        }
49580      };
49581      exports$12.setTyped = function(on) {
49582        if (on) {
49583          exports$12.Buf8 = Uint8Array;
49584          exports$12.Buf16 = Uint16Array;
49585          exports$12.Buf32 = Int32Array;

vendor: 43,893 bytes, lines 49586-51027

49586          exports$12.assign(exports$12, fnTyped);
49587        } else {
49588          exports$12.Buf8 = Array;
49589          exports$12.Buf16 = Array;
49590          exports$12.Buf32 = Array;
49591          exports$12.assign(exports$12, fnUntyped);
49592        }
49593      };
49594      exports$12.setTyped(TYPED_OK);
49595    })(common);
49596    return common;
49597  }
49598  var deflate$1 = {};
49599  var deflate = {};
49600  var trees = {};
49601  var hasRequiredTrees;
49602  function requireTrees() {
49603    if (hasRequiredTrees) return trees;
49604    hasRequiredTrees = 1;
49605    var utils2 = requireCommon();
49606    var Z_FIXED = 4;
49607    var Z_BINARY = 0;
49608    var Z_TEXT = 1;
49609    var Z_UNKNOWN = 2;
49610    function zero(buf) {
49611      var len2 = buf.length;
49612      while (--len2 >= 0) {
49613        buf[len2] = 0;
49614      }
49615    }
49616    var STORED_BLOCK = 0;
49617    var STATIC_TREES = 1;
49618    var DYN_TREES = 2;
49619    var MIN_MATCH = 3;
49620    var MAX_MATCH = 258;
49621    var LENGTH_CODES = 29;
49622    var LITERALS = 256;
49623    var L_CODES = LITERALS + 1 + LENGTH_CODES;
49624    var D_CODES = 30;
49625    var BL_CODES = 19;
49626    var HEAP_SIZE = 2 * L_CODES + 1;
49627    var MAX_BITS = 15;
49628    var Buf_size = 16;
49629    var MAX_BL_BITS = 7;
49630    var END_BLOCK = 256;
49631    var REP_3_6 = 16;
49632    var REPZ_3_10 = 17;
49633    var REPZ_11_138 = 18;
49634    var extra_lbits = (
49635      /* extra bits for each length code */
49636      [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]
49637    );
49638    var extra_dbits = (
49639      /* extra bits for each distance code */
49640      [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]
49641    );
49642    var extra_blbits = (
49643      /* extra bits for each bit length code */
49644      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]
49645    );
49646    var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
49647    var DIST_CODE_LEN = 512;
49648    var static_ltree = new Array((L_CODES + 2) * 2);
49649    zero(static_ltree);
49650    var static_dtree = new Array(D_CODES * 2);
49651    zero(static_dtree);
49652    var _dist_code = new Array(DIST_CODE_LEN);
49653    zero(_dist_code);
49654    var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
49655    zero(_length_code);
49656    var base_length = new Array(LENGTH_CODES);
49657    zero(base_length);
49658    var base_dist = new Array(D_CODES);
49659    zero(base_dist);
49660    function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
49661      this.static_tree = static_tree;
49662      this.extra_bits = extra_bits;
49663      this.extra_base = extra_base;
49664      this.elems = elems;
49665      this.max_length = max_length;
49666      this.has_stree = static_tree && static_tree.length;
49667    }
49668    var static_l_desc;
49669    var static_d_desc;
49670    var static_bl_desc;
49671    function TreeDesc(dyn_tree, stat_desc) {
49672      this.dyn_tree = dyn_tree;
49673      this.max_code = 0;
49674      this.stat_desc = stat_desc;
49675    }
49676    function d_code(dist2) {
49677      return dist2 < 256 ? _dist_code[dist2] : _dist_code[256 + (dist2 >>> 7)];
49678    }
49679    function put_short(s, w) {
49680      s.pending_buf[s.pending++] = w & 255;
49681      s.pending_buf[s.pending++] = w >>> 8 & 255;
49682    }
49683    function send_bits(s, value, length) {
49684      if (s.bi_valid > Buf_size - length) {
49685        s.bi_buf |= value << s.bi_valid & 65535;
49686        put_short(s, s.bi_buf);
49687        s.bi_buf = value >> Buf_size - s.bi_valid;
49688        s.bi_valid += length - Buf_size;
49689      } else {
49690        s.bi_buf |= value << s.bi_valid & 65535;
49691        s.bi_valid += length;
49692      }
49693    }
49694    function send_code(s, c, tree) {
49695      send_bits(
49696        s,
49697        tree[c * 2],
49698        tree[c * 2 + 1]
49699        /*.Len*/
49700      );
49701    }
49702    function bi_reverse(code2, len2) {
49703      var res = 0;
49704      do {
49705        res |= code2 & 1;
49706        code2 >>>= 1;
49707        res <<= 1;
49708      } while (--len2 > 0);
49709      return res >>> 1;
49710    }
49711    function bi_flush(s) {
49712      if (s.bi_valid === 16) {
49713        put_short(s, s.bi_buf);
49714        s.bi_buf = 0;
49715        s.bi_valid = 0;
49716      } else if (s.bi_valid >= 8) {
49717        s.pending_buf[s.pending++] = s.bi_buf & 255;
49718        s.bi_buf >>= 8;
49719        s.bi_valid -= 8;
49720      }
49721    }
49722    function gen_bitlen(s, desc) {
49723      var tree = desc.dyn_tree;
49724      var max_code = desc.max_code;
49725      var stree = desc.stat_desc.static_tree;
49726      var has_stree = desc.stat_desc.has_stree;
49727      var extra = desc.stat_desc.extra_bits;
49728      var base2 = desc.stat_desc.extra_base;
49729      var max_length = desc.stat_desc.max_length;
49730      var h;
49731      var n, m;
49732      var bits;
49733      var xbits;
49734      var f;
49735      var overflow = 0;
49736      for (bits = 0; bits <= MAX_BITS; bits++) {
49737        s.bl_count[bits] = 0;
49738      }
49739      tree[s.heap[s.heap_max] * 2 + 1] = 0;
49740      for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
49741        n = s.heap[h];
49742        bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
49743        if (bits > max_length) {
49744          bits = max_length;
49745          overflow++;
49746        }
49747        tree[n * 2 + 1] = bits;
49748        if (n > max_code) {
49749          continue;
49750        }
49751        s.bl_count[bits]++;
49752        xbits = 0;
49753        if (n >= base2) {
49754          xbits = extra[n - base2];
49755        }
49756        f = tree[n * 2];
49757        s.opt_len += f * (bits + xbits);
49758        if (has_stree) {
49759          s.static_len += f * (stree[n * 2 + 1] + xbits);
49760        }
49761      }
49762      if (overflow === 0) {
49763        return;
49764      }
49765      do {
49766        bits = max_length - 1;
49767        while (s.bl_count[bits] === 0) {
49768          bits--;
49769        }
49770        s.bl_count[bits]--;
49771        s.bl_count[bits + 1] += 2;
49772        s.bl_count[max_length]--;
49773        overflow -= 2;
49774      } while (overflow > 0);
49775      for (bits = max_length; bits !== 0; bits--) {
49776        n = s.bl_count[bits];
49777        while (n !== 0) {
49778          m = s.heap[--h];
49779          if (m > max_code) {
49780            continue;
49781          }
49782          if (tree[m * 2 + 1] !== bits) {
49783            s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
49784            tree[m * 2 + 1] = bits;
49785          }
49786          n--;
49787        }
49788      }
49789    }
49790    function gen_codes(tree, max_code, bl_count) {
49791      var next_code = new Array(MAX_BITS + 1);
49792      var code2 = 0;
49793      var bits;
49794      var n;
49795      for (bits = 1; bits <= MAX_BITS; bits++) {
49796        next_code[bits] = code2 = code2 + bl_count[bits - 1] << 1;
49797      }
49798      for (n = 0; n <= max_code; n++) {
49799        var len2 = tree[n * 2 + 1];
49800        if (len2 === 0) {
49801          continue;
49802        }
49803        tree[n * 2] = bi_reverse(next_code[len2]++, len2);
49804      }
49805    }
49806    function tr_static_init() {
49807      var n;
49808      var bits;
49809      var length;
49810      var code2;
49811      var dist2;
49812      var bl_count = new Array(MAX_BITS + 1);
49813      length = 0;
49814      for (code2 = 0; code2 < LENGTH_CODES - 1; code2++) {
49815        base_length[code2] = length;
49816        for (n = 0; n < 1 << extra_lbits[code2]; n++) {
49817          _length_code[length++] = code2;
49818        }
49819      }
49820      _length_code[length - 1] = code2;
49821      dist2 = 0;
49822      for (code2 = 0; code2 < 16; code2++) {
49823        base_dist[code2] = dist2;
49824        for (n = 0; n < 1 << extra_dbits[code2]; n++) {
49825          _dist_code[dist2++] = code2;
49826        }
49827      }
49828      dist2 >>= 7;
49829      for (; code2 < D_CODES; code2++) {
49830        base_dist[code2] = dist2 << 7;
49831        for (n = 0; n < 1 << extra_dbits[code2] - 7; n++) {
49832          _dist_code[256 + dist2++] = code2;
49833        }
49834      }
49835      for (bits = 0; bits <= MAX_BITS; bits++) {
49836        bl_count[bits] = 0;
49837      }
49838      n = 0;
49839      while (n <= 143) {
49840        static_ltree[n * 2 + 1] = 8;
49841        n++;
49842        bl_count[8]++;
49843      }
49844      while (n <= 255) {
49845        static_ltree[n * 2 + 1] = 9;
49846        n++;
49847        bl_count[9]++;
49848      }
49849      while (n <= 279) {
49850        static_ltree[n * 2 + 1] = 7;
49851        n++;
49852        bl_count[7]++;
49853      }
49854      while (n <= 287) {
49855        static_ltree[n * 2 + 1] = 8;
49856        n++;
49857        bl_count[8]++;
49858      }
49859      gen_codes(static_ltree, L_CODES + 1, bl_count);
49860      for (n = 0; n < D_CODES; n++) {
49861        static_dtree[n * 2 + 1] = 5;
49862        static_dtree[n * 2] = bi_reverse(n, 5);
49863      }
49864      static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
49865      static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
49866      static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
49867    }
49868    function init_block(s) {
49869      var n;
49870      for (n = 0; n < L_CODES; n++) {
49871        s.dyn_ltree[n * 2] = 0;
49872      }
49873      for (n = 0; n < D_CODES; n++) {
49874        s.dyn_dtree[n * 2] = 0;
49875      }
49876      for (n = 0; n < BL_CODES; n++) {
49877        s.bl_tree[n * 2] = 0;
49878      }
49879      s.dyn_ltree[END_BLOCK * 2] = 1;
49880      s.opt_len = s.static_len = 0;
49881      s.last_lit = s.matches = 0;
49882    }
49883    function bi_windup(s) {
49884      if (s.bi_valid > 8) {
49885        put_short(s, s.bi_buf);
49886      } else if (s.bi_valid > 0) {
49887        s.pending_buf[s.pending++] = s.bi_buf;
49888      }
49889      s.bi_buf = 0;
49890      s.bi_valid = 0;
49891    }
49892    function copy_block(s, buf, len2, header) {
49893      bi_windup(s);
49894      {
49895        put_short(s, len2);
49896        put_short(s, ~len2);
49897      }
49898      utils2.arraySet(s.pending_buf, s.window, buf, len2, s.pending);
49899      s.pending += len2;
49900    }
49901    function smaller(tree, n, m, depth) {
49902      var _n2 = n * 2;
49903      var _m2 = m * 2;
49904      return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];
49905    }
49906    function pqdownheap(s, tree, k) {
49907      var v = s.heap[k];
49908      var j = k << 1;
49909      while (j <= s.heap_len) {
49910        if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
49911          j++;
49912        }
49913        if (smaller(tree, v, s.heap[j], s.depth)) {
49914          break;
49915        }
49916        s.heap[k] = s.heap[j];
49917        k = j;
49918        j <<= 1;
49919      }
49920      s.heap[k] = v;
49921    }
49922    function compress_block(s, ltree, dtree) {
49923      var dist2;
49924      var lc;
49925      var lx = 0;
49926      var code2;
49927      var extra;
49928      if (s.last_lit !== 0) {
49929        do {
49930          dist2 = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1];
49931          lc = s.pending_buf[s.l_buf + lx];
49932          lx++;
49933          if (dist2 === 0) {
49934            send_code(s, lc, ltree);
49935          } else {
49936            code2 = _length_code[lc];
49937            send_code(s, code2 + LITERALS + 1, ltree);
49938            extra = extra_lbits[code2];
49939            if (extra !== 0) {
49940              lc -= base_length[code2];
49941              send_bits(s, lc, extra);
49942            }
49943            dist2--;
49944            code2 = d_code(dist2);
49945            send_code(s, code2, dtree);
49946            extra = extra_dbits[code2];
49947            if (extra !== 0) {
49948              dist2 -= base_dist[code2];
49949              send_bits(s, dist2, extra);
49950            }
49951          }
49952        } while (lx < s.last_lit);
49953      }
49954      send_code(s, END_BLOCK, ltree);
49955    }
49956    function build_tree(s, desc) {
49957      var tree = desc.dyn_tree;
49958      var stree = desc.stat_desc.static_tree;
49959      var has_stree = desc.stat_desc.has_stree;
49960      var elems = desc.stat_desc.elems;
49961      var n, m;
49962      var max_code = -1;
49963      var node2;
49964      s.heap_len = 0;
49965      s.heap_max = HEAP_SIZE;
49966      for (n = 0; n < elems; n++) {
49967        if (tree[n * 2] !== 0) {
49968          s.heap[++s.heap_len] = max_code = n;
49969          s.depth[n] = 0;
49970        } else {
49971          tree[n * 2 + 1] = 0;
49972        }
49973      }
49974      while (s.heap_len < 2) {
49975        node2 = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
49976        tree[node2 * 2] = 1;
49977        s.depth[node2] = 0;
49978        s.opt_len--;
49979        if (has_stree) {
49980          s.static_len -= stree[node2 * 2 + 1];
49981        }
49982      }
49983      desc.max_code = max_code;
49984      for (n = s.heap_len >> 1; n >= 1; n--) {
49985        pqdownheap(s, tree, n);
49986      }
49987      node2 = elems;
49988      do {
49989        n = s.heap[
49990          1
49991          /*SMALLEST*/
49992        ];
49993        s.heap[
49994          1
49995          /*SMALLEST*/
49996        ] = s.heap[s.heap_len--];
49997        pqdownheap(
49998          s,
49999          tree,
50000          1
50001          /*SMALLEST*/
50002        );
50003        m = s.heap[
50004          1
50005          /*SMALLEST*/
50006        ];
50007        s.heap[--s.heap_max] = n;
50008        s.heap[--s.heap_max] = m;
50009        tree[node2 * 2] = tree[n * 2] + tree[m * 2];
50010        s.depth[node2] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
50011        tree[n * 2 + 1] = tree[m * 2 + 1] = node2;
50012        s.heap[
50013          1
50014          /*SMALLEST*/
50015        ] = node2++;
50016        pqdownheap(
50017          s,
50018          tree,
50019          1
50020          /*SMALLEST*/
50021        );
50022      } while (s.heap_len >= 2);
50023      s.heap[--s.heap_max] = s.heap[
50024        1
50025        /*SMALLEST*/
50026      ];
50027      gen_bitlen(s, desc);
50028      gen_codes(tree, max_code, s.bl_count);
50029    }
50030    function scan_tree(s, tree, max_code) {
50031      var n;
50032      var prevlen = -1;
50033      var curlen;
50034      var nextlen = tree[0 * 2 + 1];
50035      var count = 0;
50036      var max_count = 7;
50037      var min_count = 4;
50038      if (nextlen === 0) {
50039        max_count = 138;
50040        min_count = 3;
50041      }
50042      tree[(max_code + 1) * 2 + 1] = 65535;
50043      for (n = 0; n <= max_code; n++) {
50044        curlen = nextlen;
50045        nextlen = tree[(n + 1) * 2 + 1];
50046        if (++count < max_count && curlen === nextlen) {
50047          continue;
50048        } else if (count < min_count) {
50049          s.bl_tree[curlen * 2] += count;
50050        } else if (curlen !== 0) {
50051          if (curlen !== prevlen) {
50052            s.bl_tree[curlen * 2]++;
50053          }
50054          s.bl_tree[REP_3_6 * 2]++;
50055        } else if (count <= 10) {
50056          s.bl_tree[REPZ_3_10 * 2]++;
50057        } else {
50058          s.bl_tree[REPZ_11_138 * 2]++;
50059        }
50060        count = 0;
50061        prevlen = curlen;
50062        if (nextlen === 0) {
50063          max_count = 138;
50064          min_count = 3;
50065        } else if (curlen === nextlen) {
50066          max_count = 6;
50067          min_count = 3;
50068        } else {
50069          max_count = 7;
50070          min_count = 4;
50071        }
50072      }
50073    }
50074    function send_tree(s, tree, max_code) {
50075      var n;
50076      var prevlen = -1;
50077      var curlen;
50078      var nextlen = tree[0 * 2 + 1];
50079      var count = 0;
50080      var max_count = 7;
50081      var min_count = 4;
50082      if (nextlen === 0) {
50083        max_count = 138;
50084        min_count = 3;
50085      }
50086      for (n = 0; n <= max_code; n++) {
50087        curlen = nextlen;
50088        nextlen = tree[(n + 1) * 2 + 1];
50089        if (++count < max_count && curlen === nextlen) {
50090          continue;
50091        } else if (count < min_count) {
50092          do {
50093            send_code(s, curlen, s.bl_tree);
50094          } while (--count !== 0);
50095        } else if (curlen !== 0) {
50096          if (curlen !== prevlen) {
50097            send_code(s, curlen, s.bl_tree);
50098            count--;
50099          }
50100          send_code(s, REP_3_6, s.bl_tree);
50101          send_bits(s, count - 3, 2);
50102        } else if (count <= 10) {
50103          send_code(s, REPZ_3_10, s.bl_tree);
50104          send_bits(s, count - 3, 3);
50105        } else {
50106          send_code(s, REPZ_11_138, s.bl_tree);
50107          send_bits(s, count - 11, 7);
50108        }
50109        count = 0;
50110        prevlen = curlen;
50111        if (nextlen === 0) {
50112          max_count = 138;
50113          min_count = 3;
50114        } else if (curlen === nextlen) {
50115          max_count = 6;
50116          min_count = 3;
50117        } else {
50118          max_count = 7;
50119          min_count = 4;
50120        }
50121      }
50122    }
50123    function build_bl_tree(s) {
50124      var max_blindex;
50125      scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
50126      scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
50127      build_tree(s, s.bl_desc);
50128      for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
50129        if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
50130          break;
50131        }
50132      }
50133      s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
50134      return max_blindex;
50135    }
50136    function send_all_trees(s, lcodes, dcodes, blcodes) {
50137      var rank;
50138      send_bits(s, lcodes - 257, 5);
50139      send_bits(s, dcodes - 1, 5);
50140      send_bits(s, blcodes - 4, 4);
50141      for (rank = 0; rank < blcodes; rank++) {
50142        send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], 3);
50143      }
50144      send_tree(s, s.dyn_ltree, lcodes - 1);
50145      send_tree(s, s.dyn_dtree, dcodes - 1);
50146    }
50147    function detect_data_type(s) {
50148      var black_mask = 4093624447;
50149      var n;
50150      for (n = 0; n <= 31; n++, black_mask >>>= 1) {
50151        if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) {
50152          return Z_BINARY;
50153        }
50154      }
50155      if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) {
50156        return Z_TEXT;
50157      }
50158      for (n = 32; n < LITERALS; n++) {
50159        if (s.dyn_ltree[n * 2] !== 0) {
50160          return Z_TEXT;
50161        }
50162      }
50163      return Z_BINARY;
50164    }
50165    var static_init_done = false;
50166    function _tr_init(s) {
50167      if (!static_init_done) {
50168        tr_static_init();
50169        static_init_done = true;
50170      }
50171      s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
50172      s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
50173      s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
50174      s.bi_buf = 0;
50175      s.bi_valid = 0;
50176      init_block(s);
50177    }
50178    function _tr_stored_block(s, buf, stored_len, last) {
50179      send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
50180      copy_block(s, buf, stored_len);
50181    }
50182    function _tr_align(s) {
50183      send_bits(s, STATIC_TREES << 1, 3);
50184      send_code(s, END_BLOCK, static_ltree);
50185      bi_flush(s);
50186    }
50187    function _tr_flush_block(s, buf, stored_len, last) {
50188      var opt_lenb, static_lenb;
50189      var max_blindex = 0;
50190      if (s.level > 0) {
50191        if (s.strm.data_type === Z_UNKNOWN) {
50192          s.strm.data_type = detect_data_type(s);
50193        }
50194        build_tree(s, s.l_desc);
50195        build_tree(s, s.d_desc);
50196        max_blindex = build_bl_tree(s);
50197        opt_lenb = s.opt_len + 3 + 7 >>> 3;
50198        static_lenb = s.static_len + 3 + 7 >>> 3;
50199        if (static_lenb <= opt_lenb) {
50200          opt_lenb = static_lenb;
50201        }
50202      } else {
50203        opt_lenb = static_lenb = stored_len + 5;
50204      }
50205      if (stored_len + 4 <= opt_lenb && buf !== -1) {
50206        _tr_stored_block(s, buf, stored_len, last);
50207      } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
50208        send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
50209        compress_block(s, static_ltree, static_dtree);
50210      } else {
50211        send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
50212        send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
50213        compress_block(s, s.dyn_ltree, s.dyn_dtree);
50214      }
50215      init_block(s);
50216      if (last) {
50217        bi_windup(s);
50218      }
50219    }
50220    function _tr_tally(s, dist2, lc) {
50221      s.pending_buf[s.d_buf + s.last_lit * 2] = dist2 >>> 8 & 255;
50222      s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist2 & 255;
50223      s.pending_buf[s.l_buf + s.last_lit] = lc & 255;
50224      s.last_lit++;
50225      if (dist2 === 0) {
50226        s.dyn_ltree[lc * 2]++;
50227      } else {
50228        s.matches++;
50229        dist2--;
50230        s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;
50231        s.dyn_dtree[d_code(dist2) * 2]++;
50232      }
50233      return s.last_lit === s.lit_bufsize - 1;
50234    }
50235    trees._tr_init = _tr_init;
50236    trees._tr_stored_block = _tr_stored_block;
50237    trees._tr_flush_block = _tr_flush_block;
50238    trees._tr_tally = _tr_tally;
50239    trees._tr_align = _tr_align;
50240    return trees;
50241  }
50242  var adler32_1;
50243  var hasRequiredAdler32;
50244  function requireAdler32() {
50245    if (hasRequiredAdler32) return adler32_1;
50246    hasRequiredAdler32 = 1;
50247    function adler32(adler, buf, len2, pos) {
50248      var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
50249      while (len2 !== 0) {
50250        n = len2 > 2e3 ? 2e3 : len2;
50251        len2 -= n;
50252        do {
50253          s1 = s1 + buf[pos++] | 0;
50254          s2 = s2 + s1 | 0;
50255        } while (--n);
50256        s1 %= 65521;
50257        s2 %= 65521;
50258      }
50259      return s1 | s2 << 16 | 0;
50260    }
50261    adler32_1 = adler32;
50262    return adler32_1;
50263  }
50264  var crc32_1;
50265  var hasRequiredCrc32;
50266  function requireCrc32() {
50267    if (hasRequiredCrc32) return crc32_1;
50268    hasRequiredCrc32 = 1;
50269    function makeTable() {
50270      var c, table = [];
50271      for (var n = 0; n < 256; n++) {
50272        c = n;
50273        for (var k = 0; k < 8; k++) {
50274          c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
50275        }
50276        table[n] = c;
50277      }
50278      return table;
50279    }
50280    var crcTable = makeTable();
50281    function crc32(crc, buf, len2, pos) {
50282      var t = crcTable, end = pos + len2;
50283      crc ^= -1;
50284      for (var i2 = pos; i2 < end; i2++) {
50285        crc = crc >>> 8 ^ t[(crc ^ buf[i2]) & 255];
50286      }
50287      return crc ^ -1;
50288    }
50289    crc32_1 = crc32;
50290    return crc32_1;
50291  }
50292  var messages;
50293  var hasRequiredMessages;
50294  function requireMessages() {
50295    if (hasRequiredMessages) return messages;
50296    hasRequiredMessages = 1;
50297    messages = {
50298      2: "need dictionary",
50299      /* Z_NEED_DICT       2  */
50300      1: "stream end",
50301      /* Z_STREAM_END      1  */
50302      0: "",
50303      /* Z_OK              0  */
50304      "-1": "file error",
50305      /* Z_ERRNO         (-1) */
50306      "-2": "stream error",
50307      /* Z_STREAM_ERROR  (-2) */
50308      "-3": "data error",
50309      /* Z_DATA_ERROR    (-3) */
50310      "-4": "insufficient memory",
50311      /* Z_MEM_ERROR     (-4) */
50312      "-5": "buffer error",
50313      /* Z_BUF_ERROR     (-5) */
50314      "-6": "incompatible version"
50315      /* Z_VERSION_ERROR (-6) */
50316    };
50317    return messages;
50318  }
50319  var hasRequiredDeflate$1;
50320  function requireDeflate$1() {
50321    if (hasRequiredDeflate$1) return deflate;
50322    hasRequiredDeflate$1 = 1;
50323    var utils2 = requireCommon();
50324    var trees2 = requireTrees();
50325    var adler32 = requireAdler32();
50326    var crc32 = requireCrc32();
50327    var msg = requireMessages();
50328    var Z_NO_FLUSH = 0;
50329    var Z_PARTIAL_FLUSH = 1;
50330    var Z_FULL_FLUSH = 3;
50331    var Z_FINISH = 4;
50332    var Z_BLOCK = 5;
50333    var Z_OK = 0;
50334    var Z_STREAM_END = 1;
50335    var Z_STREAM_ERROR = -2;
50336    var Z_DATA_ERROR = -3;
50337    var Z_BUF_ERROR = -5;
50338    var Z_DEFAULT_COMPRESSION = -1;
50339    var Z_FILTERED = 1;
50340    var Z_HUFFMAN_ONLY = 2;
50341    var Z_RLE = 3;
50342    var Z_FIXED = 4;
50343    var Z_DEFAULT_STRATEGY = 0;
50344    var Z_UNKNOWN = 2;
50345    var Z_DEFLATED = 8;
50346    var MAX_MEM_LEVEL = 9;
50347    var MAX_WBITS = 15;
50348    var DEF_MEM_LEVEL = 8;
50349    var LENGTH_CODES = 29;
50350    var LITERALS = 256;
50351    var L_CODES = LITERALS + 1 + LENGTH_CODES;
50352    var D_CODES = 30;
50353    var BL_CODES = 19;
50354    var HEAP_SIZE = 2 * L_CODES + 1;
50355    var MAX_BITS = 15;
50356    var MIN_MATCH = 3;
50357    var MAX_MATCH = 258;
50358    var MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;
50359    var PRESET_DICT = 32;
50360    var INIT_STATE = 42;
50361    var EXTRA_STATE = 69;
50362    var NAME_STATE = 73;
50363    var COMMENT_STATE = 91;
50364    var HCRC_STATE = 103;
50365    var BUSY_STATE = 113;
50366    var FINISH_STATE = 666;
50367    var BS_NEED_MORE = 1;
50368    var BS_BLOCK_DONE = 2;
50369    var BS_FINISH_STARTED = 3;
50370    var BS_FINISH_DONE = 4;
50371    var OS_CODE = 3;
50372    function err(strm, errorCode) {
50373      strm.msg = msg[errorCode];
50374      return errorCode;
50375    }
50376    function rank(f) {
50377      return (f << 1) - (f > 4 ? 9 : 0);
50378    }
50379    function zero(buf) {
50380      var len2 = buf.length;
50381      while (--len2 >= 0) {
50382        buf[len2] = 0;
50383      }
50384    }
50385    function flush_pending(strm) {
50386      var s = strm.state;
50387      var len2 = s.pending;
50388      if (len2 > strm.avail_out) {
50389        len2 = strm.avail_out;
50390      }
50391      if (len2 === 0) {
50392        return;
50393      }
50394      utils2.arraySet(strm.output, s.pending_buf, s.pending_out, len2, strm.next_out);
50395      strm.next_out += len2;
50396      s.pending_out += len2;
50397      strm.total_out += len2;
50398      strm.avail_out -= len2;
50399      s.pending -= len2;
50400      if (s.pending === 0) {
50401        s.pending_out = 0;
50402      }
50403    }
50404    function flush_block_only(s, last) {
50405      trees2._tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);
50406      s.block_start = s.strstart;
50407      flush_pending(s.strm);
50408    }
50409    function put_byte(s, b) {
50410      s.pending_buf[s.pending++] = b;
50411    }
50412    function putShortMSB(s, b) {
50413      s.pending_buf[s.pending++] = b >>> 8 & 255;
50414      s.pending_buf[s.pending++] = b & 255;
50415    }
50416    function read_buf(strm, buf, start, size) {
50417      var len2 = strm.avail_in;
50418      if (len2 > size) {
50419        len2 = size;
50420      }
50421      if (len2 === 0) {
50422        return 0;
50423      }
50424      strm.avail_in -= len2;
50425      utils2.arraySet(buf, strm.input, strm.next_in, len2, start);
50426      if (strm.state.wrap === 1) {
50427        strm.adler = adler32(strm.adler, buf, len2, start);
50428      } else if (strm.state.wrap === 2) {
50429        strm.adler = crc32(strm.adler, buf, len2, start);
50430      }
50431      strm.next_in += len2;
50432      strm.total_in += len2;
50433      return len2;
50434    }
50435    function longest_match(s, cur_match) {
50436      var chain_length = s.max_chain_length;
50437      var scan = s.strstart;
50438      var match;
50439      var len2;
50440      var best_len = s.prev_length;
50441      var nice_match = s.nice_match;
50442      var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;
50443      var _win = s.window;
50444      var wmask = s.w_mask;
50445      var prev = s.prev;
50446      var strend = s.strstart + MAX_MATCH;
50447      var scan_end1 = _win[scan + best_len - 1];
50448      var scan_end = _win[scan + best_len];
50449      if (s.prev_length >= s.good_match) {
50450        chain_length >>= 2;
50451      }
50452      if (nice_match > s.lookahead) {
50453        nice_match = s.lookahead;
50454      }
50455      do {
50456        match = cur_match;
50457        if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) {
50458          continue;
50459        }
50460        scan += 2;
50461        match++;
50462        do {
50463        } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
50464        len2 = MAX_MATCH - (strend - scan);
50465        scan = strend - MAX_MATCH;
50466        if (len2 > best_len) {
50467          s.match_start = cur_match;
50468          best_len = len2;
50469          if (len2 >= nice_match) {
50470            break;
50471          }
50472          scan_end1 = _win[scan + best_len - 1];
50473          scan_end = _win[scan + best_len];
50474        }
50475      } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
50476      if (best_len <= s.lookahead) {
50477        return best_len;
50478      }
50479      return s.lookahead;
50480    }
50481    function fill_window(s) {
50482      var _w_size = s.w_size;
50483      var p, n, m, more, str;
50484      do {
50485        more = s.window_size - s.lookahead - s.strstart;
50486        if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
50487          utils2.arraySet(s.window, s.window, _w_size, _w_size, 0);
50488          s.match_start -= _w_size;
50489          s.strstart -= _w_size;
50490          s.block_start -= _w_size;
50491          n = s.hash_size;
50492          p = n;
50493          do {
50494            m = s.head[--p];
50495            s.head[p] = m >= _w_size ? m - _w_size : 0;
50496          } while (--n);
50497          n = _w_size;
50498          p = n;
50499          do {
50500            m = s.prev[--p];
50501            s.prev[p] = m >= _w_size ? m - _w_size : 0;
50502          } while (--n);
50503          more += _w_size;
50504        }
50505        if (s.strm.avail_in === 0) {
50506          break;
50507        }
50508        n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
50509        s.lookahead += n;
50510        if (s.lookahead + s.insert >= MIN_MATCH) {
50511          str = s.strstart - s.insert;
50512          s.ins_h = s.window[str];
50513          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask;
50514          while (s.insert) {
50515            s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
50516            s.prev[str & s.w_mask] = s.head[s.ins_h];
50517            s.head[s.ins_h] = str;
50518            str++;
50519            s.insert--;
50520            if (s.lookahead + s.insert < MIN_MATCH) {
50521              break;
50522            }
50523          }
50524        }
50525      } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
50526    }
50527    function deflate_stored(s, flush) {
50528      var max_block_size = 65535;
50529      if (max_block_size > s.pending_buf_size - 5) {
50530        max_block_size = s.pending_buf_size - 5;
50531      }
50532      for (; ; ) {
50533        if (s.lookahead <= 1) {
50534          fill_window(s);
50535          if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
50536            return BS_NEED_MORE;
50537          }
50538          if (s.lookahead === 0) {
50539            break;
50540          }
50541        }
50542        s.strstart += s.lookahead;
50543        s.lookahead = 0;
50544        var max_start = s.block_start + max_block_size;
50545        if (s.strstart === 0 || s.strstart >= max_start) {
50546          s.lookahead = s.strstart - max_start;
50547          s.strstart = max_start;
50548          flush_block_only(s, false);
50549          if (s.strm.avail_out === 0) {
50550            return BS_NEED_MORE;
50551          }
50552        }
50553        if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {
50554          flush_block_only(s, false);
50555          if (s.strm.avail_out === 0) {
50556            return BS_NEED_MORE;
50557          }
50558        }
50559      }
50560      s.insert = 0;
50561      if (flush === Z_FINISH) {
50562        flush_block_only(s, true);
50563        if (s.strm.avail_out === 0) {
50564          return BS_FINISH_STARTED;
50565        }
50566        return BS_FINISH_DONE;
50567      }
50568      if (s.strstart > s.block_start) {
50569        flush_block_only(s, false);
50570        if (s.strm.avail_out === 0) {
50571          return BS_NEED_MORE;
50572        }
50573      }
50574      return BS_NEED_MORE;
50575    }
50576    function deflate_fast(s, flush) {
50577      var hash_head;
50578      var bflush;
50579      for (; ; ) {
50580        if (s.lookahead < MIN_LOOKAHEAD) {
50581          fill_window(s);
50582          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
50583            return BS_NEED_MORE;
50584          }
50585          if (s.lookahead === 0) {
50586            break;
50587          }
50588        }
50589        hash_head = 0;
50590        if (s.lookahead >= MIN_MATCH) {
50591          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
50592          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
50593          s.head[s.ins_h] = s.strstart;
50594        }
50595        if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
50596          s.match_length = longest_match(s, hash_head);
50597        }
50598        if (s.match_length >= MIN_MATCH) {
50599          bflush = trees2._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH);
50600          s.lookahead -= s.match_length;
50601          if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH) {
50602            s.match_length--;
50603            do {
50604              s.strstart++;
50605              s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
50606              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
50607              s.head[s.ins_h] = s.strstart;
50608            } while (--s.match_length !== 0);
50609            s.strstart++;
50610          } else {
50611            s.strstart += s.match_length;
50612            s.match_length = 0;
50613            s.ins_h = s.window[s.strstart];
50614            s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask;
50615          }
50616        } else {
50617          bflush = trees2._tr_tally(s, 0, s.window[s.strstart]);
50618          s.lookahead--;
50619          s.strstart++;
50620        }
50621        if (bflush) {
50622          flush_block_only(s, false);
50623          if (s.strm.avail_out === 0) {
50624            return BS_NEED_MORE;
50625          }
50626        }
50627      }
50628      s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
50629      if (flush === Z_FINISH) {
50630        flush_block_only(s, true);
50631        if (s.strm.avail_out === 0) {
50632          return BS_FINISH_STARTED;
50633        }
50634        return BS_FINISH_DONE;
50635      }
50636      if (s.last_lit) {
50637        flush_block_only(s, false);
50638        if (s.strm.avail_out === 0) {
50639          return BS_NEED_MORE;
50640        }
50641      }
50642      return BS_BLOCK_DONE;
50643    }
50644    function deflate_slow(s, flush) {
50645      var hash_head;
50646      var bflush;
50647      var max_insert;
50648      for (; ; ) {
50649        if (s.lookahead < MIN_LOOKAHEAD) {
50650          fill_window(s);
50651          if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
50652            return BS_NEED_MORE;
50653          }
50654          if (s.lookahead === 0) {
50655            break;
50656          }
50657        }
50658        hash_head = 0;
50659        if (s.lookahead >= MIN_MATCH) {
50660          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
50661          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
50662          s.head[s.ins_h] = s.strstart;
50663        }
50664        s.prev_length = s.match_length;
50665        s.prev_match = s.match_start;
50666        s.match_length = MIN_MATCH - 1;
50667        if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
50668          s.match_length = longest_match(s, hash_head);
50669          if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096)) {
50670            s.match_length = MIN_MATCH - 1;
50671          }
50672        }
50673        if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) {
50674          max_insert = s.strstart + s.lookahead - MIN_MATCH;
50675          bflush = trees2._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH);
50676          s.lookahead -= s.prev_length - 1;
50677          s.prev_length -= 2;
50678          do {
50679            if (++s.strstart <= max_insert) {
50680              s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask;
50681              hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
50682              s.head[s.ins_h] = s.strstart;
50683            }
50684          } while (--s.prev_length !== 0);
50685          s.match_available = 0;
50686          s.match_length = MIN_MATCH - 1;
50687          s.strstart++;
50688          if (bflush) {
50689            flush_block_only(s, false);
50690            if (s.strm.avail_out === 0) {
50691              return BS_NEED_MORE;
50692            }
50693          }
50694        } else if (s.match_available) {
50695          bflush = trees2._tr_tally(s, 0, s.window[s.strstart - 1]);
50696          if (bflush) {
50697            flush_block_only(s, false);
50698          }
50699          s.strstart++;
50700          s.lookahead--;
50701          if (s.strm.avail_out === 0) {
50702            return BS_NEED_MORE;
50703          }
50704        } else {
50705          s.match_available = 1;
50706          s.strstart++;
50707          s.lookahead--;
50708        }
50709      }
50710      if (s.match_available) {
50711        bflush = trees2._tr_tally(s, 0, s.window[s.strstart - 1]);
50712        s.match_available = 0;
50713      }
50714      s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1;
50715      if (flush === Z_FINISH) {
50716        flush_block_only(s, true);
50717        if (s.strm.avail_out === 0) {
50718          return BS_FINISH_STARTED;
50719        }
50720        return BS_FINISH_DONE;
50721      }
50722      if (s.last_lit) {
50723        flush_block_only(s, false);
50724        if (s.strm.avail_out === 0) {
50725          return BS_NEED_MORE;
50726        }
50727      }
50728      return BS_BLOCK_DONE;
50729    }
50730    function deflate_rle(s, flush) {
50731      var bflush;
50732      var prev;
50733      var scan, strend;
50734      var _win = s.window;
50735      for (; ; ) {
50736        if (s.lookahead <= MAX_MATCH) {
50737          fill_window(s);
50738          if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) {
50739            return BS_NEED_MORE;
50740          }
50741          if (s.lookahead === 0) {
50742            break;
50743          }
50744        }
50745        s.match_length = 0;
50746        if (s.lookahead >= MIN_MATCH && s.strstart > 0) {
50747          scan = s.strstart - 1;
50748          prev = _win[scan];
50749          if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
50750            strend = s.strstart + MAX_MATCH;
50751            do {
50752            } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);
50753            s.match_length = MAX_MATCH - (strend - scan);
50754            if (s.match_length > s.lookahead) {
50755              s.match_length = s.lookahead;
50756            }
50757          }
50758        }
50759        if (s.match_length >= MIN_MATCH) {
50760          bflush = trees2._tr_tally(s, 1, s.match_length - MIN_MATCH);
50761          s.lookahead -= s.match_length;
50762          s.strstart += s.match_length;
50763          s.match_length = 0;
50764        } else {
50765          bflush = trees2._tr_tally(s, 0, s.window[s.strstart]);
50766          s.lookahead--;
50767          s.strstart++;
50768        }
50769        if (bflush) {
50770          flush_block_only(s, false);
50771          if (s.strm.avail_out === 0) {
50772            return BS_NEED_MORE;
50773          }
50774        }
50775      }
50776      s.insert = 0;
50777      if (flush === Z_FINISH) {
50778        flush_block_only(s, true);
50779        if (s.strm.avail_out === 0) {
50780          return BS_FINISH_STARTED;
50781        }
50782        return BS_FINISH_DONE;
50783      }
50784      if (s.last_lit) {
50785        flush_block_only(s, false);
50786        if (s.strm.avail_out === 0) {
50787          return BS_NEED_MORE;
50788        }
50789      }
50790      return BS_BLOCK_DONE;
50791    }
50792    function deflate_huff(s, flush) {
50793      var bflush;
50794      for (; ; ) {
50795        if (s.lookahead === 0) {
50796          fill_window(s);
50797          if (s.lookahead === 0) {
50798            if (flush === Z_NO_FLUSH) {
50799              return BS_NEED_MORE;
50800            }
50801            break;
50802          }
50803        }
50804        s.match_length = 0;
50805        bflush = trees2._tr_tally(s, 0, s.window[s.strstart]);
50806        s.lookahead--;
50807        s.strstart++;
50808        if (bflush) {
50809          flush_block_only(s, false);
50810          if (s.strm.avail_out === 0) {
50811            return BS_NEED_MORE;
50812          }
50813        }
50814      }
50815      s.insert = 0;
50816      if (flush === Z_FINISH) {
50817        flush_block_only(s, true);
50818        if (s.strm.avail_out === 0) {
50819          return BS_FINISH_STARTED;
50820        }
50821        return BS_FINISH_DONE;
50822      }
50823      if (s.last_lit) {
50824        flush_block_only(s, false);
50825        if (s.strm.avail_out === 0) {
50826          return BS_NEED_MORE;
50827        }
50828      }
50829      return BS_BLOCK_DONE;
50830    }
50831    function Config(good_length, max_lazy, nice_length, max_chain, func) {
50832      this.good_length = good_length;
50833      this.max_lazy = max_lazy;
50834      this.nice_length = nice_length;
50835      this.max_chain = max_chain;
50836      this.func = func;
50837    }
50838    var configuration_table;
50839    configuration_table = [
50840      /*      good lazy nice chain */
50841      new Config(0, 0, 0, 0, deflate_stored),
50842      /* 0 store only */
50843      new Config(4, 4, 8, 4, deflate_fast),
50844      /* 1 max speed, no lazy matches */
50845      new Config(4, 5, 16, 8, deflate_fast),
50846      /* 2 */
50847      new Config(4, 6, 32, 32, deflate_fast),
50848      /* 3 */
50849      new Config(4, 4, 16, 16, deflate_slow),
50850      /* 4 lazy matches */
50851      new Config(8, 16, 32, 32, deflate_slow),
50852      /* 5 */
50853      new Config(8, 16, 128, 128, deflate_slow),
50854      /* 6 */
50855      new Config(8, 32, 128, 256, deflate_slow),
50856      /* 7 */
50857      new Config(32, 128, 258, 1024, deflate_slow),
50858      /* 8 */
50859      new Config(32, 258, 258, 4096, deflate_slow)
50860      /* 9 max compression */
50861    ];
50862    function lm_init(s) {
50863      s.window_size = 2 * s.w_size;
50864      zero(s.head);
50865      s.max_lazy_match = configuration_table[s.level].max_lazy;
50866      s.good_match = configuration_table[s.level].good_length;
50867      s.nice_match = configuration_table[s.level].nice_length;
50868      s.max_chain_length = configuration_table[s.level].max_chain;
50869      s.strstart = 0;
50870      s.block_start = 0;
50871      s.lookahead = 0;
50872      s.insert = 0;
50873      s.match_length = s.prev_length = MIN_MATCH - 1;
50874      s.match_available = 0;
50875      s.ins_h = 0;
50876    }
50877    function DeflateState() {
50878      this.strm = null;
50879      this.status = 0;
50880      this.pending_buf = null;
50881      this.pending_buf_size = 0;
50882      this.pending_out = 0;
50883      this.pending = 0;
50884      this.wrap = 0;
50885      this.gzhead = null;
50886      this.gzindex = 0;
50887      this.method = Z_DEFLATED;
50888      this.last_flush = -1;
50889      this.w_size = 0;
50890      this.w_bits = 0;
50891      this.w_mask = 0;
50892      this.window = null;
50893      this.window_size = 0;
50894      this.prev = null;
50895      this.head = null;
50896      this.ins_h = 0;
50897      this.hash_size = 0;
50898      this.hash_bits = 0;
50899      this.hash_mask = 0;
50900      this.hash_shift = 0;
50901      this.block_start = 0;
50902      this.match_length = 0;
50903      this.prev_match = 0;
50904      this.match_available = 0;
50905      this.strstart = 0;
50906      this.match_start = 0;
50907      this.lookahead = 0;
50908      this.prev_length = 0;
50909      this.max_chain_length = 0;
50910      this.max_lazy_match = 0;
50911      this.level = 0;
50912      this.strategy = 0;
50913      this.good_match = 0;
50914      this.nice_match = 0;
50915      this.dyn_ltree = new utils2.Buf16(HEAP_SIZE * 2);
50916      this.dyn_dtree = new utils2.Buf16((2 * D_CODES + 1) * 2);
50917      this.bl_tree = new utils2.Buf16((2 * BL_CODES + 1) * 2);
50918      zero(this.dyn_ltree);
50919      zero(this.dyn_dtree);
50920      zero(this.bl_tree);
50921      this.l_desc = null;
50922      this.d_desc = null;
50923      this.bl_desc = null;
50924      this.bl_count = new utils2.Buf16(MAX_BITS + 1);
50925      this.heap = new utils2.Buf16(2 * L_CODES + 1);
50926      zero(this.heap);
50927      this.heap_len = 0;
50928      this.heap_max = 0;
50929      this.depth = new utils2.Buf16(2 * L_CODES + 1);
50930      zero(this.depth);
50931      this.l_buf = 0;
50932      this.lit_bufsize = 0;
50933      this.last_lit = 0;
50934      this.d_buf = 0;
50935      this.opt_len = 0;
50936      this.static_len = 0;
50937      this.matches = 0;
50938      this.insert = 0;
50939      this.bi_buf = 0;
50940      this.bi_valid = 0;
50941    }
50942    function deflateResetKeep(strm) {
50943      var s;
50944      if (!strm || !strm.state) {
50945        return err(strm, Z_STREAM_ERROR);
50946      }
50947      strm.total_in = strm.total_out = 0;
50948      strm.data_type = Z_UNKNOWN;
50949      s = strm.state;
50950      s.pending = 0;
50951      s.pending_out = 0;
50952      if (s.wrap < 0) {
50953        s.wrap = -s.wrap;
50954      }
50955      s.status = s.wrap ? INIT_STATE : BUSY_STATE;
50956      strm.adler = s.wrap === 2 ? 0 : 1;
50957      s.last_flush = Z_NO_FLUSH;
50958      trees2._tr_init(s);
50959      return Z_OK;
50960    }
50961    function deflateReset(strm) {
50962      var ret = deflateResetKeep(strm);
50963      if (ret === Z_OK) {
50964        lm_init(strm.state);
50965      }
50966      return ret;
50967    }
50968    function deflateSetHeader(strm, head) {
50969      if (!strm || !strm.state) {
50970        return Z_STREAM_ERROR;
50971      }
50972      if (strm.state.wrap !== 2) {
50973        return Z_STREAM_ERROR;
50974      }
50975      strm.state.gzhead = head;
50976      return Z_OK;
50977    }
50978    function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
50979      if (!strm) {
50980        return Z_STREAM_ERROR;
50981      }
50982      var wrap = 1;
50983      if (level === Z_DEFAULT_COMPRESSION) {
50984        level = 6;
50985      }
50986      if (windowBits < 0) {
50987        wrap = 0;
50988        windowBits = -windowBits;
50989      } else if (windowBits > 15) {
50990        wrap = 2;
50991        windowBits -= 16;
50992      }
50993      if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
50994        return err(strm, Z_STREAM_ERROR);
50995      }
50996      if (windowBits === 8) {
50997        windowBits = 9;
50998      }
50999      var s = new DeflateState();
51000      strm.state = s;
51001      s.strm = strm;
51002      s.wrap = wrap;
51003      s.gzhead = null;
51004      s.w_bits = windowBits;
51005      s.w_size = 1 << s.w_bits;
51006      s.w_mask = s.w_size - 1;
51007      s.hash_bits = memLevel + 7;
51008      s.hash_size = 1 << s.hash_bits;
51009      s.hash_mask = s.hash_size - 1;
51010      s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH);
51011      s.window = new utils2.Buf8(s.w_size * 2);
51012      s.head = new utils2.Buf16(s.hash_size);
51013      s.prev = new utils2.Buf16(s.w_size);
51014      s.lit_bufsize = 1 << memLevel + 6;
51015      s.pending_buf_size = s.lit_bufsize * 4;
51016      s.pending_buf = new utils2.Buf8(s.pending_buf_size);
51017      s.d_buf = 1 * s.lit_bufsize;
51018      s.l_buf = (1 + 2) * s.lit_bufsize;
51019      s.level = level;
51020      s.strategy = strategy;
51021      s.method = method;
51022      return deflateReset(strm);
51023    }
51024    function deflateInit(strm, level) {
51025      return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
51026    }
51027    function deflate$12

vendor: 7,389 bytes, lines 51027-51235

51027(strm, flush) {
51028      var old_flush, s;
51029      var beg, val;
51030      if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {
51031        return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;
51032      }
51033      s = strm.state;
51034      if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH) {
51035        return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);
51036      }
51037      s.strm = strm;
51038      old_flush = s.last_flush;
51039      s.last_flush = flush;
51040      if (s.status === INIT_STATE) {
51041        if (s.wrap === 2) {
51042          strm.adler = 0;
51043          put_byte(s, 31);
51044          put_byte(s, 139);
51045          put_byte(s, 8);
51046          if (!s.gzhead) {
51047            put_byte(s, 0);
51048            put_byte(s, 0);
51049            put_byte(s, 0);
51050            put_byte(s, 0);
51051            put_byte(s, 0);
51052            put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
51053            put_byte(s, OS_CODE);
51054            s.status = BUSY_STATE;
51055          } else {
51056            put_byte(
51057              s,
51058              (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16)
51059            );
51060            put_byte(s, s.gzhead.time & 255);
51061            put_byte(s, s.gzhead.time >> 8 & 255);
51062            put_byte(s, s.gzhead.time >> 16 & 255);
51063            put_byte(s, s.gzhead.time >> 24 & 255);
51064            put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
51065            put_byte(s, s.gzhead.os & 255);
51066            if (s.gzhead.extra && s.gzhead.extra.length) {
51067              put_byte(s, s.gzhead.extra.length & 255);
51068              put_byte(s, s.gzhead.extra.length >> 8 & 255);
51069            }
51070            if (s.gzhead.hcrc) {
51071              strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0);
51072            }
51073            s.gzindex = 0;
51074            s.status = EXTRA_STATE;
51075          }
51076        } else {
51077          var header = Z_DEFLATED + (s.w_bits - 8 << 4) << 8;
51078          var level_flags = -1;
51079          if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
51080            level_flags = 0;
51081          } else if (s.level < 6) {
51082            level_flags = 1;
51083          } else if (s.level === 6) {
51084            level_flags = 2;
51085          } else {
51086            level_flags = 3;
51087          }
51088          header |= level_flags << 6;
51089          if (s.strstart !== 0) {
51090            header |= PRESET_DICT;
51091          }
51092          header += 31 - header % 31;
51093          s.status = BUSY_STATE;
51094          putShortMSB(s, header);
51095          if (s.strstart !== 0) {
51096            putShortMSB(s, strm.adler >>> 16);
51097            putShortMSB(s, strm.adler & 65535);
51098          }
51099          strm.adler = 1;
51100        }
51101      }
51102      if (s.status === EXTRA_STATE) {
51103        if (s.gzhead.extra) {
51104          beg = s.pending;
51105          while (s.gzindex < (s.gzhead.extra.length & 65535)) {
51106            if (s.pending === s.pending_buf_size) {
51107              if (s.gzhead.hcrc && s.pending > beg) {
51108                strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51109              }
51110              flush_pending(strm);
51111              beg = s.pending;
51112              if (s.pending === s.pending_buf_size) {
51113                break;
51114              }
51115            }
51116            put_byte(s, s.gzhead.extra[s.gzindex] & 255);
51117            s.gzindex++;
51118          }
51119          if (s.gzhead.hcrc && s.pending > beg) {
51120            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51121          }
51122          if (s.gzindex === s.gzhead.extra.length) {
51123            s.gzindex = 0;
51124            s.status = NAME_STATE;
51125          }
51126        } else {
51127          s.status = NAME_STATE;
51128        }
51129      }
51130      if (s.status === NAME_STATE) {
51131        if (s.gzhead.name) {
51132          beg = s.pending;
51133          do {
51134            if (s.pending === s.pending_buf_size) {
51135              if (s.gzhead.hcrc && s.pending > beg) {
51136                strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51137              }
51138              flush_pending(strm);
51139              beg = s.pending;
51140              if (s.pending === s.pending_buf_size) {
51141                val = 1;
51142                break;
51143              }
51144            }
51145            if (s.gzindex < s.gzhead.name.length) {
51146              val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;
51147            } else {
51148              val = 0;
51149            }
51150            put_byte(s, val);
51151          } while (val !== 0);
51152          if (s.gzhead.hcrc && s.pending > beg) {
51153            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51154          }
51155          if (val === 0) {
51156            s.gzindex = 0;
51157            s.status = COMMENT_STATE;
51158          }
51159        } else {
51160          s.status = COMMENT_STATE;
51161        }
51162      }
51163      if (s.status === COMMENT_STATE) {
51164        if (s.gzhead.comment) {
51165          beg = s.pending;
51166          do {
51167            if (s.pending === s.pending_buf_size) {
51168              if (s.gzhead.hcrc && s.pending > beg) {
51169                strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51170              }
51171              flush_pending(strm);
51172              beg = s.pending;
51173              if (s.pending === s.pending_buf_size) {
51174                val = 1;
51175                break;
51176              }
51177            }
51178            if (s.gzindex < s.gzhead.comment.length) {
51179              val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;
51180            } else {
51181              val = 0;
51182            }
51183            put_byte(s, val);
51184          } while (val !== 0);
51185          if (s.gzhead.hcrc && s.pending > beg) {
51186            strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg);
51187          }
51188          if (val === 0) {
51189            s.status = HCRC_STATE;
51190          }
51191        } else {
51192          s.status = HCRC_STATE;
51193        }
51194      }
51195      if (s.status === HCRC_STATE) {
51196        if (s.gzhead.hcrc) {
51197          if (s.pending + 2 > s.pending_buf_size) {
51198            flush_pending(strm);
51199          }
51200          if (s.pending + 2 <= s.pending_buf_size) {
51201            put_byte(s, strm.adler & 255);
51202            put_byte(s, strm.adler >> 8 & 255);
51203            strm.adler = 0;
51204            s.status = BUSY_STATE;
51205          }
51206        } else {
51207          s.status = BUSY_STATE;
51208        }
51209      }
51210      if (s.pending !== 0) {
51211        flush_pending(strm);
51212        if (strm.avail_out === 0) {
51213          s.last_flush = -1;
51214          return Z_OK;
51215        }
51216      } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {
51217        return err(strm, Z_BUF_ERROR);
51218      }
51219      if (s.status === FINISH_STATE && strm.avail_in !== 0) {
51220        return err(strm, Z_BUF_ERROR);
51221      }
51222      if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) {
51223        var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush);
51224        if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
51225          s.status = FINISH_STATE;
51226        }
51227        if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
51228          if (strm.avail_out === 0) {
51229            s.last_flush = -1;
51230          }
51231          return Z_OK;
51232        }
51233        if (bstate === BS_BLOCK_DONE) {
51234          if (flush === Z_PARTIAL_FLUSH) {
51235            trees

vendor: 13,254 bytes, lines 51235-51666

512352._tr_align(s);
51236          } else if (flush !== Z_BLOCK) {
51237            trees2._tr_stored_block(s, 0, 0, false);
51238            if (flush === Z_FULL_FLUSH) {
51239              zero(s.head);
51240              if (s.lookahead === 0) {
51241                s.strstart = 0;
51242                s.block_start = 0;
51243                s.insert = 0;
51244              }
51245            }
51246          }
51247          flush_pending(strm);
51248          if (strm.avail_out === 0) {
51249            s.last_flush = -1;
51250            return Z_OK;
51251          }
51252        }
51253      }
51254      if (flush !== Z_FINISH) {
51255        return Z_OK;
51256      }
51257      if (s.wrap <= 0) {
51258        return Z_STREAM_END;
51259      }
51260      if (s.wrap === 2) {
51261        put_byte(s, strm.adler & 255);
51262        put_byte(s, strm.adler >> 8 & 255);
51263        put_byte(s, strm.adler >> 16 & 255);
51264        put_byte(s, strm.adler >> 24 & 255);
51265        put_byte(s, strm.total_in & 255);
51266        put_byte(s, strm.total_in >> 8 & 255);
51267        put_byte(s, strm.total_in >> 16 & 255);
51268        put_byte(s, strm.total_in >> 24 & 255);
51269      } else {
51270        putShortMSB(s, strm.adler >>> 16);
51271        putShortMSB(s, strm.adler & 65535);
51272      }
51273      flush_pending(strm);
51274      if (s.wrap > 0) {
51275        s.wrap = -s.wrap;
51276      }
51277      return s.pending !== 0 ? Z_OK : Z_STREAM_END;
51278    }
51279    function deflateEnd(strm) {
51280      var status;
51281      if (!strm || !strm.state) {
51282        return Z_STREAM_ERROR;
51283      }
51284      status = strm.state.status;
51285      if (status !== INIT_STATE && status !== EXTRA_STATE && status !== NAME_STATE && status !== COMMENT_STATE && status !== HCRC_STATE && status !== BUSY_STATE && status !== FINISH_STATE) {
51286        return err(strm, Z_STREAM_ERROR);
51287      }
51288      strm.state = null;
51289      return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;
51290    }
51291    function deflateSetDictionary(strm, dictionary) {
51292      var dictLength = dictionary.length;
51293      var s;
51294      var str, n;
51295      var wrap;
51296      var avail;
51297      var next;
51298      var input;
51299      var tmpDict;
51300      if (!strm || !strm.state) {
51301        return Z_STREAM_ERROR;
51302      }
51303      s = strm.state;
51304      wrap = s.wrap;
51305      if (wrap === 2 || wrap === 1 && s.status !== INIT_STATE || s.lookahead) {
51306        return Z_STREAM_ERROR;
51307      }
51308      if (wrap === 1) {
51309        strm.adler = adler32(strm.adler, dictionary, dictLength, 0);
51310      }
51311      s.wrap = 0;
51312      if (dictLength >= s.w_size) {
51313        if (wrap === 0) {
51314          zero(s.head);
51315          s.strstart = 0;
51316          s.block_start = 0;
51317          s.insert = 0;
51318        }
51319        tmpDict = new utils2.Buf8(s.w_size);
51320        utils2.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0);
51321        dictionary = tmpDict;
51322        dictLength = s.w_size;
51323      }
51324      avail = strm.avail_in;
51325      next = strm.next_in;
51326      input = strm.input;
51327      strm.avail_in = dictLength;
51328      strm.next_in = 0;
51329      strm.input = dictionary;
51330      fill_window(s);
51331      while (s.lookahead >= MIN_MATCH) {
51332        str = s.strstart;
51333        n = s.lookahead - (MIN_MATCH - 1);
51334        do {
51335          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask;
51336          s.prev[str & s.w_mask] = s.head[s.ins_h];
51337          s.head[s.ins_h] = str;
51338          str++;
51339        } while (--n);
51340        s.strstart = str;
51341        s.lookahead = MIN_MATCH - 1;
51342        fill_window(s);
51343      }
51344      s.strstart += s.lookahead;
51345      s.block_start = s.strstart;
51346      s.insert = s.lookahead;
51347      s.lookahead = 0;
51348      s.match_length = s.prev_length = MIN_MATCH - 1;
51349      s.match_available = 0;
51350      strm.next_in = next;
51351      strm.input = input;
51352      strm.avail_in = avail;
51353      s.wrap = wrap;
51354      return Z_OK;
51355    }
51356    deflate.deflateInit = deflateInit;
51357    deflate.deflateInit2 = deflateInit2;
51358    deflate.deflateReset = deflateReset;
51359    deflate.deflateResetKeep = deflateResetKeep;
51360    deflate.deflateSetHeader = deflateSetHeader;
51361    deflate.deflate = deflate$12;
51362    deflate.deflateEnd = deflateEnd;
51363    deflate.deflateSetDictionary = deflateSetDictionary;
51364    deflate.deflateInfo = "pako deflate (from Nodeca project)";
51365    return deflate;
51366  }
51367  var strings = {};
51368  var hasRequiredStrings;
51369  function requireStrings() {
51370    if (hasRequiredStrings) return strings;
51371    hasRequiredStrings = 1;
51372    var utils2 = requireCommon();
51373    var STR_APPLY_OK = true;
51374    var STR_APPLY_UIA_OK = true;
51375    try {
51376      String.fromCharCode.apply(null, [0]);
51377    } catch (__) {
51378      STR_APPLY_OK = false;
51379    }
51380    try {
51381      String.fromCharCode.apply(null, new Uint8Array(1));
51382    } catch (__) {
51383      STR_APPLY_UIA_OK = false;
51384    }
51385    var _utf8len = new utils2.Buf8(256);
51386    for (var q = 0; q < 256; q++) {
51387      _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;
51388    }
51389    _utf8len[254] = _utf8len[254] = 1;
51390    strings.string2buf = function(str) {
51391      var buf, c, c2, m_pos, i2, str_len = str.length, buf_len = 0;
51392      for (m_pos = 0; m_pos < str_len; m_pos++) {
51393        c = str.charCodeAt(m_pos);
51394        if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
51395          c2 = str.charCodeAt(m_pos + 1);
51396          if ((c2 & 64512) === 56320) {
51397            c = 65536 + (c - 55296 << 10) + (c2 - 56320);
51398            m_pos++;
51399          }
51400        }
51401        buf_len += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
51402      }
51403      buf = new utils2.Buf8(buf_len);
51404      for (i2 = 0, m_pos = 0; i2 < buf_len; m_pos++) {
51405        c = str.charCodeAt(m_pos);
51406        if ((c & 64512) === 55296 && m_pos + 1 < str_len) {
51407          c2 = str.charCodeAt(m_pos + 1);
51408          if ((c2 & 64512) === 56320) {
51409            c = 65536 + (c - 55296 << 10) + (c2 - 56320);
51410            m_pos++;
51411          }
51412        }
51413        if (c < 128) {
51414          buf[i2++] = c;
51415        } else if (c < 2048) {
51416          buf[i2++] = 192 | c >>> 6;
51417          buf[i2++] = 128 | c & 63;
51418        } else if (c < 65536) {
51419          buf[i2++] = 224 | c >>> 12;
51420          buf[i2++] = 128 | c >>> 6 & 63;
51421          buf[i2++] = 128 | c & 63;
51422        } else {
51423          buf[i2++] = 240 | c >>> 18;
51424          buf[i2++] = 128 | c >>> 12 & 63;
51425          buf[i2++] = 128 | c >>> 6 & 63;
51426          buf[i2++] = 128 | c & 63;
51427        }
51428      }
51429      return buf;
51430    };
51431    function buf2binstring(buf, len2) {
51432      if (len2 < 65534) {
51433        if (buf.subarray && STR_APPLY_UIA_OK || !buf.subarray && STR_APPLY_OK) {
51434          return String.fromCharCode.apply(null, utils2.shrinkBuf(buf, len2));
51435        }
51436      }
51437      var result = "";
51438      for (var i2 = 0; i2 < len2; i2++) {
51439        result += String.fromCharCode(buf[i2]);
51440      }
51441      return result;
51442    }
51443    strings.buf2binstring = function(buf) {
51444      return buf2binstring(buf, buf.length);
51445    };
51446    strings.binstring2buf = function(str) {
51447      var buf = new utils2.Buf8(str.length);
51448      for (var i2 = 0, len2 = buf.length; i2 < len2; i2++) {
51449        buf[i2] = str.charCodeAt(i2);
51450      }
51451      return buf;
51452    };
51453    strings.buf2string = function(buf, max2) {
51454      var i2, out, c, c_len;
51455      var len2 = max2 || buf.length;
51456      var utf16buf = new Array(len2 * 2);
51457      for (out = 0, i2 = 0; i2 < len2; ) {
51458        c = buf[i2++];
51459        if (c < 128) {
51460          utf16buf[out++] = c;
51461          continue;
51462        }
51463        c_len = _utf8len[c];
51464        if (c_len > 4) {
51465          utf16buf[out++] = 65533;
51466          i2 += c_len - 1;
51467          continue;
51468        }
51469        c &= c_len === 2 ? 31 : c_len === 3 ? 15 : 7;
51470        while (c_len > 1 && i2 < len2) {
51471          c = c << 6 | buf[i2++] & 63;
51472          c_len--;
51473        }
51474        if (c_len > 1) {
51475          utf16buf[out++] = 65533;
51476          continue;
51477        }
51478        if (c < 65536) {
51479          utf16buf[out++] = c;
51480        } else {
51481          c -= 65536;
51482          utf16buf[out++] = 55296 | c >> 10 & 1023;
51483          utf16buf[out++] = 56320 | c & 1023;
51484        }
51485      }
51486      return buf2binstring(utf16buf, out);
51487    };
51488    strings.utf8border = function(buf, max2) {
51489      var pos;
51490      max2 = max2 || buf.length;
51491      if (max2 > buf.length) {
51492        max2 = buf.length;
51493      }
51494      pos = max2 - 1;
51495      while (pos >= 0 && (buf[pos] & 192) === 128) {
51496        pos--;
51497      }
51498      if (pos < 0) {
51499        return max2;
51500      }
51501      if (pos === 0) {
51502        return max2;
51503      }
51504      return pos + _utf8len[buf[pos]] > max2 ? pos : max2;
51505    };
51506    return strings;
51507  }
51508  var zstream;
51509  var hasRequiredZstream;
51510  function requireZstream() {
51511    if (hasRequiredZstream) return zstream;
51512    hasRequiredZstream = 1;
51513    function ZStream() {
51514      this.input = null;
51515      this.next_in = 0;
51516      this.avail_in = 0;
51517      this.total_in = 0;
51518      this.output = null;
51519      this.next_out = 0;
51520      this.avail_out = 0;
51521      this.total_out = 0;
51522      this.msg = "";
51523      this.state = null;
51524      this.data_type = 2;
51525      this.adler = 0;
51526    }
51527    zstream = ZStream;
51528    return zstream;
51529  }
51530  var hasRequiredDeflate;
51531  function requireDeflate() {
51532    if (hasRequiredDeflate) return deflate$1;
51533    hasRequiredDeflate = 1;
51534    var zlib_deflate = requireDeflate$1();
51535    var utils2 = requireCommon();
51536    var strings2 = requireStrings();
51537    var msg = requireMessages();
51538    var ZStream = requireZstream();
51539    var toString2 = Object.prototype.toString;
51540    var Z_NO_FLUSH = 0;
51541    var Z_FINISH = 4;
51542    var Z_OK = 0;
51543    var Z_STREAM_END = 1;
51544    var Z_SYNC_FLUSH = 2;
51545    var Z_DEFAULT_COMPRESSION = -1;
51546    var Z_DEFAULT_STRATEGY = 0;
51547    var Z_DEFLATED = 8;
51548    function Deflate(options) {
51549      if (!(this instanceof Deflate)) return new Deflate(options);
51550      this.options = utils2.assign({
51551        level: Z_DEFAULT_COMPRESSION,
51552        method: Z_DEFLATED,
51553        chunkSize: 16384,
51554        windowBits: 15,
51555        memLevel: 8,
51556        strategy: Z_DEFAULT_STRATEGY,
51557        to: ""
51558      }, options || {});
51559      var opt = this.options;
51560      if (opt.raw && opt.windowBits > 0) {
51561        opt.windowBits = -opt.windowBits;
51562      } else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {
51563        opt.windowBits += 16;
51564      }
51565      this.err = 0;
51566      this.msg = "";
51567      this.ended = false;
51568      this.chunks = [];
51569      this.strm = new ZStream();
51570      this.strm.avail_out = 0;
51571      var status = zlib_deflate.deflateInit2(
51572        this.strm,
51573        opt.level,
51574        opt.method,
51575        opt.windowBits,
51576        opt.memLevel,
51577        opt.strategy
51578      );
51579      if (status !== Z_OK) {
51580        throw new Error(msg[status]);
51581      }
51582      if (opt.header) {
51583        zlib_deflate.deflateSetHeader(this.strm, opt.header);
51584      }
51585      if (opt.dictionary) {
51586        var dict;
51587        if (typeof opt.dictionary === "string") {
51588          dict = strings2.string2buf(opt.dictionary);
51589        } else if (toString2.call(opt.dictionary) === "[object ArrayBuffer]") {
51590          dict = new Uint8Array(opt.dictionary);
51591        } else {
51592          dict = opt.dictionary;
51593        }
51594        status = zlib_deflate.deflateSetDictionary(this.strm, dict);
51595        if (status !== Z_OK) {
51596          throw new Error(msg[status]);
51597        }
51598        this._dict_set = true;
51599      }
51600    }
51601    Deflate.prototype.push = function(data, mode) {
51602      var strm = this.strm;
51603      var chunkSize = this.options.chunkSize;
51604      var status, _mode;
51605      if (this.ended) {
51606        return false;
51607      }
51608      _mode = mode === ~~mode ? mode : mode === true ? Z_FINISH : Z_NO_FLUSH;
51609      if (typeof data === "string") {
51610        strm.input = strings2.string2buf(data);
51611      } else if (toString2.call(data) === "[object ArrayBuffer]") {
51612        strm.input = new Uint8Array(data);
51613      } else {
51614        strm.input = data;
51615      }
51616      strm.next_in = 0;
51617      strm.avail_in = strm.input.length;
51618      do {
51619        if (strm.avail_out === 0) {
51620          strm.output = new utils2.Buf8(chunkSize);
51621          strm.next_out = 0;
51622          strm.avail_out = chunkSize;
51623        }
51624        status = zlib_deflate.deflate(strm, _mode);
51625        if (status !== Z_STREAM_END && status !== Z_OK) {
51626          this.onEnd(status);
51627          this.ended = true;
51628          return false;
51629        }
51630        if (strm.avail_out === 0 || strm.avail_in === 0 && (_mode === Z_FINISH || _mode === Z_SYNC_FLUSH)) {
51631          if (this.options.to === "string") {
51632            this.onData(strings2.buf2binstring(utils2.shrinkBuf(strm.output, strm.next_out)));
51633          } else {
51634            this.onData(utils2.shrinkBuf(strm.output, strm.next_out));
51635          }
51636        }
51637      } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== Z_STREAM_END);
51638      if (_mode === Z_FINISH) {
51639        status = zlib_deflate.deflateEnd(this.strm);
51640        this.onEnd(status);
51641        this.ended = true;
51642        return status === Z_OK;
51643      }
51644      if (_mode === Z_SYNC_FLUSH) {
51645        this.onEnd(Z_OK);
51646        strm.avail_out = 0;
51647        return true;
51648      }
51649      return true;
51650    };
51651    Deflate.prototype.onData = function(chunk) {
51652      this.chunks.push(chunk);
51653    };
51654    Deflate.prototype.onEnd = function(status) {
51655      if (status === Z_OK) {
51656        if (this.options.to === "string") {
51657          this.result = this.chunks.join("");
51658        } else {
51659          this.result = utils2.flattenChunks(this.chunks);
51660        }
51661      }
51662      this.chunks = [];
51663      this.err = status;
51664      this.msg = this.strm.msg;
51665    };
51666    function deflate2(input, options) {

vendor: 4,201 bytes, lines 51667-51808

51667      var deflator = new Deflate(options);
51668      deflator.push(input, true);
51669      if (deflator.err) {
51670        throw deflator.msg || msg[deflator.err];
51671      }
51672      return deflator.result;
51673    }
51674    function deflateRaw(input, options) {
51675      options = options || {};
51676      options.raw = true;
51677      return deflate2(input, options);
51678    }
51679    function gzip(input, options) {
51680      options = options || {};
51681      options.gzip = true;
51682      return deflate2(input, options);
51683    }
51684    deflate$1.Deflate = Deflate;
51685    deflate$1.deflate = deflate2;
51686    deflate$1.deflateRaw = deflateRaw;
51687    deflate$1.gzip = gzip;
51688    return deflate$1;
51689  }
51690  var inflate$1 = {};
51691  var inflate = {};
51692  var inffast;
51693  var hasRequiredInffast;
51694  function requireInffast() {
51695    if (hasRequiredInffast) return inffast;
51696    hasRequiredInffast = 1;
51697    var BAD = 30;
51698    var TYPE = 12;
51699    inffast = function inflate_fast(strm, start) {
51700      var state2;
51701      var _in;
51702      var last;
51703      var _out;
51704      var beg;
51705      var end;
51706      var dmax;
51707      var wsize;
51708      var whave;
51709      var wnext;
51710      var s_window;
51711      var hold;
51712      var bits;
51713      var lcode;
51714      var dcode;
51715      var lmask;
51716      var dmask;
51717      var here;
51718      var op;
51719      var len2;
51720      var dist2;
51721      var from;
51722      var from_source;
51723      var input, output;
51724      state2 = strm.state;
51725      _in = strm.next_in;
51726      input = strm.input;
51727      last = _in + (strm.avail_in - 5);
51728      _out = strm.next_out;
51729      output = strm.output;
51730      beg = _out - (start - strm.avail_out);
51731      end = _out + (strm.avail_out - 257);
51732      dmax = state2.dmax;
51733      wsize = state2.wsize;
51734      whave = state2.whave;
51735      wnext = state2.wnext;
51736      s_window = state2.window;
51737      hold = state2.hold;
51738      bits = state2.bits;
51739      lcode = state2.lencode;
51740      dcode = state2.distcode;
51741      lmask = (1 << state2.lenbits) - 1;
51742      dmask = (1 << state2.distbits) - 1;
51743      top:
51744        do {
51745          if (bits < 15) {
51746            hold += input[_in++] << bits;
51747            bits += 8;
51748            hold += input[_in++] << bits;
51749            bits += 8;
51750          }
51751          here = lcode[hold & lmask];
51752          dolen:
51753            for (; ; ) {
51754              op = here >>> 24;
51755              hold >>>= op;
51756              bits -= op;
51757              op = here >>> 16 & 255;
51758              if (op === 0) {
51759                output[_out++] = here & 65535;
51760              } else if (op & 16) {
51761                len2 = here & 65535;
51762                op &= 15;
51763                if (op) {
51764                  if (bits < op) {
51765                    hold += input[_in++] << bits;
51766                    bits += 8;
51767                  }
51768                  len2 += hold & (1 << op) - 1;
51769                  hold >>>= op;
51770                  bits -= op;
51771                }
51772                if (bits < 15) {
51773                  hold += input[_in++] << bits;
51774                  bits += 8;
51775                  hold += input[_in++] << bits;
51776                  bits += 8;
51777                }
51778                here = dcode[hold & dmask];
51779                dodist:
51780                  for (; ; ) {
51781                    op = here >>> 24;
51782                    hold >>>= op;
51783                    bits -= op;
51784                    op = here >>> 16 & 255;
51785                    if (op & 16) {
51786                      dist2 = here & 65535;
51787                      op &= 15;
51788                      if (bits < op) {
51789                        hold += input[_in++] << bits;
51790                        bits += 8;
51791                        if (bits < op) {
51792                          hold += input[_in++] << bits;
51793                          bits += 8;
51794                        }
51795                      }
51796                      dist2 += hold & (1 << op) - 1;
51797                      if (dist2 > dmax) {
51798                        strm.msg = "invalid distance too far back";
51799                        state2.mode = BAD;
51800                        break top;
51801                      }
51802                      hold >>>= op;
51803                      bits -= op;
51804                      op = _out - beg;
51805                      if (dist2 > op) {
51806                        op = dist2 - op;
51807                        if (op > whave) {
51808                          if (state2.sane) {

vendor: 4,699 bytes, lines 51809-51926

51809                            strm.msg = "invalid distance too far back";
51810                            state2.mode = BAD;
51811                            break top;
51812                          }
51813                        }
51814                        from = 0;
51815                        from_source = s_window;
51816                        if (wnext === 0) {
51817                          from += wsize - op;
51818                          if (op < len2) {
51819                            len2 -= op;
51820                            do {
51821                              output[_out++] = s_window[from++];
51822                            } while (--op);
51823                            from = _out - dist2;
51824                            from_source = output;
51825                          }
51826                        } else if (wnext < op) {
51827                          from += wsize + wnext - op;
51828                          op -= wnext;
51829                          if (op < len2) {
51830                            len2 -= op;
51831                            do {
51832                              output[_out++] = s_window[from++];
51833                            } while (--op);
51834                            from = 0;
51835                            if (wnext < len2) {
51836                              op = wnext;
51837                              len2 -= op;
51838                              do {
51839                                output[_out++] = s_window[from++];
51840                              } while (--op);
51841                              from = _out - dist2;
51842                              from_source = output;
51843                            }
51844                          }
51845                        } else {
51846                          from += wnext - op;
51847                          if (op < len2) {
51848                            len2 -= op;
51849                            do {
51850                              output[_out++] = s_window[from++];
51851                            } while (--op);
51852                            from = _out - dist2;
51853                            from_source = output;
51854                          }
51855                        }
51856                        while (len2 > 2) {
51857                          output[_out++] = from_source[from++];
51858                          output[_out++] = from_source[from++];
51859                          output[_out++] = from_source[from++];
51860                          len2 -= 3;
51861                        }
51862                        if (len2) {
51863                          output[_out++] = from_source[from++];
51864                          if (len2 > 1) {
51865                            output[_out++] = from_source[from++];
51866                          }
51867                        }
51868                      } else {
51869                        from = _out - dist2;
51870                        do {
51871                          output[_out++] = output[from++];
51872                          output[_out++] = output[from++];
51873                          output[_out++] = output[from++];
51874                          len2 -= 3;
51875                        } while (len2 > 2);
51876                        if (len2) {
51877                          output[_out++] = output[from++];
51878                          if (len2 > 1) {
51879                            output[_out++] = output[from++];
51880                          }
51881                        }
51882                      }
51883                    } else if ((op & 64) === 0) {
51884                      here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
51885                      continue dodist;
51886                    } else {
51887                      strm.msg = "invalid distance code";
51888                      state2.mode = BAD;
51889                      break top;
51890                    }
51891                    break;
51892                  }
51893              } else if ((op & 64) === 0) {
51894                here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
51895                continue dolen;
51896              } else if (op & 32) {
51897                state2.mode = TYPE;
51898                break top;
51899              } else {
51900                strm.msg = "invalid literal/length code";
51901                state2.mode = BAD;
51902                break top;
51903              }
51904              break;
51905            }
51906        } while (_in < last && _out < end);
51907      len2 = bits >> 3;
51908      _in -= len2;
51909      bits -= len2 << 3;
51910      hold &= (1 << bits) - 1;
51911      strm.next_in = _in;
51912      strm.next_out = _out;
51913      strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
51914      strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
51915      state2.hold = hold;
51916      state2.bits = bits;
51917      return;
51918    };
51919    return inffast;
51920  }
51921  var inftrees;
51922  var hasRequiredInftrees;
51923  function requireInftrees() {
51924    if (hasRequiredInftrees) return inftrees;
51925    hasRequiredInftrees = 1;
51926    var utils2 = requireCommon();

vendor: 4,628 bytes, lines 51927-52185

51927    var MAXBITS = 15;
51928    var ENOUGH_LENS = 852;
51929    var ENOUGH_DISTS = 592;
51930    var CODES = 0;
51931    var LENS = 1;
51932    var DISTS = 2;
51933    var lbase = [
51934      /* Length codes 257..285 base */
51935      3,
51936      4,
51937      5,
51938      6,
51939      7,
51940      8,
51941      9,
51942      10,
51943      11,
51944      13,
51945      15,
51946      17,
51947      19,
51948      23,
51949      27,
51950      31,
51951      35,
51952      43,
51953      51,
51954      59,
51955      67,
51956      83,
51957      99,
51958      115,
51959      131,
51960      163,
51961      195,
51962      227,
51963      258,
51964      0,
51965      0
51966    ];
51967    var lext = [
51968      /* Length codes 257..285 extra */
51969      16,
51970      16,
51971      16,
51972      16,
51973      16,
51974      16,
51975      16,
51976      16,
51977      17,
51978      17,
51979      17,
51980      17,
51981      18,
51982      18,
51983      18,
51984      18,
51985      19,
51986      19,
51987      19,
51988      19,
51989      20,
51990      20,
51991      20,
51992      20,
51993      21,
51994      21,
51995      21,
51996      21,
51997      16,
51998      72,
51999      78
52000    ];
52001    var dbase = [
52002      /* Distance codes 0..29 base */
52003      1,
52004      2,
52005      3,
52006      4,
52007      5,
52008      7,
52009      9,
52010      13,
52011      17,
52012      25,
52013      33,
52014      49,
52015      65,
52016      97,
52017      129,
52018      193,
52019      257,
52020      385,
52021      513,
52022      769,
52023      1025,
52024      1537,
52025      2049,
52026      3073,
52027      4097,
52028      6145,
52029      8193,
52030      12289,
52031      16385,
52032      24577,
52033      0,
52034      0
52035    ];
52036    var dext = [
52037      /* Distance codes 0..29 extra */
52038      16,
52039      16,
52040      16,
52041      16,
52042      17,
52043      17,
52044      18,
52045      18,
52046      19,
52047      19,
52048      20,
52049      20,
52050      21,
52051      21,
52052      22,
52053      22,
52054      23,
52055      23,
52056      24,
52057      24,
52058      25,
52059      25,
52060      26,
52061      26,
52062      27,
52063      27,
52064      28,
52065      28,
52066      29,
52067      29,
52068      64,
52069      64
52070    ];
52071    inftrees = function inflate_table(type2, lens, lens_index, codes, table, table_index, work, opts) {
52072      var bits = opts.bits;
52073      var len2 = 0;
52074      var sym = 0;
52075      var min2 = 0, max2 = 0;
52076      var root = 0;
52077      var curr = 0;
52078      var drop = 0;
52079      var left = 0;
52080      var used = 0;
52081      var huff = 0;
52082      var incr;
52083      var fill;
52084      var low;
52085      var mask;
52086      var next;
52087      var base2 = null;
52088      var base_index = 0;
52089      var end;
52090      var count = new utils2.Buf16(MAXBITS + 1);
52091      var offs = new utils2.Buf16(MAXBITS + 1);
52092      var extra = null;
52093      var extra_index = 0;
52094      var here_bits, here_op, here_val;
52095      for (len2 = 0; len2 <= MAXBITS; len2++) {
52096        count[len2] = 0;
52097      }
52098      for (sym = 0; sym < codes; sym++) {
52099        count[lens[lens_index + sym]]++;
52100      }
52101      root = bits;
52102      for (max2 = MAXBITS; max2 >= 1; max2--) {
52103        if (count[max2] !== 0) {
52104          break;
52105        }
52106      }
52107      if (root > max2) {
52108        root = max2;
52109      }
52110      if (max2 === 0) {
52111        table[table_index++] = 1 << 24 | 64 << 16 | 0;
52112        table[table_index++] = 1 << 24 | 64 << 16 | 0;
52113        opts.bits = 1;
52114        return 0;
52115      }
52116      for (min2 = 1; min2 < max2; min2++) {
52117        if (count[min2] !== 0) {
52118          break;
52119        }
52120      }
52121      if (root < min2) {
52122        root = min2;
52123      }
52124      left = 1;
52125      for (len2 = 1; len2 <= MAXBITS; len2++) {
52126        left <<= 1;
52127        left -= count[len2];
52128        if (left < 0) {
52129          return -1;
52130        }
52131      }
52132      if (left > 0 && (type2 === CODES || max2 !== 1)) {
52133        return -1;
52134      }
52135      offs[1] = 0;
52136      for (len2 = 1; len2 < MAXBITS; len2++) {
52137        offs[len2 + 1] = offs[len2] + count[len2];
52138      }
52139      for (sym = 0; sym < codes; sym++) {
52140        if (lens[lens_index + sym] !== 0) {
52141          work[offs[lens[lens_index + sym]]++] = sym;
52142        }
52143      }
52144      if (type2 === CODES) {
52145        base2 = extra = work;
52146        end = 19;
52147      } else if (type2 === LENS) {
52148        base2 = lbase;
52149        base_index -= 257;
52150        extra = lext;
52151        extra_index -= 257;
52152        end = 256;
52153      } else {
52154        base2 = dbase;
52155        extra = dext;
52156        end = -1;
52157      }
52158      huff = 0;
52159      sym = 0;
52160      len2 = min2;
52161      next = table_index;
52162      curr = root;
52163      drop = 0;
52164      low = -1;
52165      used = 1 << root;
52166      mask = used - 1;
52167      if (type2 === LENS && used > ENOUGH_LENS || type2 === DISTS && used > ENOUGH_DISTS) {
52168        return 1;
52169      }
52170      for (; ; ) {
52171        here_bits = len2 - drop;
52172        if (work[sym] < end) {
52173          here_op = 0;
52174          here_val = work[sym];
52175        } else if (work[sym] > end) {
52176          here_op = extra[extra_index + work[sym]];
52177          here_val = base2[base_index + work[sym]];
52178        } else {
52179          here_op = 32 + 64;
52180          here_val = 0;
52181        }
52182        incr = 1 << len2 - drop;
52183        fill = 1 << curr;
52184        min2 = fill;
52185        do {

vendor: 6,648 bytes, lines 52186-52441

52186          fill -= incr;
52187          table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
52188        } while (fill !== 0);
52189        incr = 1 << len2 - 1;
52190        while (huff & incr) {
52191          incr >>= 1;
52192        }
52193        if (incr !== 0) {
52194          huff &= incr - 1;
52195          huff += incr;
52196        } else {
52197          huff = 0;
52198        }
52199        sym++;
52200        if (--count[len2] === 0) {
52201          if (len2 === max2) {
52202            break;
52203          }
52204          len2 = lens[lens_index + work[sym]];
52205        }
52206        if (len2 > root && (huff & mask) !== low) {
52207          if (drop === 0) {
52208            drop = root;
52209          }
52210          next += min2;
52211          curr = len2 - drop;
52212          left = 1 << curr;
52213          while (curr + drop < max2) {
52214            left -= count[curr + drop];
52215            if (left <= 0) {
52216              break;
52217            }
52218            curr++;
52219            left <<= 1;
52220          }
52221          used += 1 << curr;
52222          if (type2 === LENS && used > ENOUGH_LENS || type2 === DISTS && used > ENOUGH_DISTS) {
52223            return 1;
52224          }
52225          low = huff & mask;
52226          table[low] = root << 24 | curr << 16 | next - table_index | 0;
52227        }
52228      }
52229      if (huff !== 0) {
52230        table[next + huff] = len2 - drop << 24 | 64 << 16 | 0;
52231      }
52232      opts.bits = root;
52233      return 0;
52234    };
52235    return inftrees;
52236  }
52237  var hasRequiredInflate$1;
52238  function requireInflate$1() {
52239    if (hasRequiredInflate$1) return inflate;
52240    hasRequiredInflate$1 = 1;
52241    var utils2 = requireCommon();
52242    var adler32 = requireAdler32();
52243    var crc32 = requireCrc32();
52244    var inflate_fast = requireInffast();
52245    var inflate_table = requireInftrees();
52246    var CODES = 0;
52247    var LENS = 1;
52248    var DISTS = 2;
52249    var Z_FINISH = 4;
52250    var Z_BLOCK = 5;
52251    var Z_TREES = 6;
52252    var Z_OK = 0;
52253    var Z_STREAM_END = 1;
52254    var Z_NEED_DICT = 2;
52255    var Z_STREAM_ERROR = -2;
52256    var Z_DATA_ERROR = -3;
52257    var Z_MEM_ERROR = -4;
52258    var Z_BUF_ERROR = -5;
52259    var Z_DEFLATED = 8;
52260    var HEAD = 1;
52261    var FLAGS = 2;
52262    var TIME = 3;
52263    var OS = 4;
52264    var EXLEN = 5;
52265    var EXTRA = 6;
52266    var NAME = 7;
52267    var COMMENT = 8;
52268    var HCRC = 9;
52269    var DICTID = 10;
52270    var DICT = 11;
52271    var TYPE = 12;
52272    var TYPEDO = 13;
52273    var STORED = 14;
52274    var COPY_ = 15;
52275    var COPY = 16;
52276    var TABLE = 17;
52277    var LENLENS = 18;
52278    var CODELENS = 19;
52279    var LEN_ = 20;
52280    var LEN = 21;
52281    var LENEXT = 22;
52282    var DIST = 23;
52283    var DISTEXT = 24;
52284    var MATCH = 25;
52285    var LIT = 26;
52286    var CHECK = 27;
52287    var LENGTH = 28;
52288    var DONE = 29;
52289    var BAD = 30;
52290    var MEM = 31;
52291    var SYNC = 32;
52292    var ENOUGH_LENS = 852;
52293    var ENOUGH_DISTS = 592;
52294    var MAX_WBITS = 15;
52295    var DEF_WBITS = MAX_WBITS;
52296    function zswap32(q) {
52297      return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
52298    }
52299    function InflateState() {
52300      this.mode = 0;
52301      this.last = false;
52302      this.wrap = 0;
52303      this.havedict = false;
52304      this.flags = 0;
52305      this.dmax = 0;
52306      this.check = 0;
52307      this.total = 0;
52308      this.head = null;
52309      this.wbits = 0;
52310      this.wsize = 0;
52311      this.whave = 0;
52312      this.wnext = 0;
52313      this.window = null;
52314      this.hold = 0;
52315      this.bits = 0;
52316      this.length = 0;
52317      this.offset = 0;
52318      this.extra = 0;
52319      this.lencode = null;
52320      this.distcode = null;
52321      this.lenbits = 0;
52322      this.distbits = 0;
52323      this.ncode = 0;
52324      this.nlen = 0;
52325      this.ndist = 0;
52326      this.have = 0;
52327      this.next = null;
52328      this.lens = new utils2.Buf16(320);
52329      this.work = new utils2.Buf16(288);
52330      this.lendyn = null;
52331      this.distdyn = null;
52332      this.sane = 0;
52333      this.back = 0;
52334      this.was = 0;
52335    }
52336    function inflateResetKeep(strm) {
52337      var state2;
52338      if (!strm || !strm.state) {
52339        return Z_STREAM_ERROR;
52340      }
52341      state2 = strm.state;
52342      strm.total_in = strm.total_out = state2.total = 0;
52343      strm.msg = "";
52344      if (state2.wrap) {
52345        strm.adler = state2.wrap & 1;
52346      }
52347      state2.mode = HEAD;
52348      state2.last = 0;
52349      state2.havedict = 0;
52350      state2.dmax = 32768;
52351      state2.head = null;
52352      state2.hold = 0;
52353      state2.bits = 0;
52354      state2.lencode = state2.lendyn = new utils2.Buf32(ENOUGH_LENS);
52355      state2.distcode = state2.distdyn = new utils2.Buf32(ENOUGH_DISTS);
52356      state2.sane = 1;
52357      state2.back = -1;
52358      return Z_OK;
52359    }
52360    function inflateReset(strm) {
52361      var state2;
52362      if (!strm || !strm.state) {
52363        return Z_STREAM_ERROR;
52364      }
52365      state2 = strm.state;
52366      state2.wsize = 0;
52367      state2.whave = 0;
52368      state2.wnext = 0;
52369      return inflateResetKeep(strm);
52370    }
52371    function inflateReset2(strm, windowBits) {
52372      var wrap;
52373      var state2;
52374      if (!strm || !strm.state) {
52375        return Z_STREAM_ERROR;
52376      }
52377      state2 = strm.state;
52378      if (windowBits < 0) {
52379        wrap = 0;
52380        windowBits = -windowBits;
52381      } else {
52382        wrap = (windowBits >> 4) + 1;
52383        if (windowBits < 48) {
52384          windowBits &= 15;
52385        }
52386      }
52387      if (windowBits && (windowBits < 8 || windowBits > 15)) {
52388        return Z_STREAM_ERROR;
52389      }
52390      if (state2.window !== null && state2.wbits !== windowBits) {
52391        state2.window = null;
52392      }
52393      state2.wrap = wrap;
52394      state2.wbits = windowBits;
52395      return inflateReset(strm);
52396    }
52397    function inflateInit2(strm, windowBits) {
52398      var ret;
52399      var state2;
52400      if (!strm) {
52401        return Z_STREAM_ERROR;
52402      }
52403      state2 = new InflateState();
52404      strm.state = state2;
52405      state2.window = null;
52406      ret = inflateReset2(strm, windowBits);
52407      if (ret !== Z_OK) {
52408        strm.state = null;
52409      }
52410      return ret;
52411    }
52412    function inflateInit(strm) {
52413      return inflateInit2(strm, DEF_WBITS);
52414    }
52415    var virgin = true;
52416    var lenfix, distfix;
52417    function fixedtables(state2) {
52418      if (virgin) {
52419        var sym;
52420        lenfix = new utils2.Buf32(512);
52421        distfix = new utils2.Buf32(32);
52422        sym = 0;
52423        while (sym < 144) {
52424          state2.lens[sym++] = 8;
52425        }
52426        while (sym < 256) {
52427          state2.lens[sym++] = 9;
52428        }
52429        while (sym < 280) {
52430          state2.lens[sym++] = 7;
52431        }
52432        while (sym < 288) {
52433          state2.lens[sym++] = 8;
52434        }
52435        inflate_table(LENS, state2.lens, 0, 288, lenfix, 0, state2.work, { bits: 9 });
52436        sym = 0;
52437        while (sym < 32) {
52438          state2.lens[sym++] = 5;
52439        }
52440        inflate_table(DISTS, state2.lens, 0, 32, distfix, 0, state2.work, { bits: 5 });
52441        virgin = false;

vendor: 18,754 bytes, lines 52442-53011

52442      }
52443      state2.lencode = lenfix;
52444      state2.lenbits = 9;
52445      state2.distcode = distfix;
52446      state2.distbits = 5;
52447    }
52448    function updatewindow(strm, src2, end, copy) {
52449      var dist2;
52450      var state2 = strm.state;
52451      if (state2.window === null) {
52452        state2.wsize = 1 << state2.wbits;
52453        state2.wnext = 0;
52454        state2.whave = 0;
52455        state2.window = new utils2.Buf8(state2.wsize);
52456      }
52457      if (copy >= state2.wsize) {
52458        utils2.arraySet(state2.window, src2, end - state2.wsize, state2.wsize, 0);
52459        state2.wnext = 0;
52460        state2.whave = state2.wsize;
52461      } else {
52462        dist2 = state2.wsize - state2.wnext;
52463        if (dist2 > copy) {
52464          dist2 = copy;
52465        }
52466        utils2.arraySet(state2.window, src2, end - copy, dist2, state2.wnext);
52467        copy -= dist2;
52468        if (copy) {
52469          utils2.arraySet(state2.window, src2, end - copy, copy, 0);
52470          state2.wnext = copy;
52471          state2.whave = state2.wsize;
52472        } else {
52473          state2.wnext += dist2;
52474          if (state2.wnext === state2.wsize) {
52475            state2.wnext = 0;
52476          }
52477          if (state2.whave < state2.wsize) {
52478            state2.whave += dist2;
52479          }
52480        }
52481      }
52482      return 0;
52483    }
52484    function inflate$12(strm, flush) {
52485      var state2;
52486      var input, output;
52487      var next;
52488      var put;
52489      var have, left;
52490      var hold;
52491      var bits;
52492      var _in, _out;
52493      var copy;
52494      var from;
52495      var from_source;
52496      var here = 0;
52497      var here_bits, here_op, here_val;
52498      var last_bits, last_op, last_val;
52499      var len2;
52500      var ret;
52501      var hbuf = new utils2.Buf8(4);
52502      var opts;
52503      var n;
52504      var order = (
52505        /* permutation of code lengths */
52506        [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
52507      );
52508      if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
52509        return Z_STREAM_ERROR;
52510      }
52511      state2 = strm.state;
52512      if (state2.mode === TYPE) {
52513        state2.mode = TYPEDO;
52514      }
52515      put = strm.next_out;
52516      output = strm.output;
52517      left = strm.avail_out;
52518      next = strm.next_in;
52519      input = strm.input;
52520      have = strm.avail_in;
52521      hold = state2.hold;
52522      bits = state2.bits;
52523      _in = have;
52524      _out = left;
52525      ret = Z_OK;
52526      inf_leave:
52527        for (; ; ) {
52528          switch (state2.mode) {
52529            case HEAD:
52530              if (state2.wrap === 0) {
52531                state2.mode = TYPEDO;
52532                break;
52533              }
52534              while (bits < 16) {
52535                if (have === 0) {
52536                  break inf_leave;
52537                }
52538                have--;
52539                hold += input[next++] << bits;
52540                bits += 8;
52541              }
52542              if (state2.wrap & 2 && hold === 35615) {
52543                state2.check = 0;
52544                hbuf[0] = hold & 255;
52545                hbuf[1] = hold >>> 8 & 255;
52546                state2.check = crc32(state2.check, hbuf, 2, 0);
52547                hold = 0;
52548                bits = 0;
52549                state2.mode = FLAGS;
52550                break;
52551              }
52552              state2.flags = 0;
52553              if (state2.head) {
52554                state2.head.done = false;
52555              }
52556              if (!(state2.wrap & 1) || /* check if zlib header allowed */
52557              (((hold & 255) << 8) + (hold >> 8)) % 31) {
52558                strm.msg = "incorrect header check";
52559                state2.mode = BAD;
52560                break;
52561              }
52562              if ((hold & 15) !== Z_DEFLATED) {
52563                strm.msg = "unknown compression method";
52564                state2.mode = BAD;
52565                break;
52566              }
52567              hold >>>= 4;
52568              bits -= 4;
52569              len2 = (hold & 15) + 8;
52570              if (state2.wbits === 0) {
52571                state2.wbits = len2;
52572              } else if (len2 > state2.wbits) {
52573                strm.msg = "invalid window size";
52574                state2.mode = BAD;
52575                break;
52576              }
52577              state2.dmax = 1 << len2;
52578              strm.adler = state2.check = 1;
52579              state2.mode = hold & 512 ? DICTID : TYPE;
52580              hold = 0;
52581              bits = 0;
52582              break;
52583            case FLAGS:
52584              while (bits < 16) {
52585                if (have === 0) {
52586                  break inf_leave;
52587                }
52588                have--;
52589                hold += input[next++] << bits;
52590                bits += 8;
52591              }
52592              state2.flags = hold;
52593              if ((state2.flags & 255) !== Z_DEFLATED) {
52594                strm.msg = "unknown compression method";
52595                state2.mode = BAD;
52596                break;
52597              }
52598              if (state2.flags & 57344) {
52599                strm.msg = "unknown header flags set";
52600                state2.mode = BAD;
52601                break;
52602              }
52603              if (state2.head) {
52604                state2.head.text = hold >> 8 & 1;
52605              }
52606              if (state2.flags & 512) {
52607                hbuf[0] = hold & 255;
52608                hbuf[1] = hold >>> 8 & 255;
52609                state2.check = crc32(state2.check, hbuf, 2, 0);
52610              }
52611              hold = 0;
52612              bits = 0;
52613              state2.mode = TIME;
52614            /* falls through */
52615            case TIME:
52616              while (bits < 32) {
52617                if (have === 0) {
52618                  break inf_leave;
52619                }
52620                have--;
52621                hold += input[next++] << bits;
52622                bits += 8;
52623              }
52624              if (state2.head) {
52625                state2.head.time = hold;
52626              }
52627              if (state2.flags & 512) {
52628                hbuf[0] = hold & 255;
52629                hbuf[1] = hold >>> 8 & 255;
52630                hbuf[2] = hold >>> 16 & 255;
52631                hbuf[3] = hold >>> 24 & 255;
52632                state2.check = crc32(state2.check, hbuf, 4, 0);
52633              }
52634              hold = 0;
52635              bits = 0;
52636              state2.mode = OS;
52637            /* falls through */
52638            case OS:
52639              while (bits < 16) {
52640                if (have === 0) {
52641                  break inf_leave;
52642                }
52643                have--;
52644                hold += input[next++] << bits;
52645                bits += 8;
52646              }
52647              if (state2.head) {
52648                state2.head.xflags = hold & 255;
52649                state2.head.os = hold >> 8;
52650              }
52651              if (state2.flags & 512) {
52652                hbuf[0] = hold & 255;
52653                hbuf[1] = hold >>> 8 & 255;
52654                state2.check = crc32(state2.check, hbuf, 2, 0);
52655              }
52656              hold = 0;
52657              bits = 0;
52658              state2.mode = EXLEN;
52659            /* falls through */
52660            case EXLEN:
52661              if (state2.flags & 1024) {
52662                while (bits < 16) {
52663                  if (have === 0) {
52664                    break inf_leave;
52665                  }
52666                  have--;
52667                  hold += input[next++] << bits;
52668                  bits += 8;
52669                }
52670                state2.length = hold;
52671                if (state2.head) {
52672                  state2.head.extra_len = hold;
52673                }
52674                if (state2.flags & 512) {
52675                  hbuf[0] = hold & 255;
52676                  hbuf[1] = hold >>> 8 & 255;
52677                  state2.check = crc32(state2.check, hbuf, 2, 0);
52678                }
52679                hold = 0;
52680                bits = 0;
52681              } else if (state2.head) {
52682                state2.head.extra = null;
52683              }
52684              state2.mode = EXTRA;
52685            /* falls through */
52686            case EXTRA:
52687              if (state2.flags & 1024) {
52688                copy = state2.length;
52689                if (copy > have) {
52690                  copy = have;
52691                }
52692                if (copy) {
52693                  if (state2.head) {
52694                    len2 = state2.head.extra_len - state2.length;
52695                    if (!state2.head.extra) {
52696                      state2.head.extra = new Array(state2.head.extra_len);
52697                    }
52698                    utils2.arraySet(
52699                      state2.head.extra,
52700                      input,
52701                      next,
52702                      // extra field is limited to 65536 bytes
52703                      // - no need for additional size check
52704                      copy,
52705                      /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
52706                      len2
52707                    );
52708                  }
52709                  if (state2.flags & 512) {
52710                    state2.check = crc32(state2.check, input, copy, next);
52711                  }
52712                  have -= copy;
52713                  next += copy;
52714                  state2.length -= copy;
52715                }
52716                if (state2.length) {
52717                  break inf_leave;
52718                }
52719              }
52720              state2.length = 0;
52721              state2.mode = NAME;
52722            /* falls through */
52723            case NAME:
52724              if (state2.flags & 2048) {
52725                if (have === 0) {
52726                  break inf_leave;
52727                }
52728                copy = 0;
52729                do {
52730                  len2 = input[next + copy++];
52731                  if (state2.head && len2 && state2.length < 65536) {
52732                    state2.head.name += String.fromCharCode(len2);
52733                  }
52734                } while (len2 && copy < have);
52735                if (state2.flags & 512) {
52736                  state2.check = crc32(state2.check, input, copy, next);
52737                }
52738                have -= copy;
52739                next += copy;
52740                if (len2) {
52741                  break inf_leave;
52742                }
52743              } else if (state2.head) {
52744                state2.head.name = null;
52745              }
52746              state2.length = 0;
52747              state2.mode = COMMENT;
52748            /* falls through */
52749            case COMMENT:
52750              if (state2.flags & 4096) {
52751                if (have === 0) {
52752                  break inf_leave;
52753                }
52754                copy = 0;
52755                do {
52756                  len2 = input[next + copy++];
52757                  if (state2.head && len2 && state2.length < 65536) {
52758                    state2.head.comment += String.fromCharCode(len2);
52759                  }
52760                } while (len2 && copy < have);
52761                if (state2.flags & 512) {
52762                  state2.check = crc32(state2.check, input, copy, next);
52763                }
52764                have -= copy;
52765                next += copy;
52766                if (len2) {
52767                  break inf_leave;
52768                }
52769              } else if (state2.head) {
52770                state2.head.comment = null;
52771              }
52772              state2.mode = HCRC;
52773            /* falls through */
52774            case HCRC:
52775              if (state2.flags & 512) {
52776                while (bits < 16) {
52777                  if (have === 0) {
52778                    break inf_leave;
52779                  }
52780                  have--;
52781                  hold += input[next++] << bits;
52782                  bits += 8;
52783                }
52784                if (hold !== (state2.check & 65535)) {
52785                  strm.msg = "header crc mismatch";
52786                  state2.mode = BAD;
52787                  break;
52788                }
52789                hold = 0;
52790                bits = 0;
52791              }
52792              if (state2.head) {
52793                state2.head.hcrc = state2.flags >> 9 & 1;
52794                state2.head.done = true;
52795              }
52796              strm.adler = state2.check = 0;
52797              state2.mode = TYPE;
52798              break;
52799            case DICTID:
52800              while (bits < 32) {
52801                if (have === 0) {
52802                  break inf_leave;
52803                }
52804                have--;
52805                hold += input[next++] << bits;
52806                bits += 8;
52807              }
52808              strm.adler = state2.check = zswap32(hold);
52809              hold = 0;
52810              bits = 0;
52811              state2.mode = DICT;
52812            /* falls through */
52813            case DICT:
52814              if (state2.havedict === 0) {
52815                strm.next_out = put;
52816                strm.avail_out = left;
52817                strm.next_in = next;
52818                strm.avail_in = have;
52819                state2.hold = hold;
52820                state2.bits = bits;
52821                return Z_NEED_DICT;
52822              }
52823              strm.adler = state2.check = 1;
52824              state2.mode = TYPE;
52825            /* falls through */
52826            case TYPE:
52827              if (flush === Z_BLOCK || flush === Z_TREES) {
52828                break inf_leave;
52829              }
52830            /* falls through */
52831            case TYPEDO:
52832              if (state2.last) {
52833                hold >>>= bits & 7;
52834                bits -= bits & 7;
52835                state2.mode = CHECK;
52836                break;
52837              }
52838              while (bits < 3) {
52839                if (have === 0) {
52840                  break inf_leave;
52841                }
52842                have--;
52843                hold += input[next++] << bits;
52844                bits += 8;
52845              }
52846              state2.last = hold & 1;
52847              hold >>>= 1;
52848              bits -= 1;
52849              switch (hold & 3) {
52850                case 0:
52851                  state2.mode = STORED;
52852                  break;
52853                case 1:
52854                  fixedtables(state2);
52855                  state2.mode = LEN_;
52856                  if (flush === Z_TREES) {
52857                    hold >>>= 2;
52858                    bits -= 2;
52859                    break inf_leave;
52860                  }
52861                  break;
52862                case 2:
52863                  state2.mode = TABLE;
52864                  break;
52865                case 3:
52866                  strm.msg = "invalid block type";
52867                  state2.mode = BAD;
52868              }
52869              hold >>>= 2;
52870              bits -= 2;
52871              break;
52872            case STORED:
52873              hold >>>= bits & 7;
52874              bits -= bits & 7;
52875              while (bits < 32) {
52876                if (have === 0) {
52877                  break inf_leave;
52878                }
52879                have--;
52880                hold += input[next++] << bits;
52881                bits += 8;
52882              }
52883              if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
52884                strm.msg = "invalid stored block lengths";
52885                state2.mode = BAD;
52886                break;
52887              }
52888              state2.length = hold & 65535;
52889              hold = 0;
52890              bits = 0;
52891              state2.mode = COPY_;
52892              if (flush === Z_TREES) {
52893                break inf_leave;
52894              }
52895            /* falls through */
52896            case COPY_:
52897              state2.mode = COPY;
52898            /* falls through */
52899            case COPY:
52900              copy = state2.length;
52901              if (copy) {
52902                if (copy > have) {
52903                  copy = have;
52904                }
52905                if (copy > left) {
52906                  copy = left;
52907                }
52908                if (copy === 0) {
52909                  break inf_leave;
52910                }
52911                utils2.arraySet(output, input, next, copy, put);
52912                have -= copy;
52913                next += copy;
52914                left -= copy;
52915                put += copy;
52916                state2.length -= copy;
52917                break;
52918              }
52919              state2.mode = TYPE;
52920              break;
52921            case TABLE:
52922              while (bits < 14) {
52923                if (have === 0) {
52924                  break inf_leave;
52925                }
52926                have--;
52927                hold += input[next++] << bits;
52928                bits += 8;
52929              }
52930              state2.nlen = (hold & 31) + 257;
52931              hold >>>= 5;
52932              bits -= 5;
52933              state2.ndist = (hold & 31) + 1;
52934              hold >>>= 5;
52935              bits -= 5;
52936              state2.ncode = (hold & 15) + 4;
52937              hold >>>= 4;
52938              bits -= 4;
52939              if (state2.nlen > 286 || state2.ndist > 30) {
52940                strm.msg = "too many length or distance symbols";
52941                state2.mode = BAD;
52942                break;
52943              }
52944              state2.have = 0;
52945              state2.mode = LENLENS;
52946            /* falls through */
52947            case LENLENS:
52948              while (state2.have < state2.ncode) {
52949                while (bits < 3) {
52950                  if (have === 0) {
52951                    break inf_leave;
52952                  }
52953                  have--;
52954                  hold += input[next++] << bits;
52955                  bits += 8;
52956                }
52957                state2.lens[order[state2.have++]] = hold & 7;
52958                hold >>>= 3;
52959                bits -= 3;
52960              }
52961              while (state2.have < 19) {
52962                state2.lens[order[state2.have++]] = 0;
52963              }
52964              state2.lencode = state2.lendyn;
52965              state2.lenbits = 7;
52966              opts = { bits: state2.lenbits };
52967              ret = inflate_table(CODES, state2.lens, 0, 19, state2.lencode, 0, state2.work, opts);
52968              state2.lenbits = opts.bits;
52969              if (ret) {
52970                strm.msg = "invalid code lengths set";
52971                state2.mode = BAD;
52972                break;
52973              }
52974              state2.have = 0;
52975              state2.mode = CODELENS;
52976            /* falls through */
52977            case CODELENS:
52978              while (state2.have < state2.nlen + state2.ndist) {
52979                for (; ; ) {
52980                  here = state2.lencode[hold & (1 << state2.lenbits) - 1];
52981                  here_bits = here >>> 24;
52982                  here_op = here >>> 16 & 255;
52983                  here_val = here & 65535;
52984                  if (here_bits <= bits) {
52985                    break;
52986                  }
52987                  if (have === 0) {
52988                    break inf_leave;
52989                  }
52990                  have--;
52991                  hold += input[next++] << bits;
52992                  bits += 8;
52993                }
52994                if (here_val < 16) {
52995                  hold >>>= here_bits;
52996                  bits -= here_bits;
52997                  state2.lens[state2.have++] = here_val;
52998                } else {
52999                  if (here_val === 16) {
53000                    n = here_bits + 2;
53001                    while (bits < n) {
53002                      if (have === 0) {
53003                        break inf_leave;
53004                      }
53005                      have--;
53006                      hold += input[next++] << bits;
53007                      bits += 8;
53008                    }
53009                    hold >>>= here_bits;
53010                    bits -= here_bits;
53011                    if (state2.have === 0) {

vendor: 5,822 bytes, lines 53012-53172

53012                      strm.msg = "invalid bit length repeat";
53013                      state2.mode = BAD;
53014                      break;
53015                    }
53016                    len2 = state2.lens[state2.have - 1];
53017                    copy = 3 + (hold & 3);
53018                    hold >>>= 2;
53019                    bits -= 2;
53020                  } else if (here_val === 17) {
53021                    n = here_bits + 3;
53022                    while (bits < n) {
53023                      if (have === 0) {
53024                        break inf_leave;
53025                      }
53026                      have--;
53027                      hold += input[next++] << bits;
53028                      bits += 8;
53029                    }
53030                    hold >>>= here_bits;
53031                    bits -= here_bits;
53032                    len2 = 0;
53033                    copy = 3 + (hold & 7);
53034                    hold >>>= 3;
53035                    bits -= 3;
53036                  } else {
53037                    n = here_bits + 7;
53038                    while (bits < n) {
53039                      if (have === 0) {
53040                        break inf_leave;
53041                      }
53042                      have--;
53043                      hold += input[next++] << bits;
53044                      bits += 8;
53045                    }
53046                    hold >>>= here_bits;
53047                    bits -= here_bits;
53048                    len2 = 0;
53049                    copy = 11 + (hold & 127);
53050                    hold >>>= 7;
53051                    bits -= 7;
53052                  }
53053                  if (state2.have + copy > state2.nlen + state2.ndist) {
53054                    strm.msg = "invalid bit length repeat";
53055                    state2.mode = BAD;
53056                    break;
53057                  }
53058                  while (copy--) {
53059                    state2.lens[state2.have++] = len2;
53060                  }
53061                }
53062              }
53063              if (state2.mode === BAD) {
53064                break;
53065              }
53066              if (state2.lens[256] === 0) {
53067                strm.msg = "invalid code -- missing end-of-block";
53068                state2.mode = BAD;
53069                break;
53070              }
53071              state2.lenbits = 9;
53072              opts = { bits: state2.lenbits };
53073              ret = inflate_table(LENS, state2.lens, 0, state2.nlen, state2.lencode, 0, state2.work, opts);
53074              state2.lenbits = opts.bits;
53075              if (ret) {
53076                strm.msg = "invalid literal/lengths set";
53077                state2.mode = BAD;
53078                break;
53079              }
53080              state2.distbits = 6;
53081              state2.distcode = state2.distdyn;
53082              opts = { bits: state2.distbits };
53083              ret = inflate_table(DISTS, state2.lens, state2.nlen, state2.ndist, state2.distcode, 0, state2.work, opts);
53084              state2.distbits = opts.bits;
53085              if (ret) {
53086                strm.msg = "invalid distances set";
53087                state2.mode = BAD;
53088                break;
53089              }
53090              state2.mode = LEN_;
53091              if (flush === Z_TREES) {
53092                break inf_leave;
53093              }
53094            /* falls through */
53095            case LEN_:
53096              state2.mode = LEN;
53097            /* falls through */
53098            case LEN:
53099              if (have >= 6 && left >= 258) {
53100                strm.next_out = put;
53101                strm.avail_out = left;
53102                strm.next_in = next;
53103                strm.avail_in = have;
53104                state2.hold = hold;
53105                state2.bits = bits;
53106                inflate_fast(strm, _out);
53107                put = strm.next_out;
53108                output = strm.output;
53109                left = strm.avail_out;
53110                next = strm.next_in;
53111                input = strm.input;
53112                have = strm.avail_in;
53113                hold = state2.hold;
53114                bits = state2.bits;
53115                if (state2.mode === TYPE) {
53116                  state2.back = -1;
53117                }
53118                break;
53119              }
53120              state2.back = 0;
53121              for (; ; ) {
53122                here = state2.lencode[hold & (1 << state2.lenbits) - 1];
53123                here_bits = here >>> 24;
53124                here_op = here >>> 16 & 255;
53125                here_val = here & 65535;
53126                if (here_bits <= bits) {
53127                  break;
53128                }
53129                if (have === 0) {
53130                  break inf_leave;
53131                }
53132                have--;
53133                hold += input[next++] << bits;
53134                bits += 8;
53135              }
53136              if (here_op && (here_op & 240) === 0) {
53137                last_bits = here_bits;
53138                last_op = here_op;
53139                last_val = here_val;
53140                for (; ; ) {
53141                  here = state2.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
53142                  here_bits = here >>> 24;
53143                  here_op = here >>> 16 & 255;
53144                  here_val = here & 65535;
53145                  if (last_bits + here_bits <= bits) {
53146                    break;
53147                  }
53148                  if (have === 0) {
53149                    break inf_leave;
53150                  }
53151                  have--;
53152                  hold += input[next++] << bits;
53153                  bits += 8;
53154                }
53155                hold >>>= last_bits;
53156                bits -= last_bits;
53157                state2.back += last_bits;
53158              }
53159              hold >>>= here_bits;
53160              bits -= here_bits;
53161              state2.back += here_bits;
53162              state2.length = here_val;
53163              if (here_op === 0) {
53164                state2.mode = LIT;
53165                break;
53166              }
53167              if (here_op & 32) {
53168                state2.back = -1;
53169                state2.mode = TYPE;
53170                break;
53171              }
53172              if (here_op & 64) {

vendor: 5,551 bytes, lines 53173-53335

53173                strm.msg = "invalid literal/length code";
53174                state2.mode = BAD;
53175                break;
53176              }
53177              state2.extra = here_op & 15;
53178              state2.mode = LENEXT;
53179            /* falls through */
53180            case LENEXT:
53181              if (state2.extra) {
53182                n = state2.extra;
53183                while (bits < n) {
53184                  if (have === 0) {
53185                    break inf_leave;
53186                  }
53187                  have--;
53188                  hold += input[next++] << bits;
53189                  bits += 8;
53190                }
53191                state2.length += hold & (1 << state2.extra) - 1;
53192                hold >>>= state2.extra;
53193                bits -= state2.extra;
53194                state2.back += state2.extra;
53195              }
53196              state2.was = state2.length;
53197              state2.mode = DIST;
53198            /* falls through */
53199            case DIST:
53200              for (; ; ) {
53201                here = state2.distcode[hold & (1 << state2.distbits) - 1];
53202                here_bits = here >>> 24;
53203                here_op = here >>> 16 & 255;
53204                here_val = here & 65535;
53205                if (here_bits <= bits) {
53206                  break;
53207                }
53208                if (have === 0) {
53209                  break inf_leave;
53210                }
53211                have--;
53212                hold += input[next++] << bits;
53213                bits += 8;
53214              }
53215              if ((here_op & 240) === 0) {
53216                last_bits = here_bits;
53217                last_op = here_op;
53218                last_val = here_val;
53219                for (; ; ) {
53220                  here = state2.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
53221                  here_bits = here >>> 24;
53222                  here_op = here >>> 16 & 255;
53223                  here_val = here & 65535;
53224                  if (last_bits + here_bits <= bits) {
53225                    break;
53226                  }
53227                  if (have === 0) {
53228                    break inf_leave;
53229                  }
53230                  have--;
53231                  hold += input[next++] << bits;
53232                  bits += 8;
53233                }
53234                hold >>>= last_bits;
53235                bits -= last_bits;
53236                state2.back += last_bits;
53237              }
53238              hold >>>= here_bits;
53239              bits -= here_bits;
53240              state2.back += here_bits;
53241              if (here_op & 64) {
53242                strm.msg = "invalid distance code";
53243                state2.mode = BAD;
53244                break;
53245              }
53246              state2.offset = here_val;
53247              state2.extra = here_op & 15;
53248              state2.mode = DISTEXT;
53249            /* falls through */
53250            case DISTEXT:
53251              if (state2.extra) {
53252                n = state2.extra;
53253                while (bits < n) {
53254                  if (have === 0) {
53255                    break inf_leave;
53256                  }
53257                  have--;
53258                  hold += input[next++] << bits;
53259                  bits += 8;
53260                }
53261                state2.offset += hold & (1 << state2.extra) - 1;
53262                hold >>>= state2.extra;
53263                bits -= state2.extra;
53264                state2.back += state2.extra;
53265              }
53266              if (state2.offset > state2.dmax) {
53267                strm.msg = "invalid distance too far back";
53268                state2.mode = BAD;
53269                break;
53270              }
53271              state2.mode = MATCH;
53272            /* falls through */
53273            case MATCH:
53274              if (left === 0) {
53275                break inf_leave;
53276              }
53277              copy = _out - left;
53278              if (state2.offset > copy) {
53279                copy = state2.offset - copy;
53280                if (copy > state2.whave) {
53281                  if (state2.sane) {
53282                    strm.msg = "invalid distance too far back";
53283                    state2.mode = BAD;
53284                    break;
53285                  }
53286                }
53287                if (copy > state2.wnext) {
53288                  copy -= state2.wnext;
53289                  from = state2.wsize - copy;
53290                } else {
53291                  from = state2.wnext - copy;
53292                }
53293                if (copy > state2.length) {
53294                  copy = state2.length;
53295                }
53296                from_source = state2.window;
53297              } else {
53298                from_source = output;
53299                from = put - state2.offset;
53300                copy = state2.length;
53301              }
53302              if (copy > left) {
53303                copy = left;
53304              }
53305              left -= copy;
53306              state2.length -= copy;
53307              do {
53308                output[put++] = from_source[from++];
53309              } while (--copy);
53310              if (state2.length === 0) {
53311                state2.mode = LEN;
53312              }
53313              break;
53314            case LIT:
53315              if (left === 0) {
53316                break inf_leave;
53317              }
53318              output[put++] = state2.length;
53319              left--;
53320              state2.mode = LEN;
53321              break;
53322            case CHECK:
53323              if (state2.wrap) {
53324                while (bits < 32) {
53325                  if (have === 0) {
53326                    break inf_leave;
53327                  }
53328                  have--;
53329                  hold |= input[next++] << bits;
53330                  bits += 8;
53331                }
53332                _out -= left;
53333                strm.total_out += _out;
53334                state2.total += _out;
53335                if (_out) {

vendor: 5,230 bytes, lines 53336-53494

53336                  strm.adler = state2.check = /*UPDATE(state.check, put - _out, _out);*/
53337                  state2.flags ? crc32(state2.check, output, _out, put - _out) : adler32(state2.check, output, _out, put - _out);
53338                }
53339                _out = left;
53340                if ((state2.flags ? hold : zswap32(hold)) !== state2.check) {
53341                  strm.msg = "incorrect data check";
53342                  state2.mode = BAD;
53343                  break;
53344                }
53345                hold = 0;
53346                bits = 0;
53347              }
53348              state2.mode = LENGTH;
53349            /* falls through */
53350            case LENGTH:
53351              if (state2.wrap && state2.flags) {
53352                while (bits < 32) {
53353                  if (have === 0) {
53354                    break inf_leave;
53355                  }
53356                  have--;
53357                  hold += input[next++] << bits;
53358                  bits += 8;
53359                }
53360                if (hold !== (state2.total & 4294967295)) {
53361                  strm.msg = "incorrect length check";
53362                  state2.mode = BAD;
53363                  break;
53364                }
53365                hold = 0;
53366                bits = 0;
53367              }
53368              state2.mode = DONE;
53369            /* falls through */
53370            case DONE:
53371              ret = Z_STREAM_END;
53372              break inf_leave;
53373            case BAD:
53374              ret = Z_DATA_ERROR;
53375              break inf_leave;
53376            case MEM:
53377              return Z_MEM_ERROR;
53378            case SYNC:
53379            /* falls through */
53380            default:
53381              return Z_STREAM_ERROR;
53382          }
53383        }
53384      strm.next_out = put;
53385      strm.avail_out = left;
53386      strm.next_in = next;
53387      strm.avail_in = have;
53388      state2.hold = hold;
53389      state2.bits = bits;
53390      if (state2.wsize || _out !== strm.avail_out && state2.mode < BAD && (state2.mode < CHECK || flush !== Z_FINISH)) {
53391        if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) ;
53392      }
53393      _in -= strm.avail_in;
53394      _out -= strm.avail_out;
53395      strm.total_in += _in;
53396      strm.total_out += _out;
53397      state2.total += _out;
53398      if (state2.wrap && _out) {
53399        strm.adler = state2.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
53400        state2.flags ? crc32(state2.check, output, _out, strm.next_out - _out) : adler32(state2.check, output, _out, strm.next_out - _out);
53401      }
53402      strm.data_type = state2.bits + (state2.last ? 64 : 0) + (state2.mode === TYPE ? 128 : 0) + (state2.mode === LEN_ || state2.mode === COPY_ ? 256 : 0);
53403      if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret === Z_OK) {
53404        ret = Z_BUF_ERROR;
53405      }
53406      return ret;
53407    }
53408    function inflateEnd(strm) {
53409      if (!strm || !strm.state) {
53410        return Z_STREAM_ERROR;
53411      }
53412      var state2 = strm.state;
53413      if (state2.window) {
53414        state2.window = null;
53415      }
53416      strm.state = null;
53417      return Z_OK;
53418    }
53419    function inflateGetHeader(strm, head) {
53420      var state2;
53421      if (!strm || !strm.state) {
53422        return Z_STREAM_ERROR;
53423      }
53424      state2 = strm.state;
53425      if ((state2.wrap & 2) === 0) {
53426        return Z_STREAM_ERROR;
53427      }
53428      state2.head = head;
53429      head.done = false;
53430      return Z_OK;
53431    }
53432    function inflateSetDictionary(strm, dictionary) {
53433      var dictLength = dictionary.length;
53434      var state2;
53435      var dictid;
53436      var ret;
53437      if (!strm || !strm.state) {
53438        return Z_STREAM_ERROR;
53439      }
53440      state2 = strm.state;
53441      if (state2.wrap !== 0 && state2.mode !== DICT) {
53442        return Z_STREAM_ERROR;
53443      }
53444      if (state2.mode === DICT) {
53445        dictid = 1;
53446        dictid = adler32(dictid, dictionary, dictLength, 0);
53447        if (dictid !== state2.check) {
53448          return Z_DATA_ERROR;
53449        }
53450      }
53451      ret = updatewindow(strm, dictionary, dictLength, dictLength);
53452      if (ret) {
53453        state2.mode = MEM;
53454        return Z_MEM_ERROR;
53455      }
53456      state2.havedict = 1;
53457      return Z_OK;
53458    }
53459    inflate.inflateReset = inflateReset;
53460    inflate.inflateReset2 = inflateReset2;
53461    inflate.inflateResetKeep = inflateResetKeep;
53462    inflate.inflateInit = inflateInit;
53463    inflate.inflateInit2 = inflateInit2;
53464    inflate.inflate = inflate$12;
53465    inflate.inflateEnd = inflateEnd;
53466    inflate.inflateGetHeader = inflateGetHeader;
53467    inflate.inflateSetDictionary = inflateSetDictionary;
53468    inflate.inflateInfo = "pako inflate (from Nodeca project)";
53469    return inflate;
53470  }
53471  var constants;
53472  var hasRequiredConstants;
53473  function requireConstants() {
53474    if (hasRequiredConstants) return constants;
53475    hasRequiredConstants = 1;
53476    constants = {
53477      /* Allowed flush values; see deflate() and inflate() below for details */
53478      Z_NO_FLUSH: 0,
53479      Z_PARTIAL_FLUSH: 1,
53480      Z_SYNC_FLUSH: 2,
53481      Z_FULL_FLUSH: 3,
53482      Z_FINISH: 4,
53483      Z_BLOCK: 5,
53484      Z_TREES: 6,
53485      /* Return codes for the compression/decompression functions. Negative values
53486      * are errors, positive values are used for special but normal events.
53487      */
53488      Z_OK: 0,
53489      Z_STREAM_END: 1,
53490      Z_NEED_DICT: 2,
53491      Z_ERRNO: -1,
53492      Z_STREAM_ERROR: -2,
53493      Z_DATA_ERROR: -3,
53494      //Z_MEM_ERROR:     -4,

vendor: 4,326 bytes, lines 53495-53630

53495      Z_BUF_ERROR: -5,
53496      //Z_VERSION_ERROR: -6,
53497      /* compression levels */
53498      Z_NO_COMPRESSION: 0,
53499      Z_BEST_SPEED: 1,
53500      Z_BEST_COMPRESSION: 9,
53501      Z_DEFAULT_COMPRESSION: -1,
53502      Z_FILTERED: 1,
53503      Z_HUFFMAN_ONLY: 2,
53504      Z_RLE: 3,
53505      Z_FIXED: 4,
53506      Z_DEFAULT_STRATEGY: 0,
53507      /* Possible values of the data_type field (though see inflate()) */
53508      Z_BINARY: 0,
53509      Z_TEXT: 1,
53510      //Z_ASCII:                1, // = Z_TEXT (deprecated)
53511      Z_UNKNOWN: 2,
53512      /* The deflate compression method */
53513      Z_DEFLATED: 8
53514      //Z_NULL:                 null // Use -1 or null inline, depending on var type
53515    };
53516    return constants;
53517  }
53518  var gzheader;
53519  var hasRequiredGzheader;
53520  function requireGzheader() {
53521    if (hasRequiredGzheader) return gzheader;
53522    hasRequiredGzheader = 1;
53523    function GZheader() {
53524      this.text = 0;
53525      this.time = 0;
53526      this.xflags = 0;
53527      this.os = 0;
53528      this.extra = null;
53529      this.extra_len = 0;
53530      this.name = "";
53531      this.comment = "";
53532      this.hcrc = 0;
53533      this.done = false;
53534    }
53535    gzheader = GZheader;
53536    return gzheader;
53537  }
53538  var hasRequiredInflate;
53539  function requireInflate() {
53540    if (hasRequiredInflate) return inflate$1;
53541    hasRequiredInflate = 1;
53542    var zlib_inflate = requireInflate$1();
53543    var utils2 = requireCommon();
53544    var strings2 = requireStrings();
53545    var c = requireConstants();
53546    var msg = requireMessages();
53547    var ZStream = requireZstream();
53548    var GZheader = requireGzheader();
53549    var toString2 = Object.prototype.toString;
53550    function Inflate(options) {
53551      if (!(this instanceof Inflate)) return new Inflate(options);
53552      this.options = utils2.assign({
53553        chunkSize: 16384,
53554        windowBits: 0,
53555        to: ""
53556      }, options || {});
53557      var opt = this.options;
53558      if (opt.raw && opt.windowBits >= 0 && opt.windowBits < 16) {
53559        opt.windowBits = -opt.windowBits;
53560        if (opt.windowBits === 0) {
53561          opt.windowBits = -15;
53562        }
53563      }
53564      if (opt.windowBits >= 0 && opt.windowBits < 16 && !(options && options.windowBits)) {
53565        opt.windowBits += 32;
53566      }
53567      if (opt.windowBits > 15 && opt.windowBits < 48) {
53568        if ((opt.windowBits & 15) === 0) {
53569          opt.windowBits |= 15;
53570        }
53571      }
53572      this.err = 0;
53573      this.msg = "";
53574      this.ended = false;
53575      this.chunks = [];
53576      this.strm = new ZStream();
53577      this.strm.avail_out = 0;
53578      var status = zlib_inflate.inflateInit2(
53579        this.strm,
53580        opt.windowBits
53581      );
53582      if (status !== c.Z_OK) {
53583        throw new Error(msg[status]);
53584      }
53585      this.header = new GZheader();
53586      zlib_inflate.inflateGetHeader(this.strm, this.header);
53587      if (opt.dictionary) {
53588        if (typeof opt.dictionary === "string") {
53589          opt.dictionary = strings2.string2buf(opt.dictionary);
53590        } else if (toString2.call(opt.dictionary) === "[object ArrayBuffer]") {
53591          opt.dictionary = new Uint8Array(opt.dictionary);
53592        }
53593        if (opt.raw) {
53594          status = zlib_inflate.inflateSetDictionary(this.strm, opt.dictionary);
53595          if (status !== c.Z_OK) {
53596            throw new Error(msg[status]);
53597          }
53598        }
53599      }
53600    }
53601    Inflate.prototype.push = function(data, mode) {
53602      var strm = this.strm;
53603      var chunkSize = this.options.chunkSize;
53604      var dictionary = this.options.dictionary;
53605      var status, _mode;
53606      var next_out_utf8, tail, utf8str;
53607      var allowBufError = false;
53608      if (this.ended) {
53609        return false;
53610      }
53611      _mode = mode === ~~mode ? mode : mode === true ? c.Z_FINISH : c.Z_NO_FLUSH;
53612      if (typeof data === "string") {
53613        strm.input = strings2.binstring2buf(data);
53614      } else if (toString2.call(data) === "[object ArrayBuffer]") {
53615        strm.input = new Uint8Array(data);
53616      } else {
53617        strm.input = data;
53618      }
53619      strm.next_in = 0;
53620      strm.avail_in = strm.input.length;
53621      do {
53622        if (strm.avail_out === 0) {
53623          strm.output = new utils2.Buf8(chunkSize);
53624          strm.next_out = 0;
53625          strm.avail_out = chunkSize;
53626        }
53627        status = zlib_inflate.inflate(strm, c.Z_NO_FLUSH);
53628        if (status === c.Z_NEED_DICT && dictionary) {
53629          status = zlib_inflate.inflateSetDictionary(this.strm, dictionary);
53630        }

53631        if (status === c.Z_BUF_ERROR && allowBufError === true) {
53632          status = c.Z_OK;
53633          allowBufError = false;
53634        }
53635        if (status !== c.Z_STREAM_END && status !== c.Z_OK) {
53636          this.onEnd(status);
53637          this.ended = true;
53638          return false;
53639        }
53640        if (strm.next_out) {
53641          if (strm.avail_out === 0 || status === c.Z_STREAM_END || strm.avail_in === 0 && (_mode === c.Z_FINISH || _mode === c.Z_SYNC_FLUSH)) {
53642            if (this.options.to === "string") {
53643              next_out_utf8 = strings2.utf8border(strm.output, strm.next_out);
53644              tail = strm.next_out - next_out_utf8;
53645              utf8str = strings2.buf2string(strm.output, next_out_utf8);
53646              strm.next_out = tail;
53647              strm.avail_out = chunkSize - tail;
53648              if (tail) {
53649                utils2.arraySet(strm.output, strm.output, next_out_utf8, tail, 0);
53650              }
53651              this.onData(utf8str);
53652            } else {
53653              this.onData(utils2.shrinkBuf(strm.output, strm.next_out));
53654            }
53655          }
53656        }
53657        if (strm.avail_in === 0 && strm.avail_out === 0) {
53658          allowBufError = true;
53659        }
53660      } while ((strm.avail_in > 0 || strm.avail_out === 0) && status !== c.Z_STREAM_END);
53661      if (status === c.Z_STREAM_END) {
53662        _mode = c.Z_FINISH;
53663      }
53664      if (_mode === c.Z_FINISH) {
53665        status = zlib_inflate.inflateEnd(this.strm);
53666        this.onEnd(status);
53667        this.ended = true;
53668        return status === c.Z_OK;
53669      }
53670      if (_mode === c.Z_SYNC_FLUSH) {
53671        this.onEnd(c.Z_OK);
53672        strm.avail_out = 0;
53673        return true;
53674      }
53675      return true;
53676    };
53677    Inflate.prototype.onData = function(chunk) {
53678      this.chunks.push(chunk);
53679    };
53680    Inflate.prototype.onEnd = function(status) {
53681      if (status === c.Z_OK) {
53682        if (this.options.to === "string") {
53683          this.result = this.chunks.join("");
53684        } else {
53685          this.result = utils2.flattenChunks(this.chunks);
53686        }
53687      }
53688      this.chunks = [];
53689      this.err = status;
53690      this.msg = this.strm.msg;
53691    };
53692    function inflate2(input, options) {
53693      var inflator = new Inflate(options);
53694      inflator.push(input, true);
53695      if (inflator.err) {
53696        throw inflator.msg || msg[inflator.err];
53697      }
53698      return inflator.result;
53699    }
53700    function inflateRaw(input, options) {
53701      options = options || {};
53702      options.raw = true;
53703      return inflate2(input, options);
53704    }
53705    inflate$1.Inflate = Inflate;
53706    inflate$1.inflate = inflate2;
53707    inflate$1.inflateRaw = inflateRaw;
53708    inflate$1.ungzip = inflate2;
53709    return inflate$1;
53710  }
53711  var pako_1;
53712  var hasRequiredPako;
53713  function requirePako() {
53714    if (hasRequiredPako) return pako_1;
53715    hasRequiredPako = 1;
53716    var assign = requireCommon().assign;
53717    var deflate2 = requireDeflate();
53718    var inflate2 = requireInflate();
53719    var constants2 = requireConstants();
53720    var pako = {};
53721    assign(pako, deflate2, inflate2, constants2);
53722    pako_1 = pako;
53723    return pako_1;
53724  }
53725  var zlibShim;
53726  var hasRequiredZlibShim;
53727  function requireZlibShim() {
53728    if (hasRequiredZlibShim) return zlibShim;
53729    hasRequiredZlibShim = 1;
53730    const pako = requirePako();
53731    const constants2 = {
53732      Z_NO_FLUSH: 0,
53733      Z_PARTIAL_FLUSH: 1,
53734      Z_SYNC_FLUSH: 2,
53735      Z_FULL_FLUSH: 3,
53736      Z_FINISH: 4,
53737      Z_BLOCK: 5,
53738      Z_TREES: 6
53739      // Add any other constants needed by dependencies
53740    };
53741    zlibShim = {
53742      ...pako,
53743      constants: constants2,
53744      Z_NO_FLUSH: constants2.Z_NO_FLUSH,
53745      Z_PARTIAL_FLUSH: constants2.Z_PARTIAL_FLUSH,
53746      Z_SYNC_FLUSH: constants2.Z_SYNC_FLUSH,
53747      Z_FULL_FLUSH: constants2.Z_FULL_FLUSH,
53748      Z_FINISH: constants2.Z_FINISH,
53749      Z_BLOCK: constants2.Z_BLOCK,
53750      Z_TREES: constants2.Z_TREES
53751    };
53752    return zlibShim;
53753  }
53754  var zlibShimExports = requireZlibShim();
53755  const zlib = /* @__PURE__ */ getDefaultExportFromCjs$1(zlibShimExports);
53756  const VERSION$1 = "1.16.0";
53757  function parseProtocol(url2) {
53758    const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url2);
53759    return match && match[1] || "";
53760  }
53761  const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
53762  function fromDataURI(uri2, asBlob, options) {
53763    const _Blob = options && options.Blob || platform.classes.Blob;
53764    const protocol = parseProtocol(uri2);
53765    if (asBlob === void 0 && _Blob) {
53766      asBlob = true;
53767    }
53768    if (protocol === "data") {
53769      uri2 = protocol.length ? uri2.slice(protocol.length + 1) : uri2;
53770      const match = DATA_URL_PATTERN.exec(uri2);
53771      if (!match) {
53772        throw new AxiosError$1("Invalid URL", AxiosError$1.ERR_INVALID_URL);
53773      }
53774      const mime = match[1];
53775      const isBase64 = match[2];
53776      const body = match[3];
53777      const buffer2 = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
53778      if (asBlob) {
53779        if (!_Blob) {
53780          throw new AxiosError$1("Blob is not supported", AxiosError$1.ERR_NOT_SUPPORT);
53781        }
53782        return new _Blob([buffer2], { type: mime });
53783      }
53784      return buffer2;
53785    }
53786    throw new AxiosError$1("Unsupported protocol " + protocol, AxiosError$1.ERR_NOT_SUPPORT);
53787  }
53788  var streamBrowserifyExports = requireStreamBrowserify();
53789  const stream = /* @__PURE__ */ getDefaultExportFromCjs$1(streamBrowserifyExports);
53790  const kInternals = Symbol("internals");
53791  class AxiosTransformStream extends stream.Transform {
53792    constructor(options) {
53793      options = utils$5.toFlatObject(
53794        options,
53795        {
53796          maxRate: 0,
53797          chunkSize: 64 * 1024,
53798          minChunkSize: 100,
53799          timeWindow: 500,
53800          ticksRate: 2,
53801          samplesCount: 15
53802        },
53803        null,
53804        (prop, source) => {
53805          return !utils$5.isUndefined(source[prop]);
53806        }
53807      );
53808      super({
53809        readableHighWaterMark: options.chunkSize
53810      });
53811      const internals = this[kInternals] = {
53812        timeWindow: options.timeWindow,
53813        chunkSize: options.chunkSize,
53814        maxRate: options.maxRate,
53815        minChunkSize: options.minChunkSize,
53816        bytesSeen: 0,
53817        isCaptured: false,
53818        notifiedBytesLoaded: 0,
53819        ts: Date.now(),
53820        bytes: 0,
53821        onReadCallback: null
53822      };
53823      this.on("newListener", (event) => {
53824        if (event === "progress") {
53825          if (!internals.isCaptured) {
53826            internals.isCaptured = true;
53827          }
53828        }
53829      });
53830    }
53831    _read(size) {
53832      const internals = this[kInternals];
53833      if (internals.onReadCallback) {
53834        internals.onReadCallback();
53835      }
53836      return super._read(size);
53837    }
53838    _transform(chunk, encoding, callback) {
53839      const internals = this[kInternals];
53840      const maxRate = internals.maxRate;
53841      const readableHighWaterMark = this.readableHighWaterMark;
53842      const timeWindow = internals.timeWindow;
53843      const divider = 1e3 / timeWindow;
53844      const bytesThreshold = maxRate / divider;
53845      const minChunkSize = internals.minChunkSize !== false ? Math.max(internals.minChunkSize, bytesThreshold * 0.01) : 0;
53846      const pushChunk = (_chunk, _callback) => {
53847        const bytes = Buffer.byteLength(_chunk);
53848        internals.bytesSeen += bytes;
53849        internals.bytes += bytes;

vendor: 4,454 bytes, lines 53850-53978

53850        internals.isCaptured && this.emit("progress", internals.bytesSeen);
53851        if (this.push(_chunk)) {
53852          process$1.nextTick(_callback);
53853        } else {
53854          internals.onReadCallback = () => {
53855            internals.onReadCallback = null;
53856            process$1.nextTick(_callback);
53857          };
53858        }
53859      };
53860      const transformChunk = (_chunk, _callback) => {
53861        const chunkSize = Buffer.byteLength(_chunk);
53862        let chunkRemainder = null;
53863        let maxChunkSize = readableHighWaterMark;
53864        let bytesLeft;
53865        let passed = 0;
53866        if (maxRate) {
53867          const now = Date.now();
53868          if (!internals.ts || (passed = now - internals.ts) >= timeWindow) {
53869            internals.ts = now;
53870            bytesLeft = bytesThreshold - internals.bytes;
53871            internals.bytes = bytesLeft < 0 ? -bytesLeft : 0;
53872            passed = 0;
53873          }
53874          bytesLeft = bytesThreshold - internals.bytes;
53875        }
53876        if (maxRate) {
53877          if (bytesLeft <= 0) {
53878            return setTimeout(() => {
53879              _callback(null, _chunk);
53880            }, timeWindow - passed);
53881          }
53882          if (bytesLeft < maxChunkSize) {
53883            maxChunkSize = bytesLeft;
53884          }
53885        }
53886        if (maxChunkSize && chunkSize > maxChunkSize && chunkSize - maxChunkSize > minChunkSize) {
53887          chunkRemainder = _chunk.subarray(maxChunkSize);
53888          _chunk = _chunk.subarray(0, maxChunkSize);
53889        }
53890        pushChunk(
53891          _chunk,
53892          chunkRemainder ? () => {
53893            process$1.nextTick(_callback, null, chunkRemainder);
53894          } : _callback
53895        );
53896      };
53897      transformChunk(chunk, function transformNextChunk(err, _chunk) {
53898        if (err) {
53899          return callback(err);
53900        }
53901        if (_chunk) {
53902          transformChunk(_chunk, transformNextChunk);
53903        } else {
53904          callback(null);
53905        }
53906      });
53907    }
53908  }
53909  var eventsExports = requireEvents();
53910  const { asyncIterator } = Symbol;
53911  const readBlob = async function* (blob) {
53912    if (blob.stream) {
53913      yield* blob.stream();
53914    } else if (blob.arrayBuffer) {
53915      yield await blob.arrayBuffer();
53916    } else if (blob[asyncIterator]) {
53917      yield* blob[asyncIterator]();
53918    } else {
53919      yield blob;
53920    }
53921  };
53922  const BOUNDARY_ALPHABET = platform.ALPHABET.ALPHA_DIGIT + "-_";
53923  const textEncoder = typeof TextEncoder === "function" ? new TextEncoder() : new util.TextEncoder();
53924  const CRLF = "\r\n";
53925  const CRLF_BYTES = textEncoder.encode(CRLF);
53926  const CRLF_BYTES_COUNT = 2;
53927  class FormDataPart {
53928    constructor(name, value) {
53929      const { escapeName } = this.constructor;
53930      const isStringValue = utils$5.isString(value);
53931      let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${!isStringValue && value.name ? `; filename="${escapeName(value.name)}"` : ""}${CRLF}`;
53932      if (isStringValue) {
53933        value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
53934      } else {
53935        const safeType = String(value.type || "application/octet-stream").replace(/[\r\n]/g, "");
53936        headers += `Content-Type: ${safeType}${CRLF}`;
53937      }
53938      this.headers = textEncoder.encode(headers + CRLF);
53939      this.contentLength = isStringValue ? value.byteLength : value.size;
53940      this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
53941      this.name = name;
53942      this.value = value;
53943    }
53944    async *encode() {
53945      yield this.headers;
53946      const { value } = this;
53947      if (utils$5.isTypedArray(value)) {
53948        yield value;
53949      } else {
53950        yield* readBlob(value);
53951      }
53952      yield CRLF_BYTES;
53953    }
53954    static escapeName(name) {
53955      return String(name).replace(
53956        /[\r\n"]/g,
53957        (match) => ({
53958          "\r": "%0D",
53959          "\n": "%0A",
53960          '"': "%22"
53961        })[match]
53962      );
53963    }
53964  }
53965  const formDataToStream = (form, headersHandler, options) => {
53966    const {
53967      tag = "form-data-boundary",
53968      size = 25,
53969      boundary = tag + "-" + platform.generateString(size, BOUNDARY_ALPHABET)
53970    } = options || {};
53971    if (!utils$5.isFormData(form)) {
53972      throw TypeError("FormData instance required");
53973    }
53974    if (boundary.length < 1 || boundary.length > 70) {
53975      throw Error("boundary must be 1-70 characters long");
53976    }
53977    const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
53978    const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF);

53979    let contentLength = footerBytes.byteLength;
53980    const parts = Array.from(form.entries()).map(([name, value]) => {
53981      const part = new FormDataPart(name, value);
53982      contentLength += part.size;
53983      return part;
53984    });
53985    contentLength += boundaryBytes.byteLength * parts.length;
53986    contentLength = utils$5.toFiniteNumber(contentLength);
53987    const computedHeaders = {
53988      "Content-Type": `multipart/form-data; boundary=${boundary}`
53989    };
53990    if (Number.isFinite(contentLength)) {
53991      computedHeaders["Content-Length"] = contentLength;
53992    }
53993    headersHandler && headersHandler(computedHeaders);
53994    return streamBrowserifyExports.Readable.from(
53995      (async function* () {
53996        for (const part of parts) {
53997          yield boundaryBytes;
53998          yield* part.encode();
53999        }
54000        yield footerBytes;
54001      })()
54002    );
54003  };
54004  class ZlibHeaderTransformStream extends stream.Transform {
54005    __transform(chunk, encoding, callback) {
54006      this.push(chunk);
54007      callback();
54008    }
54009    _transform(chunk, encoding, callback) {
54010      if (chunk.length !== 0) {
54011        this._transform = this.__transform;
54012        if (chunk[0] !== 120) {
54013          const header = Buffer.alloc(2);
54014          header[0] = 120;
54015          header[1] = 156;
54016          this.push(header, encoding);
54017        }
54018      }
54019      this.__transform(chunk, encoding, callback);
54020    }
54021  }
54022  const callbackify = (fn, reducer) => {
54023    return utils$5.isAsyncFn(fn) ? function(...args) {
54024      const cb = args.pop();
54025      fn.apply(this, args).then((value) => {
54026        try {
54027          reducer ? cb(null, ...reducer(value)) : cb(null, value);
54028        } catch (err) {
54029          cb(err);
54030        }
54031      }, cb);
54032    } : fn;
54033  };
54034  var define_process_env_default = {};
54035  const LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost"]);
54036  const isIPv4Loopback = (host) => {
54037    const parts = host.split(".");
54038    if (parts.length !== 4) return false;
54039    if (parts[0] !== "127") return false;
54040    return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
54041  };
54042  const isIPv6Loopback = (host) => {
54043    if (host === "::1") return true;
54044    const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
54045    if (v4MappedDotted) return isIPv4Loopback(v4MappedDotted[1]);
54046    const v4MappedHex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
54047    if (v4MappedHex) {
54048      const high = parseInt(v4MappedHex[1], 16);
54049      return high >= 32512 && high <= 32767;
54050    }
54051    const groups = host.split(":");
54052    if (groups.length === 8) {
54053      for (let i2 = 0; i2 < 7; i2++) {
54054        if (!/^0+$/.test(groups[i2])) return false;
54055      }
54056      return /^0*1$/.test(groups[7]);
54057    }
54058    return false;
54059  };
54060  const isLoopback = (host) => {
54061    if (!host) return false;
54062    if (LOOPBACK_HOSTNAMES.has(host)) return true;
54063    if (isIPv4Loopback(host)) return true;
54064    return isIPv6Loopback(host);
54065  };
54066  const DEFAULT_PORTS = {
54067    http: 80,
54068    https: 443,
54069    ws: 80,
54070    wss: 443,
54071    ftp: 21
54072  };
54073  const parseNoProxyEntry = (entry) => {
54074    let entryHost = entry;
54075    let entryPort = 0;
54076    if (entryHost.charAt(0) === "[") {
54077      const bracketIndex = entryHost.indexOf("]");
54078      if (bracketIndex !== -1) {
54079        const host = entryHost.slice(1, bracketIndex);
54080        const rest = entryHost.slice(bracketIndex + 1);
54081        if (rest.charAt(0) === ":" && /^\d+$/.test(rest.slice(1))) {
54082          entryPort = Number.parseInt(rest.slice(1), 10);
54083        }
54084        return [host, entryPort];
54085      }
54086    }
54087    const firstColon = entryHost.indexOf(":");
54088    const lastColon = entryHost.lastIndexOf(":");
54089    if (firstColon !== -1 && firstColon === lastColon && /^\d+$/.test(entryHost.slice(lastColon + 1))) {
54090      entryPort = Number.parseInt(entryHost.slice(lastColon + 1), 10);
54091      entryHost = entryHost.slice(0, lastColon);
54092    }
54093    return [entryHost, entryPort];
54094  };
54095  const IPV4_MAPPED_DOTTED_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:(\d+\.\d+\.\d+\.\d+)$/i;
54096  const IPV4_MAPPED_HEX_RE = /^(?:::|(?:0{1,4}:){1,4}:|(?:0{1,4}:){5})ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i;
54097  const unmapIPv4MappedIPv6 = (host) => {
54098    if (typeof host !== "string" || host.indexOf(":") === -1) return host;

vendor: 7,731 bytes, lines 54099-54343

54099    const dotted = host.match(IPV4_MAPPED_DOTTED_RE);
54100    if (dotted) return dotted[1];
54101    const hex = host.match(IPV4_MAPPED_HEX_RE);
54102    if (hex) {
54103      const high = parseInt(hex[1], 16);
54104      const low = parseInt(hex[2], 16);
54105      return `${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`;
54106    }
54107    return host;
54108  };
54109  const normalizeNoProxyHost = (hostname) => {
54110    if (!hostname) {
54111      return hostname;
54112    }
54113    if (hostname.charAt(0) === "[" && hostname.charAt(hostname.length - 1) === "]") {
54114      hostname = hostname.slice(1, -1);
54115    }
54116    return unmapIPv4MappedIPv6(hostname.replace(/\.+$/, ""));
54117  };
54118  function shouldBypassProxy(location2) {
54119    let parsed;
54120    try {
54121      parsed = new URL(location2);
54122    } catch (_err) {
54123      return false;
54124    }
54125    const noProxy = (define_process_env_default.no_proxy || define_process_env_default.NO_PROXY || "").toLowerCase();
54126    if (!noProxy) {
54127      return false;
54128    }
54129    if (noProxy === "*") {
54130      return true;
54131    }
54132    const port = Number.parseInt(parsed.port, 10) || DEFAULT_PORTS[parsed.protocol.split(":", 1)[0]] || 0;
54133    const hostname = normalizeNoProxyHost(parsed.hostname.toLowerCase());
54134    return noProxy.split(/[\s,]+/).some((entry) => {
54135      if (!entry) {
54136        return false;
54137      }
54138      let [entryHost, entryPort] = parseNoProxyEntry(entry);
54139      entryHost = normalizeNoProxyHost(entryHost);
54140      if (!entryHost) {
54141        return false;
54142      }
54143      if (entryPort && entryPort !== port) {
54144        return false;
54145      }
54146      if (entryHost.charAt(0) === "*") {
54147        entryHost = entryHost.slice(1);
54148      }
54149      if (entryHost.charAt(0) === ".") {
54150        return hostname.endsWith(entryHost);
54151      }
54152      return hostname === entryHost || isLoopback(hostname) && isLoopback(entryHost);
54153    });
54154  }
54155  function speedometer(samplesCount, min2) {
54156    samplesCount = samplesCount || 10;
54157    const bytes = new Array(samplesCount);
54158    const timestamps = new Array(samplesCount);
54159    let head = 0;
54160    let tail = 0;
54161    let firstSampleTS;
54162    min2 = min2 !== void 0 ? min2 : 1e3;
54163    return function push(chunkLength) {
54164      const now = Date.now();
54165      const startedAt = timestamps[tail];
54166      if (!firstSampleTS) {
54167        firstSampleTS = now;
54168      }
54169      bytes[head] = chunkLength;
54170      timestamps[head] = now;
54171      let i2 = tail;
54172      let bytesCount = 0;
54173      while (i2 !== head) {
54174        bytesCount += bytes[i2++];
54175        i2 = i2 % samplesCount;
54176      }
54177      head = (head + 1) % samplesCount;
54178      if (head === tail) {
54179        tail = (tail + 1) % samplesCount;
54180      }
54181      if (now - firstSampleTS < min2) {
54182        return;
54183      }
54184      const passed = startedAt && now - startedAt;
54185      return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
54186    };
54187  }
54188  function throttle(fn, freq) {
54189    let timestamp = 0;
54190    let threshold = 1e3 / freq;
54191    let lastArgs;
54192    let timer;
54193    const invoke = (args, now = Date.now()) => {
54194      timestamp = now;
54195      lastArgs = null;
54196      if (timer) {
54197        clearTimeout(timer);
54198        timer = null;
54199      }
54200      fn(...args);
54201    };
54202    const throttled = (...args) => {
54203      const now = Date.now();
54204      const passed = now - timestamp;
54205      if (passed >= threshold) {
54206        invoke(args, now);
54207      } else {
54208        lastArgs = args;
54209        if (!timer) {
54210          timer = setTimeout(() => {
54211            timer = null;
54212            invoke(lastArgs);
54213          }, threshold - passed);
54214        }
54215      }
54216    };
54217    const flush = () => lastArgs && invoke(lastArgs);
54218    return [throttled, flush];
54219  }
54220  const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
54221    let bytesNotified = 0;
54222    const _speedometer = speedometer(50, 250);
54223    return throttle((e) => {
54224      const rawLoaded = e.loaded;
54225      const total = e.lengthComputable ? e.total : void 0;
54226      const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
54227      const progressBytes = Math.max(0, loaded - bytesNotified);
54228      const rate = _speedometer(progressBytes);
54229      bytesNotified = Math.max(bytesNotified, loaded);
54230      const data = {
54231        loaded,
54232        total,
54233        progress: total ? loaded / total : void 0,
54234        bytes: progressBytes,
54235        rate: rate ? rate : void 0,
54236        estimated: rate && total ? (total - loaded) / rate : void 0,
54237        event: e,
54238        lengthComputable: total != null,
54239        [isDownloadStream ? "download" : "upload"]: true
54240      };
54241      listener(data);
54242    }, freq);
54243  };
54244  const progressEventDecorator = (total, throttled) => {
54245    const lengthComputable = total != null;
54246    return [
54247      (loaded) => throttled[0]({
54248        lengthComputable,
54249        total,
54250        loaded
54251      }),
54252      throttled[1]
54253    ];
54254  };
54255  const asyncDecorator = (fn) => (...args) => utils$5.asap(() => fn(...args));
54256  function estimateDataURLDecodedBytes(url2) {
54257    if (!url2 || typeof url2 !== "string") return 0;
54258    if (!url2.startsWith("data:")) return 0;
54259    const comma = url2.indexOf(",");
54260    if (comma < 0) return 0;
54261    const meta = url2.slice(5, comma);
54262    const body = url2.slice(comma + 1);
54263    const isBase64 = /;base64/i.test(meta);
54264    if (isBase64) {
54265      let effectiveLen = body.length;
54266      const len2 = body.length;
54267      for (let i2 = 0; i2 < len2; i2++) {
54268        if (body.charCodeAt(i2) === 37 && i2 + 2 < len2) {
54269          const a = body.charCodeAt(i2 + 1);
54270          const b = body.charCodeAt(i2 + 2);
54271          const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
54272          if (isHex) {
54273            effectiveLen -= 2;
54274            i2 += 2;
54275          }
54276        }
54277      }
54278      let pad = 0;
54279      let idx = len2 - 1;
54280      const tailIsPct3D = (j) => j >= 2 && body.charCodeAt(j - 2) === 37 && // '%'
54281      body.charCodeAt(j - 1) === 51 && // '3'
54282      (body.charCodeAt(j) === 68 || body.charCodeAt(j) === 100);
54283      if (idx >= 0) {
54284        if (body.charCodeAt(idx) === 61) {
54285          pad++;
54286          idx--;
54287        } else if (tailIsPct3D(idx)) {
54288          pad++;
54289          idx -= 3;
54290        }
54291      }
54292      if (pad === 1 && idx >= 0) {
54293        if (body.charCodeAt(idx) === 61) {
54294          pad++;
54295        } else if (tailIsPct3D(idx)) {
54296          pad++;
54297        }
54298      }
54299      const groups = Math.floor(effectiveLen / 4);
54300      const bytes2 = groups * 3 - (pad || 0);
54301      return bytes2 > 0 ? bytes2 : 0;
54302    }
54303    if (typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function") {
54304      return Buffer.byteLength(body, "utf8");
54305    }
54306    let bytes = 0;
54307    for (let i2 = 0, len2 = body.length; i2 < len2; i2++) {
54308      const c = body.charCodeAt(i2);
54309      if (c < 128) {
54310        bytes += 1;
54311      } else if (c < 2048) {
54312        bytes += 2;
54313      } else if (c >= 55296 && c <= 56319 && i2 + 1 < len2) {
54314        const next = body.charCodeAt(i2 + 1);
54315        if (next >= 56320 && next <= 57343) {
54316          bytes += 4;
54317          i2++;
54318        } else {
54319          bytes += 3;
54320        }
54321      } else {
54322        bytes += 3;
54323      }
54324    }
54325    return bytes;
54326  }
54327  const zlibOptions = {
54328    flush: zlib.constants.Z_SYNC_FLUSH,
54329    finishFlush: zlib.constants.Z_SYNC_FLUSH
54330  };
54331  const brotliOptions = {
54332    flush: zlib.constants.BROTLI_OPERATION_FLUSH,
54333    finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
54334  };
54335  const isBrotliSupported = utils$5.isFunction(zlib.createBrotliDecompress);
54336  const { http: httpFollow, https: httpsFollow } = followRedirects;
54337  const isHttps = /https:?/;
54338  const FORM_DATA_CONTENT_HEADERS$1 = ["content-type", "content-length"];
54339  function setFormDataHeaders$1(headers, formHeaders, policy) {
54340    if (policy !== "content-only") {
54341      headers.set(formHeaders);
54342      return;
54343    }

54344    Object.entries(formHeaders).forEach(([key2, val]) => {
54345      if (FORM_DATA_CONTENT_HEADERS$1.includes(key2.toLowerCase())) {
54346        headers.set(key2, val);
54347      }
54348    });
54349  }
54350  const kAxiosSocketListener = Symbol("axios.http.socketListener");
54351  const kAxiosCurrentReq = Symbol("axios.http.currentReq");
54352  const supportedProtocols = platform.protocols.map((protocol) => {
54353    return protocol + ":";
54354  });
54355  const decodeURIComponentSafe = (value) => {
54356    if (!utils$5.isString(value)) {
54357      return value;
54358    }
54359    try {
54360      return decodeURIComponent(value);
54361    } catch (error) {
54362      return value;
54363    }
54364  };
54365  const flushOnFinish = (stream2, [throttled, flush]) => {
54366    stream2.on("end", flush).on("error", flush);
54367    return throttled;
54368  };
54369  class Http2Sessions {
54370    constructor() {
54371      this.sessions = /* @__PURE__ */ Object.create(null);
54372    }
54373    getSession(authority, options) {
54374      options = Object.assign(
54375        {
54376          sessionTimeout: 1e3
54377        },
54378        options
54379      );
54380      let authoritySessions = this.sessions[authority];
54381      if (authoritySessions) {
54382        let len2 = authoritySessions.length;
54383        for (let i2 = 0; i2 < len2; i2++) {
54384          const [sessionHandle, sessionOptions] = authoritySessions[i2];
54385          if (!sessionHandle.destroyed && !sessionHandle.closed && util.isDeepStrictEqual(sessionOptions, options)) {
54386            return sessionHandle;
54387          }
54388        }
54389      }
54390      const session = http2.connect(authority, options);
54391      let removed;
54392      const removeSession = () => {
54393        if (removed) {
54394          return;
54395        }
54396        removed = true;
54397        let entries = authoritySessions, len2 = entries.length, i2 = len2;
54398        while (i2--) {
54399          if (entries[i2][0] === session) {
54400            if (len2 === 1) {
54401              delete this.sessions[authority];
54402            } else {
54403              entries.splice(i2, 1);
54404            }
54405            if (!session.closed) {
54406              session.close();
54407            }
54408            return;
54409          }
54410        }
54411      };
54412      const originalRequestFn = session.request;
54413      const { sessionTimeout } = options;
54414      if (sessionTimeout != null) {
54415        let timer;
54416        let streamsCount = 0;
54417        session.request = function() {
54418          const stream2 = originalRequestFn.apply(this, arguments);
54419          streamsCount++;
54420          if (timer) {
54421            clearTimeout(timer);
54422            timer = null;
54423          }
54424          stream2.once("close", () => {
54425            if (!--streamsCount) {
54426              timer = setTimeout(() => {
54427                timer = null;
54428                removeSession();
54429              }, sessionTimeout);
54430            }
54431          });
54432          return stream2;
54433        };
54434      }
54435      session.once("close", removeSession);
54436      let entry = [session, options];
54437      authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
54438      return session;
54439    }
54440  }
54441  const http2Sessions = new Http2Sessions();
54442  function dispatchBeforeRedirect(options, responseDetails, requestDetails) {
54443    if (options.beforeRedirects.proxy) {
54444      options.beforeRedirects.proxy(options);
54445    }
54446    if (options.beforeRedirects.config) {
54447      options.beforeRedirects.config(options, responseDetails, requestDetails);
54448    }
54449  }
54450  function setProxy(options, configProxy, location2, isRedirect) {
54451    let proxy = configProxy;
54452    if (!proxy && proxy !== false) {
54453      const proxyUrl = getProxyForUrl(location2);
54454      if (proxyUrl) {
54455        if (!shouldBypassProxy(location2)) {
54456          proxy = new URL(proxyUrl);
54457        }
54458      }
54459    }
54460    if (isRedirect && options.headers) {
54461      for (const name of Object.keys(options.headers)) {
54462        if (name.toLowerCase() === "proxy-authorization") {
54463          delete options.headers[name];
54464        }
54465      }
54466    }
54467    if (proxy) {
54468      const isProxyURL = proxy instanceof URL;
54469      const readProxyField = (key2) => isProxyURL || utils$5.hasOwnProp(proxy, key2) ? proxy[key2] : void 0;
54470      const proxyUsername = readProxyField("username");
54471      const proxyPassword = readProxyField("password");
54472      let proxyAuth = utils$5.hasOwnProp(proxy, "auth") ? proxy.auth : void 0;
54473      if (proxyUsername) {
54474        proxyAuth = (proxyUsername || "") + ":" + (proxyPassword || "");
54475      }
54476      if (proxyAuth) {
54477        const authIsObject = typeof proxyAuth === "object";
54478        const authUsername = authIsObject && utils$5.hasOwnProp(proxyAuth, "username") ? proxyAuth.username : void 0;
54479        const authPassword = authIsObject && utils$5.hasOwnProp(proxyAuth, "password") ? proxyAuth.password : void 0;
54480        const validProxyAuth = Boolean(authUsername || authPassword);
54481        if (validProxyAuth) {
54482          proxyAuth = (authUsername || "") + ":" + (authPassword || "");
54483        } else if (authIsObject) {
54484          throw new AxiosError$1("Invalid proxy authorization", AxiosError$1.ERR_BAD_OPTION, { proxy });
54485        }
54486        const base64 = Buffer.from(proxyAuth, "utf8").toString("base64");
54487        options.headers["Proxy-Authorization"] = "Basic " + base64;
54488      }
54489      let hasUserHostHeader = false;

vendor: 10,009 bytes, lines 54490-54747

54490      for (const name of Object.keys(options.headers)) {
54491        if (name.toLowerCase() === "host") {
54492          hasUserHostHeader = true;
54493          break;
54494        }
54495      }
54496      if (!hasUserHostHeader) {
54497        options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
54498      }
54499      const proxyHost = readProxyField("hostname") || readProxyField("host");
54500      options.hostname = proxyHost;
54501      options.host = proxyHost;
54502      options.port = readProxyField("port");
54503      options.path = location2;
54504      const proxyProtocol = readProxyField("protocol");
54505      if (proxyProtocol) {
54506        options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
54507      }
54508    }
54509    options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
54510      setProxy(redirectOptions, configProxy, redirectOptions.href, true);
54511    };
54512  }
54513  const isHttpAdapterSupported = typeof process$1 !== "undefined" && utils$5.kindOf(process$1) === "process";
54514  const wrapAsync = (asyncExecutor) => {
54515    return new Promise((resolve, reject) => {
54516      let onDone;
54517      let isDone;
54518      const done = (value, isRejected) => {
54519        if (isDone) return;
54520        isDone = true;
54521        onDone && onDone(value, isRejected);
54522      };
54523      const _resolve = (value) => {
54524        done(value);
54525        resolve(value);
54526      };
54527      const _reject = (reason) => {
54528        done(reason, true);
54529        reject(reason);
54530      };
54531      asyncExecutor(_resolve, _reject, (onDoneHandler) => onDone = onDoneHandler).catch(_reject);
54532    });
54533  };
54534  const resolveFamily = ({ address, family }) => {
54535    if (!utils$5.isString(address)) {
54536      throw TypeError("address must be a string");
54537    }
54538    return {
54539      address,
54540      family: family || (address.indexOf(".") < 0 ? 6 : 4)
54541    };
54542  };
54543  const buildAddressEntry = (address, family) => resolveFamily(utils$5.isObject(address) ? address : { address, family });
54544  const http2Transport = {
54545    request(options, cb) {
54546      const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
54547      const { http2Options, headers } = options;
54548      const session = http2Sessions.getSession(authority, http2Options);
54549      const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http2.constants;
54550      const http2Headers = {
54551        [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
54552        [HTTP2_HEADER_METHOD]: options.method,
54553        [HTTP2_HEADER_PATH]: options.path
54554      };
54555      utils$5.forEach(headers, (header, name) => {
54556        name.charAt(0) !== ":" && (http2Headers[name] = header);
54557      });
54558      const req = session.request(http2Headers);
54559      req.once("response", (responseHeaders) => {
54560        const response2 = req;
54561        responseHeaders = Object.assign({}, responseHeaders);
54562        const status = responseHeaders[HTTP2_HEADER_STATUS];
54563        delete responseHeaders[HTTP2_HEADER_STATUS];
54564        response2.headers = responseHeaders;
54565        response2.statusCode = +status;
54566        cb(response2);
54567      });
54568      return req;
54569    }
54570  };
54571  const httpAdapter = isHttpAdapterSupported && function httpAdapter2(config) {
54572    return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
54573      const own2 = (key2) => utils$5.hasOwnProp(config, key2) ? config[key2] : void 0;
54574      let data = own2("data");
54575      let lookup2 = own2("lookup");
54576      let family = own2("family");
54577      let httpVersion = own2("httpVersion");
54578      if (httpVersion === void 0) httpVersion = 1;
54579      let http2Options = own2("http2Options");
54580      const responseType = own2("responseType");
54581      const responseEncoding = own2("responseEncoding");
54582      const method = config.method.toUpperCase();
54583      let isDone;
54584      let rejected = false;
54585      let req;
54586      let connectPhaseTimer;
54587      httpVersion = +httpVersion;
54588      if (Number.isNaN(httpVersion)) {
54589        throw TypeError(`Invalid protocol version: '${config.httpVersion}' is not a number`);
54590      }
54591      if (httpVersion !== 1 && httpVersion !== 2) {
54592        throw TypeError(`Unsupported protocol version '${httpVersion}'`);
54593      }
54594      const isHttp2 = httpVersion === 2;
54595      if (lookup2) {
54596        const _lookup = callbackify(lookup2, (value) => utils$5.isArray(value) ? value : [value]);
54597        lookup2 = (hostname, opt, cb) => {
54598          _lookup(hostname, opt, (err, arg0, arg1) => {
54599            if (err) {
54600              return cb(err);
54601            }
54602            const addresses = utils$5.isArray(arg0) ? arg0.map((addr) => buildAddressEntry(addr)) : [buildAddressEntry(arg0, arg1)];
54603            opt.all ? cb(err, addresses) : cb(err, addresses[0].address, addresses[0].family);
54604          });
54605        };
54606      }
54607      const abortEmitter = new eventsExports.EventEmitter();
54608      function abort(reason) {
54609        try {
54610          abortEmitter.emit(
54611            "abort",
54612            !reason || reason.type ? new CanceledError$1(null, config, req) : reason
54613          );
54614        } catch (err) {
54615          console.warn("emit error", err);
54616        }
54617      }
54618      function clearConnectPhaseTimer() {
54619        if (connectPhaseTimer) {
54620          clearTimeout(connectPhaseTimer);
54621          connectPhaseTimer = null;
54622        }
54623      }
54624      function createTimeoutError() {
54625        let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
54626        const transitional = config.transitional || transitionalDefaults;
54627        if (config.timeoutErrorMessage) {
54628          timeoutErrorMessage = config.timeoutErrorMessage;
54629        }
54630        return new AxiosError$1(
54631          timeoutErrorMessage,
54632          transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
54633          config,
54634          req
54635        );
54636      }
54637      abortEmitter.once("abort", reject);
54638      const onFinished = () => {
54639        clearConnectPhaseTimer();
54640        if (config.cancelToken) {
54641          config.cancelToken.unsubscribe(abort);
54642        }
54643        if (config.signal) {
54644          config.signal.removeEventListener("abort", abort);
54645        }
54646        abortEmitter.removeAllListeners();
54647      };
54648      if (config.cancelToken || config.signal) {
54649        config.cancelToken && config.cancelToken.subscribe(abort);
54650        if (config.signal) {
54651          config.signal.aborted ? abort() : config.signal.addEventListener("abort", abort);
54652        }
54653      }
54654      onDone((response2, isRejected) => {
54655        isDone = true;
54656        clearConnectPhaseTimer();
54657        if (isRejected) {
54658          rejected = true;
54659          onFinished();
54660          return;
54661        }
54662        const { data: data2 } = response2;
54663        if (data2 instanceof stream.Readable || data2 instanceof stream.Duplex) {
54664          const offListeners = stream.finished(data2, () => {
54665            offListeners();
54666            onFinished();
54667          });
54668        } else {
54669          onFinished();
54670        }
54671      });
54672      const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
54673      const parsed = new URL(fullPath, platform.hasBrowserEnv ? platform.origin : void 0);
54674      const protocol = parsed.protocol || supportedProtocols[0];
54675      if (protocol === "data:") {
54676        if (config.maxContentLength > -1) {
54677          const dataUrl = String(config.url || fullPath || "");
54678          const estimated = estimateDataURLDecodedBytes(dataUrl);
54679          if (estimated > config.maxContentLength) {
54680            return reject(
54681              new AxiosError$1(
54682                "maxContentLength size of " + config.maxContentLength + " exceeded",
54683                AxiosError$1.ERR_BAD_RESPONSE,
54684                config
54685              )
54686            );
54687          }
54688        }
54689        let convertedData;
54690        if (method !== "GET") {
54691          return settle(resolve, reject, {
54692            status: 405,
54693            statusText: "method not allowed",
54694            headers: {},
54695            config
54696          });
54697        }
54698        try {
54699          convertedData = fromDataURI(config.url, responseType === "blob", {
54700            Blob: config.env && config.env.Blob
54701          });
54702        } catch (err) {
54703          throw AxiosError$1.from(err, AxiosError$1.ERR_BAD_REQUEST, config);
54704        }
54705        if (responseType === "text") {
54706          convertedData = convertedData.toString(responseEncoding);
54707          if (!responseEncoding || responseEncoding === "utf8") {
54708            convertedData = utils$5.stripBOM(convertedData);
54709          }
54710        } else if (responseType === "stream") {
54711          convertedData = stream.Readable.from(convertedData);
54712        }
54713        return settle(resolve, reject, {
54714          data: convertedData,
54715          status: 200,
54716          statusText: "OK",
54717          headers: new AxiosHeaders$1(),
54718          config
54719        });
54720      }
54721      if (supportedProtocols.indexOf(protocol) === -1) {
54722        return reject(
54723          new AxiosError$1("Unsupported protocol " + protocol, AxiosError$1.ERR_BAD_REQUEST, config)
54724        );
54725      }
54726      const headers = AxiosHeaders$1.from(config.headers).normalize();
54727      headers.set("User-Agent", "axios/" + VERSION$1, false);
54728      const { onUploadProgress, onDownloadProgress } = config;
54729      const maxRate = config.maxRate;
54730      let maxUploadRate = void 0;
54731      let maxDownloadRate = void 0;
54732      if (utils$5.isSpecCompliantForm(data)) {
54733        const userBoundary = headers.getContentType(/boundary=([-_\w\d]{10,70})/i);
54734        data = formDataToStream(
54735          data,
54736          (formHeaders) => {
54737            headers.set(formHeaders);
54738          },
54739          {
54740            tag: `axios-${VERSION$1}-boundary`,
54741            boundary: userBoundary && userBoundary[1] || void 0
54742          }
54743        );
54744      } else if (utils$5.isFormData(data) && utils$5.isFunction(data.getHeaders) && data.getHeaders !== Object.prototype.getHeaders) {
54745        setFormDataHeaders$1(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
54746        if (!headers.hasContentLength()) {
54747          try {

54748            const knownLength = await util.promisify(data.getLength).call(data);
54749            Number.isFinite(knownLength) && knownLength >= 0 && headers.setContentLength(knownLength);
54750          } catch (e) {
54751          }
54752        }
54753      } else if (utils$5.isBlob(data) || utils$5.isFile(data)) {
54754        data.size && headers.setContentType(data.type || "application/octet-stream");
54755        headers.setContentLength(data.size || 0);
54756        data = stream.Readable.from(readBlob(data));
54757      } else if (data && !utils$5.isStream(data)) {
54758        if (Buffer.isBuffer(data)) ;
54759        else if (utils$5.isArrayBuffer(data)) {
54760          data = Buffer.from(new Uint8Array(data));
54761        } else if (utils$5.isString(data)) {
54762          data = Buffer.from(data, "utf-8");
54763        } else {
54764          return reject(
54765            new AxiosError$1(
54766              "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
54767              AxiosError$1.ERR_BAD_REQUEST,
54768              config
54769            )
54770          );
54771        }
54772        headers.setContentLength(data.length, false);
54773        if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
54774          return reject(
54775            new AxiosError$1(
54776              "Request body larger than maxBodyLength limit",
54777              AxiosError$1.ERR_BAD_REQUEST,
54778              config
54779            )
54780          );
54781        }
54782      }
54783      const contentLength = utils$5.toFiniteNumber(headers.getContentLength());
54784      if (utils$5.isArray(maxRate)) {
54785        maxUploadRate = maxRate[0];
54786        maxDownloadRate = maxRate[1];
54787      } else {
54788        maxUploadRate = maxDownloadRate = maxRate;
54789      }
54790      if (data && (onUploadProgress || maxUploadRate)) {
54791        if (!utils$5.isStream(data)) {
54792          data = stream.Readable.from(data, { objectMode: false });
54793        }
54794        data = stream.pipeline(
54795          [
54796            data,
54797            new AxiosTransformStream({
54798              maxRate: utils$5.toFiniteNumber(maxUploadRate)
54799            })
54800          ],
54801          utils$5.noop
54802        );
54803        onUploadProgress && data.on(
54804          "progress",
54805          flushOnFinish(
54806            data,
54807            progressEventDecorator(
54808              contentLength,
54809              progressEventReducer(asyncDecorator(onUploadProgress), false, 3)
54810            )
54811          )
54812        );
54813      }
54814      let auth = void 0;
54815      const configAuth = own2("auth");
54816      if (configAuth) {
54817        const username = configAuth.username || "";
54818        const password = configAuth.password || "";
54819        auth = username + ":" + password;
54820      }
54821      if (!auth && parsed.username) {
54822        const urlUsername = decodeURIComponentSafe(parsed.username);
54823        const urlPassword = decodeURIComponentSafe(parsed.password);
54824        auth = urlUsername + ":" + urlPassword;
54825      }
54826      auth && headers.delete("authorization");
54827      let path;
54828      try {
54829        path = buildURL(
54830          parsed.pathname + parsed.search,
54831          config.params,
54832          config.paramsSerializer
54833        ).replace(/^\?/, "");
54834      } catch (err) {
54835        const customErr = new Error(err.message);
54836        customErr.config = config;
54837        customErr.url = config.url;
54838        customErr.exists = true;
54839        return reject(customErr);
54840      }
54841      headers.set(
54842        "Accept-Encoding",
54843        "gzip, compress, deflate" + (isBrotliSupported ? ", br" : ""),
54844        false
54845      );
54846      const options = Object.assign(/* @__PURE__ */ Object.create(null), {
54847        path,
54848        method,
54849        headers: headers.toJSON(),
54850        agents: { http: config.httpAgent, https: config.httpsAgent },
54851        auth,
54852        protocol,
54853        family,
54854        beforeRedirect: dispatchBeforeRedirect,
54855        beforeRedirects: /* @__PURE__ */ Object.create(null),
54856        http2Options
54857      });
54858      !utils$5.isUndefined(lookup2) && (options.lookup = lookup2);
54859      if (config.socketPath) {
54860        if (typeof config.socketPath !== "string") {
54861          return reject(
54862            new AxiosError$1("socketPath must be a string", AxiosError$1.ERR_BAD_OPTION_VALUE, config)
54863          );
54864        }
54865        if (config.allowedSocketPaths != null) {
54866          const allowed = Array.isArray(config.allowedSocketPaths) ? config.allowedSocketPaths : [config.allowedSocketPaths];
54867          const resolvedSocket = pathBrowserifyExports.resolve(config.socketPath);
54868          const isAllowed = allowed.some(
54869            (entry) => typeof entry === "string" && pathBrowserifyExports.resolve(entry) === resolvedSocket
54870          );
54871          if (!isAllowed) {
54872            return reject(
54873              new AxiosError$1(
54874                `socketPath "${config.socketPath}" is not permitted by allowedSocketPaths`,
54875                AxiosError$1.ERR_BAD_OPTION_VALUE,
54876                config
54877              )
54878            );
54879          }
54880        }
54881        options.socketPath = config.socketPath;
54882      } else {
54883        options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
54884        options.port = parsed.port;
54885        setProxy(
54886          options,
54887          config.proxy,
54888          protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path
54889        );
54890      }
54891      let transport;

vendor: 8,310 bytes, lines 54892-55112

54892      let isNativeTransport = false;
54893      const isHttpsRequest = isHttps.test(options.protocol);
54894      options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
54895      if (isHttp2) {
54896        transport = http2Transport;
54897      } else {
54898        const configTransport = own2("transport");
54899        if (configTransport) {
54900          transport = configTransport;
54901        } else if (config.maxRedirects === 0) {
54902          transport = isHttpsRequest ? https : http;
54903          isNativeTransport = true;
54904        } else {
54905          if (config.maxRedirects) {
54906            options.maxRedirects = config.maxRedirects;
54907          }
54908          const configBeforeRedirect = own2("beforeRedirect");
54909          if (configBeforeRedirect) {
54910            options.beforeRedirects.config = configBeforeRedirect;
54911          }
54912          transport = isHttpsRequest ? httpsFollow : httpFollow;
54913        }
54914      }
54915      if (config.maxBodyLength > -1) {
54916        options.maxBodyLength = config.maxBodyLength;
54917      } else {
54918        options.maxBodyLength = Infinity;
54919      }
54920      options.insecureHTTPParser = Boolean(own2("insecureHTTPParser"));
54921      req = transport.request(options, function handleResponse(res) {
54922        clearConnectPhaseTimer();
54923        if (req.destroyed) return;
54924        const streams = [res];
54925        const responseLength = utils$5.toFiniteNumber(res.headers["content-length"]);
54926        if (onDownloadProgress || maxDownloadRate) {
54927          const transformStream = new AxiosTransformStream({
54928            maxRate: utils$5.toFiniteNumber(maxDownloadRate)
54929          });
54930          onDownloadProgress && transformStream.on(
54931            "progress",
54932            flushOnFinish(
54933              transformStream,
54934              progressEventDecorator(
54935                responseLength,
54936                progressEventReducer(asyncDecorator(onDownloadProgress), true, 3)
54937              )
54938            )
54939          );
54940          streams.push(transformStream);
54941        }
54942        let responseStream = res;
54943        const lastRequest = res.req || req;
54944        if (config.decompress !== false && res.headers["content-encoding"]) {
54945          if (method === "HEAD" || res.statusCode === 204) {
54946            delete res.headers["content-encoding"];
54947          }
54948          switch ((res.headers["content-encoding"] || "").toLowerCase()) {
54949            /*eslint default-case:0*/
54950            case "gzip":
54951            case "x-gzip":
54952            case "compress":
54953            case "x-compress":
54954              streams.push(zlib.createUnzip(zlibOptions));
54955              delete res.headers["content-encoding"];
54956              break;
54957            case "deflate":
54958              streams.push(new ZlibHeaderTransformStream());
54959              streams.push(zlib.createUnzip(zlibOptions));
54960              delete res.headers["content-encoding"];
54961              break;
54962            case "br":
54963              if (isBrotliSupported) {
54964                streams.push(zlib.createBrotliDecompress(brotliOptions));
54965                delete res.headers["content-encoding"];
54966              }
54967          }
54968        }
54969        responseStream = streams.length > 1 ? stream.pipeline(streams, utils$5.noop) : streams[0];
54970        const response2 = {
54971          status: res.statusCode,
54972          statusText: res.statusMessage,
54973          headers: new AxiosHeaders$1(res.headers),
54974          config,
54975          request: lastRequest
54976        };
54977        if (responseType === "stream") {
54978          if (config.maxContentLength > -1) {
54979            const limit = config.maxContentLength;
54980            const source = responseStream;
54981            async function* enforceMaxContentLength() {
54982              let totalResponseBytes = 0;
54983              for await (const chunk of source) {
54984                totalResponseBytes += chunk.length;
54985                if (totalResponseBytes > limit) {
54986                  throw new AxiosError$1(
54987                    "maxContentLength size of " + limit + " exceeded",
54988                    AxiosError$1.ERR_BAD_RESPONSE,
54989                    config,
54990                    lastRequest
54991                  );
54992                }
54993                yield chunk;
54994              }
54995            }
54996            responseStream = stream.Readable.from(enforceMaxContentLength(), {
54997              objectMode: false
54998            });
54999          }
55000          response2.data = responseStream;
55001          settle(resolve, reject, response2);
55002        } else {
55003          const responseBuffer = [];
55004          let totalResponseBytes = 0;
55005          responseStream.on("data", function handleStreamData(chunk) {
55006            responseBuffer.push(chunk);
55007            totalResponseBytes += chunk.length;
55008            if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
55009              rejected = true;
55010              responseStream.destroy();
55011              abort(
55012                new AxiosError$1(
55013                  "maxContentLength size of " + config.maxContentLength + " exceeded",
55014                  AxiosError$1.ERR_BAD_RESPONSE,
55015                  config,
55016                  lastRequest
55017                )
55018              );
55019            }
55020          });
55021          responseStream.on("aborted", function handlerStreamAborted() {
55022            if (rejected) {
55023              return;
55024            }
55025            const err = new AxiosError$1(
55026              "stream has been aborted",
55027              AxiosError$1.ERR_BAD_RESPONSE,
55028              config,
55029              lastRequest,
55030              response2
55031            );
55032            responseStream.destroy(err);
55033            reject(err);
55034          });
55035          responseStream.on("error", function handleStreamError(err) {
55036            if (rejected) return;
55037            reject(AxiosError$1.from(err, null, config, lastRequest, response2));
55038          });
55039          responseStream.on("end", function handleStreamEnd() {
55040            try {
55041              let responseData = responseBuffer.length === 1 ? responseBuffer[0] : Buffer.concat(responseBuffer);
55042              if (responseType !== "arraybuffer") {
55043                responseData = responseData.toString(responseEncoding);
55044                if (!responseEncoding || responseEncoding === "utf8") {
55045                  responseData = utils$5.stripBOM(responseData);
55046                }
55047              }
55048              response2.data = responseData;
55049            } catch (err) {
55050              return reject(AxiosError$1.from(err, null, config, response2.request, response2));
55051            }
55052            settle(resolve, reject, response2);
55053          });
55054        }
55055        abortEmitter.once("abort", (err) => {
55056          if (!responseStream.destroyed) {
55057            responseStream.emit("error", err);
55058            responseStream.destroy();
55059          }
55060        });
55061      });
55062      abortEmitter.once("abort", (err) => {
55063        if (req.close) {
55064          req.close();
55065        } else {
55066          req.destroy(err);
55067        }
55068      });
55069      req.on("error", function handleRequestError(err) {
55070        reject(AxiosError$1.from(err, null, config, req));
55071      });
55072      const boundSockets = /* @__PURE__ */ new Set();
55073      req.on("socket", function handleRequestSocket(socket) {
55074        socket.setKeepAlive(true, 1e3 * 60);
55075        if (!socket[kAxiosSocketListener]) {
55076          socket.on("error", function handleSocketError(err) {
55077            const current = socket[kAxiosCurrentReq];
55078            if (current && !current.destroyed) {
55079              current.destroy(err);
55080            }
55081          });
55082          socket[kAxiosSocketListener] = true;
55083        }
55084        socket[kAxiosCurrentReq] = req;
55085        boundSockets.add(socket);
55086      });
55087      req.once("close", function clearCurrentReq() {
55088        clearConnectPhaseTimer();
55089        for (const socket of boundSockets) {
55090          if (socket[kAxiosCurrentReq] === req) {
55091            socket[kAxiosCurrentReq] = null;
55092          }
55093        }
55094        boundSockets.clear();
55095      });
55096      if (config.timeout) {
55097        const timeout = parseInt(config.timeout, 10);
55098        if (Number.isNaN(timeout)) {
55099          abort(
55100            new AxiosError$1(
55101              "error trying to parse `config.timeout` to int",
55102              AxiosError$1.ERR_BAD_OPTION_VALUE,
55103              config,
55104              req
55105            )
55106          );
55107          return;
55108        }
55109        const handleTimeout = function handleTimeout2() {
55110          if (isDone) return;
55111          abort(createTimeoutError());
55112        };

55113        if (isNativeTransport && timeout > 0) {
55114          connectPhaseTimer = setTimeout(handleTimeout, timeout);
55115        }
55116        req.setTimeout(timeout, handleTimeout);
55117      } else {
55118        req.setTimeout(0);
55119      }
55120      if (utils$5.isStream(data)) {
55121        let ended = false;
55122        let errored = false;
55123        data.on("end", () => {
55124          ended = true;
55125        });
55126        data.once("error", (err) => {
55127          errored = true;
55128          req.destroy(err);
55129        });
55130        data.on("close", () => {
55131          if (!ended && !errored) {
55132            abort(new CanceledError$1("Request stream has been aborted", config, req));
55133          }
55134        });
55135        let uploadStream = data;
55136        if (config.maxBodyLength > -1 && config.maxRedirects === 0) {
55137          const limit = config.maxBodyLength;
55138          let bytesSent = 0;
55139          uploadStream = stream.pipeline(
55140            [
55141              data,
55142              new stream.Transform({
55143                transform(chunk, _enc, cb) {
55144                  bytesSent += chunk.length;
55145                  if (bytesSent > limit) {
55146                    return cb(
55147                      new AxiosError$1(
55148                        "Request body larger than maxBodyLength limit",
55149                        AxiosError$1.ERR_BAD_REQUEST,
55150                        config,
55151                        req
55152                      )
55153                    );
55154                  }
55155                  cb(null, chunk);
55156                }
55157              })
55158            ],
55159            utils$5.noop
55160          );
55161          uploadStream.on("error", (err) => {
55162            if (!req.destroyed) req.destroy(err);
55163          });
55164        }
55165        uploadStream.pipe(req);
55166      } else {
55167        data && req.write(data);
55168        req.end();
55169      }
55170    });
55171  };
55172  const isURLSameOrigin = platform.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url2) => {
55173    url2 = new URL(url2, platform.origin);
55174    return origin2.protocol === url2.protocol && origin2.host === url2.host && (isMSIE || origin2.port === url2.port);
55175  })(
55176    new URL(platform.origin),
55177    platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
55178  ) : () => true;
55179  const cookies = platform.hasStandardBrowserEnv ? (
55180    // Standard browser envs support document.cookie
55181    {
55182      write(name, value, expires, path, domain, secure, sameSite) {
55183        if (typeof document === "undefined") return;
55184        const cookie = [`${name}=${encodeURIComponent(value)}`];
55185        if (utils$5.isNumber(expires)) {
55186          cookie.push(`expires=${new Date(expires).toUTCString()}`);
55187        }
55188        if (utils$5.isString(path)) {
55189          cookie.push(`path=${path}`);
55190        }
55191        if (utils$5.isString(domain)) {
55192          cookie.push(`domain=${domain}`);
55193        }
55194        if (secure === true) {
55195          cookie.push("secure");
55196        }
55197        if (utils$5.isString(sameSite)) {
55198          cookie.push(`SameSite=${sameSite}`);
55199        }
55200        document.cookie = cookie.join("; ");
55201      },
55202      read(name) {
55203        if (typeof document === "undefined") return null;
55204        const cookies2 = document.cookie.split(";");
55205        for (let i2 = 0; i2 < cookies2.length; i2++) {
55206          const cookie = cookies2[i2].replace(/^\s+/, "");
55207          const eq = cookie.indexOf("=");
55208          if (eq !== -1 && cookie.slice(0, eq) === name) {
55209            return decodeURIComponent(cookie.slice(eq + 1));
55210          }
55211        }
55212        return null;
55213      },
55214      remove(name) {
55215        this.write(name, "", Date.now() - 864e5, "/");
55216      }
55217    }
55218  ) : (
55219    // Non-standard browser env (web workers, react-native) lack needed support.
55220    {
55221      write() {
55222      },
55223      read() {
55224        return null;
55225      },
55226      remove() {
55227      }
55228    }
55229  );
55230  const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
55231  function mergeConfig$1(config1, config2) {
55232    config2 = config2 || {};
55233    const config = /* @__PURE__ */ Object.create(null);
55234    Object.defineProperty(config, "hasOwnProperty", {
55235      // Null-proto descriptor so a polluted Object.prototype.get cannot turn
55236      // this data descriptor into an accessor descriptor on the way in.
55237      __proto__: null,
55238      value: Object.prototype.hasOwnProperty,
55239      enumerable: false,
55240      writable: true,
55241      configurable: true
55242    });
55243    function getMergedValue(target, source, prop, caseless) {
55244      if (utils$5.isPlainObject(target) && utils$5.isPlainObject(source)) {
55245        return utils$5.merge.call({ caseless }, target, source);
55246      } else if (utils$5.isPlainObject(source)) {

vendor: 10,654 bytes, lines 55247-55527

55247        return utils$5.merge({}, source);
55248      } else if (utils$5.isArray(source)) {
55249        return source.slice();
55250      }
55251      return source;
55252    }
55253    function mergeDeepProperties(a, b, prop, caseless) {
55254      if (!utils$5.isUndefined(b)) {
55255        return getMergedValue(a, b, prop, caseless);
55256      } else if (!utils$5.isUndefined(a)) {
55257        return getMergedValue(void 0, a, prop, caseless);
55258      }
55259    }
55260    function valueFromConfig2(a, b) {
55261      if (!utils$5.isUndefined(b)) {
55262        return getMergedValue(void 0, b);
55263      }
55264    }
55265    function defaultToConfig2(a, b) {
55266      if (!utils$5.isUndefined(b)) {
55267        return getMergedValue(void 0, b);
55268      } else if (!utils$5.isUndefined(a)) {
55269        return getMergedValue(void 0, a);
55270      }
55271    }
55272    function mergeDirectKeys(a, b, prop) {
55273      if (utils$5.hasOwnProp(config2, prop)) {
55274        return getMergedValue(a, b);
55275      } else if (utils$5.hasOwnProp(config1, prop)) {
55276        return getMergedValue(void 0, a);
55277      }
55278    }
55279    const mergeMap = {
55280      url: valueFromConfig2,
55281      method: valueFromConfig2,
55282      data: valueFromConfig2,
55283      baseURL: defaultToConfig2,
55284      transformRequest: defaultToConfig2,
55285      transformResponse: defaultToConfig2,
55286      paramsSerializer: defaultToConfig2,
55287      timeout: defaultToConfig2,
55288      timeoutMessage: defaultToConfig2,
55289      withCredentials: defaultToConfig2,
55290      withXSRFToken: defaultToConfig2,
55291      adapter: defaultToConfig2,
55292      responseType: defaultToConfig2,
55293      xsrfCookieName: defaultToConfig2,
55294      xsrfHeaderName: defaultToConfig2,
55295      onUploadProgress: defaultToConfig2,
55296      onDownloadProgress: defaultToConfig2,
55297      decompress: defaultToConfig2,
55298      maxContentLength: defaultToConfig2,
55299      maxBodyLength: defaultToConfig2,
55300      beforeRedirect: defaultToConfig2,
55301      transport: defaultToConfig2,
55302      httpAgent: defaultToConfig2,
55303      httpsAgent: defaultToConfig2,
55304      cancelToken: defaultToConfig2,
55305      socketPath: defaultToConfig2,
55306      allowedSocketPaths: defaultToConfig2,
55307      responseEncoding: defaultToConfig2,
55308      validateStatus: mergeDirectKeys,
55309      headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
55310    };
55311    utils$5.forEach(Object.keys({ ...config1, ...config2 }), function computeConfigValue(prop) {
55312      if (prop === "__proto__" || prop === "constructor" || prop === "prototype") return;
55313      const merge2 = utils$5.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
55314      const a = utils$5.hasOwnProp(config1, prop) ? config1[prop] : void 0;
55315      const b = utils$5.hasOwnProp(config2, prop) ? config2[prop] : void 0;
55316      const configValue = merge2(a, b, prop);
55317      utils$5.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
55318    });
55319    return config;
55320  }
55321  const FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
55322  function setFormDataHeaders(headers, formHeaders, policy) {
55323    if (policy !== "content-only") {
55324      headers.set(formHeaders);
55325      return;
55326    }
55327    Object.entries(formHeaders).forEach(([key2, val]) => {
55328      if (FORM_DATA_CONTENT_HEADERS.includes(key2.toLowerCase())) {
55329        headers.set(key2, val);
55330      }
55331    });
55332  }
55333  const encodeUTF8 = (str) => encodeURIComponent(str).replace(
55334    /%([0-9A-F]{2})/gi,
55335    (_2, hex) => String.fromCharCode(parseInt(hex, 16))
55336  );
55337  const resolveConfig = (config) => {
55338    const newConfig = mergeConfig$1({}, config);
55339    const own2 = (key2) => utils$5.hasOwnProp(newConfig, key2) ? newConfig[key2] : void 0;
55340    const data = own2("data");
55341    let withXSRFToken = own2("withXSRFToken");
55342    const xsrfHeaderName = own2("xsrfHeaderName");
55343    const xsrfCookieName = own2("xsrfCookieName");
55344    let headers = own2("headers");
55345    const auth = own2("auth");
55346    const baseURL = own2("baseURL");
55347    const allowAbsoluteUrls = own2("allowAbsoluteUrls");
55348    const url2 = own2("url");
55349    newConfig.headers = headers = AxiosHeaders$1.from(headers);
55350    newConfig.url = buildURL(
55351      buildFullPath(baseURL, url2, allowAbsoluteUrls),
55352      config.params,
55353      config.paramsSerializer
55354    );
55355    if (auth) {
55356      headers.set(
55357        "Authorization",
55358        "Basic " + btoa((auth.username || "") + ":" + (auth.password ? encodeUTF8(auth.password) : ""))
55359      );
55360    }
55361    if (utils$5.isFormData(data)) {
55362      if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
55363        headers.setContentType(void 0);
55364      } else if (utils$5.isFunction(data.getHeaders)) {
55365        setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
55366      }
55367    }
55368    if (platform.hasStandardBrowserEnv) {
55369      if (utils$5.isFunction(withXSRFToken)) {
55370        withXSRFToken = withXSRFToken(newConfig);
55371      }
55372      const shouldSendXSRF = withXSRFToken === true || withXSRFToken == null && isURLSameOrigin(newConfig.url);
55373      if (shouldSendXSRF) {
55374        const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
55375        if (xsrfValue) {
55376          headers.set(xsrfHeaderName, xsrfValue);
55377        }
55378      }
55379    }
55380    return newConfig;
55381  };
55382  const isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
55383  const xhrAdapter = isXHRAdapterSupported && function(config) {
55384    return new Promise(function dispatchXhrRequest(resolve, reject) {
55385      const _config = resolveConfig(config);
55386      let requestData = _config.data;
55387      const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
55388      let { responseType, onUploadProgress, onDownloadProgress } = _config;
55389      let onCanceled;
55390      let uploadThrottled, downloadThrottled;
55391      let flushUpload, flushDownload;
55392      function done() {
55393        flushUpload && flushUpload();
55394        flushDownload && flushDownload();
55395        _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
55396        _config.signal && _config.signal.removeEventListener("abort", onCanceled);
55397      }
55398      let request2 = new XMLHttpRequest();
55399      request2.open(_config.method.toUpperCase(), _config.url, true);
55400      request2.timeout = _config.timeout;
55401      function onloadend() {
55402        if (!request2) {
55403          return;
55404        }
55405        const responseHeaders = AxiosHeaders$1.from(
55406          "getAllResponseHeaders" in request2 && request2.getAllResponseHeaders()
55407        );
55408        const responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response;
55409        const response2 = {
55410          data: responseData,
55411          status: request2.status,
55412          statusText: request2.statusText,
55413          headers: responseHeaders,
55414          config,
55415          request: request2
55416        };
55417        settle(
55418          function _resolve(value) {
55419            resolve(value);
55420            done();
55421          },
55422          function _reject(err) {
55423            reject(err);
55424            done();
55425          },
55426          response2
55427        );
55428        request2 = null;
55429      }
55430      if ("onloadend" in request2) {
55431        request2.onloadend = onloadend;
55432      } else {
55433        request2.onreadystatechange = function handleLoad() {
55434          if (!request2 || request2.readyState !== 4) {
55435            return;
55436          }
55437          if (request2.status === 0 && !(request2.responseURL && request2.responseURL.startsWith("file:"))) {
55438            return;
55439          }
55440          setTimeout(onloadend);
55441        };
55442      }
55443      request2.onabort = function handleAbort() {
55444        if (!request2) {
55445          return;
55446        }
55447        reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request2));
55448        done();
55449        request2 = null;
55450      };
55451      request2.onerror = function handleError(event) {
55452        const msg = event && event.message ? event.message : "Network Error";
55453        const err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config, request2);
55454        err.event = event || null;
55455        reject(err);
55456        done();
55457        request2 = null;
55458      };
55459      request2.ontimeout = function handleTimeout() {
55460        let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
55461        const transitional = _config.transitional || transitionalDefaults;
55462        if (_config.timeoutErrorMessage) {
55463          timeoutErrorMessage = _config.timeoutErrorMessage;
55464        }
55465        reject(
55466          new AxiosError$1(
55467            timeoutErrorMessage,
55468            transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
55469            config,
55470            request2
55471          )
55472        );
55473        done();
55474        request2 = null;
55475      };
55476      requestData === void 0 && requestHeaders.setContentType(null);
55477      if ("setRequestHeader" in request2) {
55478        utils$5.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key2) {
55479          request2.setRequestHeader(key2, val);
55480        });
55481      }
55482      if (!utils$5.isUndefined(_config.withCredentials)) {
55483        request2.withCredentials = !!_config.withCredentials;
55484      }
55485      if (responseType && responseType !== "json") {
55486        request2.responseType = _config.responseType;
55487      }
55488      if (onDownloadProgress) {
55489        [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
55490        request2.addEventListener("progress", downloadThrottled);
55491      }
55492      if (onUploadProgress && request2.upload) {
55493        [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
55494        request2.upload.addEventListener("progress", uploadThrottled);
55495        request2.upload.addEventListener("loadend", flushUpload);
55496      }
55497      if (_config.cancelToken || _config.signal) {
55498        onCanceled = (cancel) => {
55499          if (!request2) {
55500            return;
55501          }
55502          reject(!cancel || cancel.type ? new CanceledError$1(null, config, request2) : cancel);
55503          request2.abort();
55504          done();
55505          request2 = null;
55506        };
55507        _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
55508        if (_config.signal) {
55509          _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
55510        }
55511      }
55512      const protocol = parseProtocol(_config.url);
55513      if (protocol && !platform.protocols.includes(protocol)) {
55514        reject(
55515          new AxiosError$1(
55516            "Unsupported protocol " + protocol + ":",
55517            AxiosError$1.ERR_BAD_REQUEST,
55518            config
55519          )
55520        );
55521        return;
55522      }
55523      request2.send(requestData || null);
55524    });
55525  };
55526  const composeSignals = (signals, timeout) => {
55527    const { length }

vendor: 4,163 bytes, lines 55527-55669

55527 = signals = signals ? signals.filter(Boolean) : [];
55528    if (timeout || length) {
55529      let controller = new AbortController();
55530      let aborted;
55531      const onabort = function(reason) {
55532        if (!aborted) {
55533          aborted = true;
55534          unsubscribe();
55535          const err = reason instanceof Error ? reason : this.reason;
55536          controller.abort(
55537            err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err)
55538          );
55539        }
55540      };
55541      let timer = timeout && setTimeout(() => {
55542        timer = null;
55543        onabort(new AxiosError$1(`timeout of ${timeout}ms exceeded`, AxiosError$1.ETIMEDOUT));
55544      }, timeout);
55545      const unsubscribe = () => {
55546        if (signals) {
55547          timer && clearTimeout(timer);
55548          timer = null;
55549          signals.forEach((signal2) => {
55550            signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
55551          });
55552          signals = null;
55553        }
55554      };
55555      signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
55556      const { signal } = controller;
55557      signal.unsubscribe = () => utils$5.asap(unsubscribe);
55558      return signal;
55559    }
55560  };
55561  const streamChunk = function* (chunk, chunkSize) {
55562    let len2 = chunk.byteLength;
55563    if (len2 < chunkSize) {
55564      yield chunk;
55565      return;
55566    }
55567    let pos = 0;
55568    let end;
55569    while (pos < len2) {
55570      end = pos + chunkSize;
55571      yield chunk.slice(pos, end);
55572      pos = end;
55573    }
55574  };
55575  const readBytes = async function* (iterable, chunkSize) {
55576    for await (const chunk of readStream(iterable)) {
55577      yield* streamChunk(chunk, chunkSize);
55578    }
55579  };
55580  const readStream = async function* (stream2) {
55581    if (stream2[Symbol.asyncIterator]) {
55582      yield* stream2;
55583      return;
55584    }
55585    const reader = stream2.getReader();
55586    try {
55587      for (; ; ) {
55588        const { done, value } = await reader.read();
55589        if (done) {
55590          break;
55591        }
55592        yield value;
55593      }
55594    } finally {
55595      await reader.cancel();
55596    }
55597  };
55598  const trackStream = (stream2, chunkSize, onProgress, onFinish) => {
55599    const iterator2 = readBytes(stream2, chunkSize);
55600    let bytes = 0;
55601    let done;
55602    let _onFinish = (e) => {
55603      if (!done) {
55604        done = true;
55605        onFinish && onFinish(e);
55606      }
55607    };
55608    return new ReadableStream(
55609      {
55610        async pull(controller) {
55611          try {
55612            const { done: done2, value } = await iterator2.next();
55613            if (done2) {
55614              _onFinish();
55615              controller.close();
55616              return;
55617            }
55618            let len2 = value.byteLength;
55619            if (onProgress) {
55620              let loadedBytes = bytes += len2;
55621              onProgress(loadedBytes);
55622            }
55623            controller.enqueue(new Uint8Array(value));
55624          } catch (err) {
55625            _onFinish(err);
55626            throw err;
55627          }
55628        },
55629        cancel(reason) {
55630          _onFinish(reason);
55631          return iterator2.return();
55632        }
55633      },
55634      {
55635        highWaterMark: 2
55636      }
55637    );
55638  };
55639  const DEFAULT_CHUNK_SIZE = 64 * 1024;
55640  const { isFunction } = utils$5;
55641  const test = (fn, ...args) => {
55642    try {
55643      return !!fn(...args);
55644    } catch (e) {
55645      return false;
55646    }
55647  };
55648  const factory = (env) => {
55649    const globalObject = utils$5.global ?? globalThis;
55650    const { ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = globalObject;
55651    env = utils$5.merge.call(
55652      {
55653        skipUndefined: true
55654      },
55655      {
55656        Request: globalObject.Request,
55657        Response: globalObject.Response
55658      },
55659      env
55660    );
55661    const { fetch: envFetch, Request, Response } = env;
55662    const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === "function";
55663    const isRequestSupported = isFunction(Request);
55664    const isResponseSupported = isFunction(Response);
55665    if (!isFetchSupported) {
55666      return false;
55667    }
55668    const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream2);
55669    const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? /* @__P

vendor: 3,307 bytes, lines 55669-55762

55669URE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
55670    const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
55671      let duplexAccessed = false;
55672      const request2 = new Request(platform.origin, {
55673        body: new ReadableStream2(),
55674        method: "POST",
55675        get duplex() {
55676          duplexAccessed = true;
55677          return "half";
55678        }
55679      });
55680      const hasContentType = request2.headers.has("Content-Type");
55681      if (request2.body != null) {
55682        request2.body.cancel();
55683      }
55684      return duplexAccessed && !hasContentType;
55685    });
55686    const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils$5.isReadableStream(new Response("").body));
55687    const resolvers = {
55688      stream: supportsResponseStream && ((res) => res.body)
55689    };
55690    isFetchSupported && (() => {
55691      ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type2) => {
55692        !resolvers[type2] && (resolvers[type2] = (res, config) => {
55693          let method = res && res[type2];
55694          if (method) {
55695            return method.call(res);
55696          }
55697          throw new AxiosError$1(
55698            `Response type '${type2}' is not supported`,
55699            AxiosError$1.ERR_NOT_SUPPORT,
55700            config
55701          );
55702        });
55703      });
55704    })();
55705    const getBodyLength = async (body) => {
55706      if (body == null) {
55707        return 0;
55708      }
55709      if (utils$5.isBlob(body)) {
55710        return body.size;
55711      }
55712      if (utils$5.isSpecCompliantForm(body)) {
55713        const _request = new Request(platform.origin, {
55714          method: "POST",
55715          body
55716        });
55717        return (await _request.arrayBuffer()).byteLength;
55718      }
55719      if (utils$5.isArrayBufferView(body) || utils$5.isArrayBuffer(body)) {
55720        return body.byteLength;
55721      }
55722      if (utils$5.isURLSearchParams(body)) {
55723        body = body + "";
55724      }
55725      if (utils$5.isString(body)) {
55726        return (await encodeText(body)).byteLength;
55727      }
55728    };
55729    const resolveBodyLength = async (headers, body) => {
55730      const length = utils$5.toFiniteNumber(headers.getContentLength());
55731      return length == null ? getBodyLength(body) : length;
55732    };
55733    return async (config) => {
55734      let {
55735        url: url2,
55736        method,
55737        data,
55738        signal,
55739        cancelToken,
55740        timeout,
55741        onDownloadProgress,
55742        onUploadProgress,
55743        responseType,
55744        headers,
55745        withCredentials = "same-origin",
55746        fetchOptions,
55747        maxContentLength,
55748        maxBodyLength
55749      } = resolveConfig(config);
55750      const hasMaxContentLength = utils$5.isNumber(maxContentLength) && maxContentLength > -1;
55751      const hasMaxBodyLength = utils$5.isNumber(maxBodyLength) && maxBodyLength > -1;
55752      let _fetch = envFetch || fetch;
55753      responseType = responseType ? (responseType + "").toLowerCase() : "text";
55754      let composedSignal = composeSignals(
55755        [signal, cancelToken && cancelToken.toAbortSignal()],
55756        timeout
55757      );
55758      let request2 = null;
55759      const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
55760        composedSignal.unsubscribe();
55761      });
55762      let requestContentLength;

vendor: 7,681 bytes, lines 55763-55942

55763      try {
55764        if (hasMaxContentLength && typeof url2 === "string" && url2.startsWith("data:")) {
55765          const estimated = estimateDataURLDecodedBytes(url2);
55766          if (estimated > maxContentLength) {
55767            throw new AxiosError$1(
55768              "maxContentLength size of " + maxContentLength + " exceeded",
55769              AxiosError$1.ERR_BAD_RESPONSE,
55770              config,
55771              request2
55772            );
55773          }
55774        }
55775        if (hasMaxBodyLength && method !== "get" && method !== "head") {
55776          const outboundLength = await resolveBodyLength(headers, data);
55777          if (typeof outboundLength === "number" && isFinite(outboundLength) && outboundLength > maxBodyLength) {
55778            throw new AxiosError$1(
55779              "Request body larger than maxBodyLength limit",
55780              AxiosError$1.ERR_BAD_REQUEST,
55781              config,
55782              request2
55783            );
55784          }
55785        }
55786        if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
55787          let _request = new Request(url2, {
55788            method: "POST",
55789            body: data,
55790            duplex: "half"
55791          });
55792          let contentTypeHeader;
55793          if (utils$5.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
55794            headers.setContentType(contentTypeHeader);
55795          }
55796          if (_request.body) {
55797            const [onProgress, flush] = progressEventDecorator(
55798              requestContentLength,
55799              progressEventReducer(asyncDecorator(onUploadProgress))
55800            );
55801            data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
55802          }
55803        }
55804        if (!utils$5.isString(withCredentials)) {
55805          withCredentials = withCredentials ? "include" : "omit";
55806        }
55807        const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
55808        if (utils$5.isFormData(data)) {
55809          const contentType2 = headers.getContentType();
55810          if (contentType2 && /^multipart\/form-data/i.test(contentType2) && !/boundary=/i.test(contentType2)) {
55811            headers.delete("content-type");
55812          }
55813        }
55814        headers.set("User-Agent", "axios/" + VERSION$1, false);
55815        const resolvedOptions = {
55816          ...fetchOptions,
55817          signal: composedSignal,
55818          method: method.toUpperCase(),
55819          headers: headers.normalize().toJSON(),
55820          body: data,
55821          duplex: "half",
55822          credentials: isCredentialsSupported ? withCredentials : void 0
55823        };
55824        request2 = isRequestSupported && new Request(url2, resolvedOptions);
55825        let response2 = await (isRequestSupported ? _fetch(request2, fetchOptions) : _fetch(url2, resolvedOptions));
55826        if (hasMaxContentLength) {
55827          const declaredLength = utils$5.toFiniteNumber(response2.headers.get("content-length"));
55828          if (declaredLength != null && declaredLength > maxContentLength) {
55829            throw new AxiosError$1(
55830              "maxContentLength size of " + maxContentLength + " exceeded",
55831              AxiosError$1.ERR_BAD_RESPONSE,
55832              config,
55833              request2
55834            );
55835          }
55836        }
55837        const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
55838        if (supportsResponseStream && response2.body && (onDownloadProgress || hasMaxContentLength || isStreamResponse && unsubscribe)) {
55839          const options = {};
55840          ["status", "statusText", "headers"].forEach((prop) => {
55841            options[prop] = response2[prop];
55842          });
55843          const responseContentLength = utils$5.toFiniteNumber(response2.headers.get("content-length"));
55844          const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
55845            responseContentLength,
55846            progressEventReducer(asyncDecorator(onDownloadProgress), true)
55847          ) || [];
55848          let bytesRead = 0;
55849          const onChunkProgress = (loadedBytes) => {
55850            if (hasMaxContentLength) {
55851              bytesRead = loadedBytes;
55852              if (bytesRead > maxContentLength) {
55853                throw new AxiosError$1(
55854                  "maxContentLength size of " + maxContentLength + " exceeded",
55855                  AxiosError$1.ERR_BAD_RESPONSE,
55856                  config,
55857                  request2
55858                );
55859              }
55860            }
55861            onProgress && onProgress(loadedBytes);
55862          };
55863          response2 = new Response(
55864            trackStream(response2.body, DEFAULT_CHUNK_SIZE, onChunkProgress, () => {
55865              flush && flush();
55866              unsubscribe && unsubscribe();
55867            }),
55868            options
55869          );
55870        }
55871        responseType = responseType || "text";
55872        let responseData = await resolvers[utils$5.findKey(resolvers, responseType) || "text"](
55873          response2,
55874          config
55875        );
55876        if (hasMaxContentLength && !supportsResponseStream && !isStreamResponse) {
55877          let materializedSize;
55878          if (responseData != null) {
55879            if (typeof responseData.byteLength === "number") {
55880              materializedSize = responseData.byteLength;
55881            } else if (typeof responseData.size === "number") {
55882              materializedSize = responseData.size;
55883            } else if (typeof responseData === "string") {
55884              materializedSize = typeof TextEncoder2 === "function" ? new TextEncoder2().encode(responseData).byteLength : responseData.length;
55885            }
55886          }
55887          if (typeof materializedSize === "number" && materializedSize > maxContentLength) {
55888            throw new AxiosError$1(
55889              "maxContentLength size of " + maxContentLength + " exceeded",
55890              AxiosError$1.ERR_BAD_RESPONSE,
55891              config,
55892              request2
55893            );
55894          }
55895        }
55896        !isStreamResponse && unsubscribe && unsubscribe();
55897        return await new Promise((resolve, reject) => {
55898          settle(resolve, reject, {
55899            data: responseData,
55900            headers: AxiosHeaders$1.from(response2.headers),
55901            status: response2.status,
55902            statusText: response2.statusText,
55903            config,
55904            request: request2
55905          });
55906        });
55907      } catch (err) {
55908        unsubscribe && unsubscribe();
55909        if (composedSignal && composedSignal.aborted && composedSignal.reason instanceof AxiosError$1) {
55910          const canceledError = composedSignal.reason;
55911          canceledError.config = config;
55912          request2 && (canceledError.request = request2);
55913          err !== canceledError && (canceledError.cause = err);
55914          throw canceledError;
55915        }
55916        if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
55917          throw Object.assign(
55918            new AxiosError$1(
55919              "Network Error",
55920              AxiosError$1.ERR_NETWORK,
55921              config,
55922              request2,
55923              err && err.response
55924            ),
55925            {
55926              cause: err.cause || err
55927            }
55928          );
55929        }
55930        throw AxiosError$1.from(err, err && err.code, config, request2, err && err.response);
55931      }
55932    };
55933  };
55934  const seedCache = /* @__PURE__ */ new Map();
55935  const getFetch = (config) => {
55936    let env = config && config.env || {};
55937    const { fetch: fetch2, Request, Response } = env;
55938    const seeds = [Request, Response, fetch2];
55939    let len2 = seeds.length, i2 = len2, seed, target, map = seedCache;
55940    while (i2--) {
55941      seed = seeds[i2];
55942      target = map.get(seed);

vendor: 5,597 bytes, lines 55943-56100

55943      target === void 0 && map.set(seed, target = i2 ? /* @__PURE__ */ new Map() : factory(env));
55944      map = target;
55945    }
55946    return target;
55947  };
55948  getFetch();
55949  const knownAdapters = {
55950    http: httpAdapter,
55951    xhr: xhrAdapter,
55952    fetch: {
55953      get: getFetch
55954    }
55955  };
55956  utils$5.forEach(knownAdapters, (fn, value) => {
55957    if (fn) {
55958      try {
55959        Object.defineProperty(fn, "name", { __proto__: null, value });
55960      } catch (e) {
55961      }
55962      Object.defineProperty(fn, "adapterName", { __proto__: null, value });
55963    }
55964  });
55965  const renderReason = (reason) => `- ${reason}`;
55966  const isResolvedHandle = (adapter) => utils$5.isFunction(adapter) || adapter === null || adapter === false;
55967  function getAdapter$1(adapters2, config) {
55968    adapters2 = utils$5.isArray(adapters2) ? adapters2 : [adapters2];
55969    const { length } = adapters2;
55970    let nameOrAdapter;
55971    let adapter;
55972    const rejectedReasons = {};
55973    for (let i2 = 0; i2 < length; i2++) {
55974      nameOrAdapter = adapters2[i2];
55975      let id;
55976      adapter = nameOrAdapter;
55977      if (!isResolvedHandle(nameOrAdapter)) {
55978        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
55979        if (adapter === void 0) {
55980          throw new AxiosError$1(`Unknown adapter '${id}'`);
55981        }
55982      }
55983      if (adapter && (utils$5.isFunction(adapter) || (adapter = adapter.get(config)))) {
55984        break;
55985      }
55986      rejectedReasons[id || "#" + i2] = adapter;
55987    }
55988    if (!adapter) {
55989      const reasons = Object.entries(rejectedReasons).map(
55990        ([id, state2]) => `adapter ${id} ` + (state2 === false ? "is not supported by the environment" : "is not available in the build")
55991      );
55992      let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
55993      throw new AxiosError$1(
55994        `There is no suitable adapter to dispatch the request ` + s,
55995        "ERR_NOT_SUPPORT"
55996      );
55997    }
55998    return adapter;
55999  }
56000  const adapters = {
56001    /**
56002     * Resolve an adapter from a list of adapter names or functions.
56003     * @type {Function}
56004     */
56005    getAdapter: getAdapter$1,
56006    /**
56007     * Exposes all known adapters
56008     * @type {Object<string, Function|Object>}
56009     */
56010    adapters: knownAdapters
56011  };
56012  function throwIfCancellationRequested(config) {
56013    if (config.cancelToken) {
56014      config.cancelToken.throwIfRequested();
56015    }
56016    if (config.signal && config.signal.aborted) {
56017      throw new CanceledError$1(null, config);
56018    }
56019  }
56020  function dispatchRequest(config) {
56021    throwIfCancellationRequested(config);
56022    config.headers = AxiosHeaders$1.from(config.headers);
56023    config.data = transformData.call(config, config.transformRequest);
56024    if (["post", "put", "patch"].indexOf(config.method) !== -1) {
56025      config.headers.setContentType("application/x-www-form-urlencoded", false);
56026    }
56027    const adapter = adapters.getAdapter(config.adapter || defaults.adapter, config);
56028    return adapter(config).then(
56029      function onAdapterResolution(response2) {
56030        throwIfCancellationRequested(config);
56031        config.response = response2;
56032        try {
56033          response2.data = transformData.call(config, config.transformResponse, response2);
56034        } finally {
56035          delete config.response;
56036        }
56037        response2.headers = AxiosHeaders$1.from(response2.headers);
56038        return response2;
56039      },
56040      function onAdapterRejection(reason) {
56041        if (!isCancel$1(reason)) {
56042          throwIfCancellationRequested(config);
56043          if (reason && reason.response) {
56044            config.response = reason.response;
56045            try {
56046              reason.response.data = transformData.call(
56047                config,
56048                config.transformResponse,
56049                reason.response
56050              );
56051            } finally {
56052              delete config.response;
56053            }
56054            reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
56055          }
56056        }
56057        return Promise.reject(reason);
56058      }
56059    );
56060  }
56061  const validators$1 = {};
56062  ["object", "boolean", "number", "function", "string", "symbol"].forEach((type2, i2) => {
56063    validators$1[type2] = function validator2(thing) {
56064      return typeof thing === type2 || "a" + (i2 < 1 ? "n " : " ") + type2;
56065    };
56066  });
56067  const deprecatedWarnings = {};
56068  validators$1.transitional = function transitional(validator2, version2, message) {
56069    function formatMessage(opt, desc) {
56070      return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
56071    }
56072    return (value, opt, opts) => {
56073      if (validator2 === false) {
56074        throw new AxiosError$1(
56075          formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")),
56076          AxiosError$1.ERR_DEPRECATED
56077        );
56078      }
56079      if (version2 && !deprecatedWarnings[opt]) {
56080        deprecatedWarnings[opt] = true;
56081        console.warn(
56082          formatMessage(
56083            opt,
56084            " has been deprecated since v" + version2 + " and will be removed in the near future"
56085          )
56086        );
56087      }
56088      return validator2 ? validator2(value, opt, opts) : true;
56089    };
56090  };
56091  validators$1.spelling = function spelling(correctSpelling) {
56092    return (value, opt) => {
56093      console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
56094      return true;
56095    };
56096  };
56097  function assertOptions(options, schema, allowUnknown) {
56098    if (typeof options !== "object") {
56099      throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
56100    }

vendor: 11,066 bytes, lines 56101-56438

56101    const keys = Object.keys(options);
56102    let i2 = keys.length;
56103    while (i2-- > 0) {
56104      const opt = keys[i2];
56105      const validator2 = Object.prototype.hasOwnProperty.call(schema, opt) ? schema[opt] : void 0;
56106      if (validator2) {
56107        const value = options[opt];
56108        const result = value === void 0 || validator2(value, opt, options);
56109        if (result !== true) {
56110          throw new AxiosError$1(
56111            "option " + opt + " must be " + result,
56112            AxiosError$1.ERR_BAD_OPTION_VALUE
56113          );
56114        }
56115        continue;
56116      }
56117      if (allowUnknown !== true) {
56118        throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
56119      }
56120    }
56121  }
56122  const validator = {
56123    assertOptions,
56124    validators: validators$1
56125  };
56126  const validators = validator.validators;
56127  let Axios$1 = class Axios {
56128    constructor(instanceConfig) {
56129      this.defaults = instanceConfig || {};
56130      this.interceptors = {
56131        request: new InterceptorManager(),
56132        response: new InterceptorManager()
56133      };
56134    }
56135    /**
56136     * Dispatch a request
56137     *
56138     * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
56139     * @param {?Object} config
56140     *
56141     * @returns {Promise} The Promise to be fulfilled
56142     */
56143    async request(configOrUrl, config) {
56144      try {
56145        return await this._request(configOrUrl, config);
56146      } catch (err) {
56147        if (err instanceof Error) {
56148          let dummy = {};
56149          Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
56150          const stack = (() => {
56151            if (!dummy.stack) {
56152              return "";
56153            }
56154            const firstNewlineIndex = dummy.stack.indexOf("\n");
56155            return firstNewlineIndex === -1 ? "" : dummy.stack.slice(firstNewlineIndex + 1);
56156          })();
56157          try {
56158            if (!err.stack) {
56159              err.stack = stack;
56160            } else if (stack) {
56161              const firstNewlineIndex = stack.indexOf("\n");
56162              const secondNewlineIndex = firstNewlineIndex === -1 ? -1 : stack.indexOf("\n", firstNewlineIndex + 1);
56163              const stackWithoutTwoTopLines = secondNewlineIndex === -1 ? "" : stack.slice(secondNewlineIndex + 1);
56164              if (!String(err.stack).endsWith(stackWithoutTwoTopLines)) {
56165                err.stack += "\n" + stack;
56166              }
56167            }
56168          } catch (e) {
56169          }
56170        }
56171        throw err;
56172      }
56173    }
56174    _request(configOrUrl, config) {
56175      if (typeof configOrUrl === "string") {
56176        config = config || {};
56177        config.url = configOrUrl;
56178      } else {
56179        config = configOrUrl || {};
56180      }
56181      config = mergeConfig$1(this.defaults, config);
56182      const { transitional, paramsSerializer, headers } = config;
56183      if (transitional !== void 0) {
56184        validator.assertOptions(
56185          transitional,
56186          {
56187            silentJSONParsing: validators.transitional(validators.boolean),
56188            forcedJSONParsing: validators.transitional(validators.boolean),
56189            clarifyTimeoutError: validators.transitional(validators.boolean),
56190            legacyInterceptorReqResOrdering: validators.transitional(validators.boolean)
56191          },
56192          false
56193        );
56194      }
56195      if (paramsSerializer != null) {
56196        if (utils$5.isFunction(paramsSerializer)) {
56197          config.paramsSerializer = {
56198            serialize: paramsSerializer
56199          };
56200        } else {
56201          validator.assertOptions(
56202            paramsSerializer,
56203            {
56204              encode: validators.function,
56205              serialize: validators.function
56206            },
56207            true
56208          );
56209        }
56210      }
56211      if (config.allowAbsoluteUrls !== void 0) ;
56212      else if (this.defaults.allowAbsoluteUrls !== void 0) {
56213        config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
56214      } else {
56215        config.allowAbsoluteUrls = true;
56216      }
56217      validator.assertOptions(
56218        config,
56219        {
56220          baseUrl: validators.spelling("baseURL"),
56221          withXsrfToken: validators.spelling("withXSRFToken")
56222        },
56223        true
56224      );
56225      config.method = (config.method || this.defaults.method || "get").toLowerCase();
56226      let contextHeaders = headers && utils$5.merge(headers.common, headers[config.method]);
56227      headers && utils$5.forEach(["delete", "get", "head", "post", "put", "patch", "query", "common"], (method) => {
56228        delete headers[method];
56229      });
56230      config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
56231      const requestInterceptorChain = [];
56232      let synchronousRequestInterceptors = true;
56233      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
56234        if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
56235          return;
56236        }
56237        synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
56238        const transitional2 = config.transitional || transitionalDefaults;
56239        const legacyInterceptorReqResOrdering = transitional2 && transitional2.legacyInterceptorReqResOrdering;
56240        if (legacyInterceptorReqResOrdering) {
56241          requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
56242        } else {
56243          requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
56244        }
56245      });
56246      const responseInterceptorChain = [];
56247      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
56248        responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
56249      });
56250      let promise;
56251      let i2 = 0;
56252      let len2;
56253      if (!synchronousRequestInterceptors) {
56254        const chain = [dispatchRequest.bind(this), void 0];
56255        chain.unshift(...requestInterceptorChain);
56256        chain.push(...responseInterceptorChain);
56257        len2 = chain.length;
56258        promise = Promise.resolve(config);
56259        while (i2 < len2) {
56260          promise = promise.then(chain[i2++], chain[i2++]);
56261        }
56262        return promise;
56263      }
56264      len2 = requestInterceptorChain.length;
56265      let newConfig = config;
56266      while (i2 < len2) {
56267        const onFulfilled = requestInterceptorChain[i2++];
56268        const onRejected = requestInterceptorChain[i2++];
56269        try {
56270          newConfig = onFulfilled(newConfig);
56271        } catch (error) {
56272          onRejected.call(this, error);
56273          break;
56274        }
56275      }
56276      try {
56277        promise = dispatchRequest.call(this, newConfig);
56278      } catch (error) {
56279        return Promise.reject(error);
56280      }
56281      i2 = 0;
56282      len2 = responseInterceptorChain.length;
56283      while (i2 < len2) {
56284        promise = promise.then(responseInterceptorChain[i2++], responseInterceptorChain[i2++]);
56285      }
56286      return promise;
56287    }
56288    getUri(config) {
56289      config = mergeConfig$1(this.defaults, config);
56290      const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
56291      return buildURL(fullPath, config.params, config.paramsSerializer);
56292    }
56293  };
56294  utils$5.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
56295    Axios$1.prototype[method] = function(url2, config) {
56296      return this.request(
56297        mergeConfig$1(config || {}, {
56298          method,
56299          url: url2,
56300          data: (config || {}).data
56301        })
56302      );
56303    };
56304  });
56305  utils$5.forEach(["post", "put", "patch", "query"], function forEachMethodWithData(method) {
56306    function generateHTTPMethod(isForm) {
56307      return function httpMethod(url2, data, config) {
56308        return this.request(
56309          mergeConfig$1(config || {}, {
56310            method,
56311            headers: isForm ? {
56312              "Content-Type": "multipart/form-data"
56313            } : {},
56314            url: url2,
56315            data
56316          })
56317        );
56318      };
56319    }
56320    Axios$1.prototype[method] = generateHTTPMethod();
56321    if (method !== "query") {
56322      Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
56323    }
56324  });
56325  let CancelToken$1 = class CancelToken2 {
56326    constructor(executor) {
56327      if (typeof executor !== "function") {
56328        throw new TypeError("executor must be a function.");
56329      }
56330      let resolvePromise;
56331      this.promise = new Promise(function promiseExecutor(resolve) {
56332        resolvePromise = resolve;
56333      });
56334      const token = this;
56335      this.promise.then((cancel) => {
56336        if (!token._listeners) return;
56337        let i2 = token._listeners.length;
56338        while (i2-- > 0) {
56339          token._listeners[i2](cancel);
56340        }
56341        token._listeners = null;
56342      });
56343      this.promise.then = (onfulfilled) => {
56344        let _resolve;
56345        const promise = new Promise((resolve) => {
56346          token.subscribe(resolve);
56347          _resolve = resolve;
56348        }).then(onfulfilled);
56349        promise.cancel = function reject() {
56350          token.unsubscribe(_resolve);
56351        };
56352        return promise;
56353      };
56354      executor(function cancel(message, config, request2) {
56355        if (token.reason) {
56356          return;
56357        }
56358        token.reason = new CanceledError$1(message, config, request2);
56359        resolvePromise(token.reason);
56360      });
56361    }
56362    /**
56363     * Throws a `CanceledError` if cancellation has been requested.
56364     */
56365    throwIfRequested() {
56366      if (this.reason) {
56367        throw this.reason;
56368      }
56369    }
56370    /**
56371     * Subscribe to the cancel signal
56372     */
56373    subscribe(listener) {
56374      if (this.reason) {
56375        listener(this.reason);
56376        return;
56377      }
56378      if (this._listeners) {
56379        this._listeners.push(listener);
56380      } else {
56381        this._listeners = [listener];
56382      }
56383    }
56384    /**
56385     * Unsubscribe from the cancel signal
56386     */
56387    unsubscribe(listener) {
56388      if (!this._listeners) {
56389        return;
56390      }
56391      const index = this._listeners.indexOf(listener);
56392      if (index !== -1) {
56393        this._listeners.splice(index, 1);
56394      }
56395    }
56396    toAbortSignal() {
56397      const controller = new AbortController();
56398      const abort = (err) => {
56399        controller.abort(err);
56400      };
56401      this.subscribe(abort);
56402      controller.signal.unsubscribe = () => this.unsubscribe(abort);
56403      return controller.signal;
56404    }
56405    /**
56406     * Returns an object that contains a new `CancelToken` and a function that, when called,
56407     * cancels the `CancelToken`.
56408     */
56409    static source() {
56410      let cancel;
56411      const token = new CancelToken2(function executor(c) {
56412        cancel = c;
56413      });
56414      return {
56415        token,
56416        cancel
56417      };
56418    }
56419  };
56420  function spread$1(callback) {
56421    return function wrap(arr) {
56422      return callback.apply(null, arr);
56423    };
56424  }
56425  function isAxiosError$1(payload) {
56426    return utils$5.isObject(payload) && payload.isAxiosError === true;
56427  }
56428  const HttpStatusCode$1 = {
56429    Continue: 100,
56430    SwitchingProtocols: 101,
56431    Processing: 102,
56432    EarlyHints: 103,
56433    Ok: 200,
56434    Created: 201,
56435    Accepted: 202,
56436    NonAuthoritativeInformation: 203,
56437    NoContent: 204,
56438    ResetContent: 205,

56439    PartialContent: 206,
56440    MultiStatus: 207,
56441    AlreadyReported: 208,
56442    ImUsed: 226,
56443    MultipleChoices: 300,
56444    MovedPermanently: 301,
56445    Found: 302,
56446    SeeOther: 303,
56447    NotModified: 304,
56448    UseProxy: 305,
56449    Unused: 306,
56450    TemporaryRedirect: 307,
56451    PermanentRedirect: 308,
56452    BadRequest: 400,
56453    Unauthorized: 401,
56454    PaymentRequired: 402,
56455    Forbidden: 403,
56456    NotFound: 404,
56457    MethodNotAllowed: 405,
56458    NotAcceptable: 406,
56459    ProxyAuthenticationRequired: 407,
56460    RequestTimeout: 408,
56461    Conflict: 409,
56462    Gone: 410,
56463    LengthRequired: 411,
56464    PreconditionFailed: 412,
56465    PayloadTooLarge: 413,
56466    UriTooLong: 414,
56467    UnsupportedMediaType: 415,
56468    RangeNotSatisfiable: 416,
56469    ExpectationFailed: 417,
56470    ImATeapot: 418,
56471    MisdirectedRequest: 421,
56472    UnprocessableEntity: 422,
56473    Locked: 423,
56474    FailedDependency: 424,
56475    TooEarly: 425,
56476    UpgradeRequired: 426,
56477    PreconditionRequired: 428,
56478    TooManyRequests: 429,
56479    RequestHeaderFieldsTooLarge: 431,
56480    UnavailableForLegalReasons: 451,
56481    InternalServerError: 500,
56482    NotImplemented: 501,
56483    BadGateway: 502,
56484    ServiceUnavailable: 503,
56485    GatewayTimeout: 504,
56486    HttpVersionNotSupported: 505,
56487    VariantAlsoNegotiates: 506,
56488    InsufficientStorage: 507,
56489    LoopDetected: 508,
56490    NotExtended: 510,
56491    NetworkAuthenticationRequired: 511,
56492    WebServerIsDown: 521,
56493    ConnectionTimedOut: 522,
56494    OriginIsUnreachable: 523,
56495    TimeoutOccurred: 524,
56496    SslHandshakeFailed: 525,
56497    InvalidSslCertificate: 526
56498  };
56499  Object.entries(HttpStatusCode$1).forEach(([key2, value]) => {
56500    HttpStatusCode$1[value] = key2;
56501  });
56502  function createInstance(defaultConfig) {
56503    const context = new Axios$1(defaultConfig);
56504    const instance = bind(Axios$1.prototype.request, context);
56505    utils$5.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
56506    utils$5.extend(instance, context, null, { allOwnKeys: true });
56507    instance.create = function create2(instanceConfig) {
56508      return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
56509    };
56510    return instance;
56511  }
56512  const axios = createInstance(defaults);
56513  axios.Axios = Axios$1;
56514  axios.CanceledError = CanceledError$1;
56515  axios.CancelToken = CancelToken$1;
56516  axios.isCancel = isCancel$1;
56517  axios.VERSION = VERSION$1;
56518  axios.toFormData = toFormData$1;
56519  axios.AxiosError = AxiosError$1;
56520  axios.Cancel = axios.CanceledError;
56521  axios.all = function all2(promises) {
56522    return Promise.all(promises);
56523  };
56524  axios.spread = spread$1;
56525  axios.isAxiosError = isAxiosError$1;
56526  axios.mergeConfig = mergeConfig$1;
56527  axios.AxiosHeaders = AxiosHeaders$1;
56528  axios.formToJSON = (thing) => formDataToJSON(utils$5.isHTMLForm(thing) ? new FormData(thing) : thing);
56529  axios.getAdapter = adapters.getAdapter;
56530  axios.HttpStatusCode = HttpStatusCode$1;
56531  axios.default = axios;
56532  const {
56533    Axios,
56534    AxiosError,
56535    CanceledError,
56536    isCancel,
56537    CancelToken,
56538    VERSION,
56539    all,
56540    Cancel,
56541    isAxiosError,
56542    spread,
56543    toFormData,
56544    AxiosHeaders,
56545    HttpStatusCode,
56546    formToJSON,
56547    getAdapter,
56548    mergeConfig,
56549    create
56550  } = axios;
56551  var reactExports = requireReact();
56552  const React = /* @__PURE__ */ getDefaultExportFromCjs$1(reactExports);
56553  var propTypes = { exports: {} };
56554  var ReactPropTypesSecret_1;
56555  var hasRequiredReactPropTypesSecret;
56556  function requireReactPropTypesSecret() {
56557    if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
56558    hasRequiredReactPropTypesSecret = 1;
56559    var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
56560    ReactPropTypesSecret_1 = ReactPropTypesSecret;
56561    return ReactPropTypesSecret_1;
56562  }
56563  var factoryWithThrowingShims;
56564  var hasRequiredFactoryWithThrowingShims;
56565  function requireFactoryWithThrowingShims() {
56566    if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
56567    hasRequiredFactoryWithThrowingShims = 1;
56568    var ReactPropTypesSecret = /* @__PURE__ */ requireReactPropTypesSecret();
56569    function emptyFunction() {
56570    }
56571    function emptyFunctionWithReset() {
56572    }
56573    emptyFunctionWithReset.resetWarningCache = emptyFunction;
56574    factoryWithThrowingShims = function() {
56575      function shim2(props, propName, componentName, location2, propFullName, secret) {
56576        if (secret === ReactPropTypesSecret) {
56577          return;
56578        }
56579        var err = new Error(
56580          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
56581        );
56582        err.name = "Invariant Violation";
56583        throw err;
56584      }
56585      shim2.isRequired = shim2;
56586      function getShim() {
56587        return shim2;
56588      }
56589      var ReactPropTypes = {
56590        array: shim2,
56591        bigint: shim2,
56592        bool: shim2,
56593        func: shim2,
56594        number: shim2,
56595        object: shim2,

56596        string: shim2,
56597        symbol: shim2,
56598        any: shim2,
56599        arrayOf: getShim,
56600        element: shim2,
56601        elementType: shim2,
56602        instanceOf: getShim,
56603        node: shim2,
56604        objectOf: getShim,
56605        oneOf: getShim,
56606        oneOfType: getShim,
56607        shape: getShim,
56608        exact: getShim,
56609        checkPropTypes: emptyFunctionWithReset,
56610        resetWarningCache: emptyFunction
56611      };
56612      ReactPropTypes.PropTypes = ReactPropTypes;
56613      return ReactPropTypes;
56614    };
56615    return factoryWithThrowingShims;
56616  }
56617  var hasRequiredPropTypes;
56618  function requirePropTypes() {
56619    if (hasRequiredPropTypes) return propTypes.exports;
56620    hasRequiredPropTypes = 1;
56621    {
56622      propTypes.exports = /* @__PURE__ */ requireFactoryWithThrowingShims()();
56623    }
56624    return propTypes.exports;
56625  }
56626  var propTypesExports = /* @__PURE__ */ requirePropTypes();
56627  const PropTypes = /* @__PURE__ */ getDefaultExportFromCjs$1(propTypesExports);
56628  function _objectWithoutPropertiesLoose(r, e) {
56629    if (null == r) return {};
56630    var t = {};
56631    for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
56632      if (-1 !== e.indexOf(n)) continue;
56633      t[n] = r[n];
56634    }
56635    return t;
56636  }
56637  function _extends() {
56638    return _extends = Object.assign ? Object.assign.bind() : function(n) {
56639      for (var e = 1; e < arguments.length; e++) {
56640        var t = arguments[e];
56641        for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
56642      }
56643      return n;
56644    }, _extends.apply(null, arguments);
56645  }
56646  function _setPrototypeOf(t, e) {
56647    return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
56648      return t2.__proto__ = e2, t2;
56649    }, _setPrototypeOf(t, e);
56650  }
56651  function _inheritsLoose(t, o) {
56652    t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
56653  }
56654  function __spreadArray(to, from, pack) {
56655    if (pack || arguments.length === 2) for (var i2 = 0, l = from.length, ar; i2 < l; i2++) {
56656      if (ar || !(i2 in from)) {
56657        if (!ar) ar = Array.prototype.slice.call(from, 0, i2);
56658        ar[i2] = from[i2];
56659      }
56660    }
56661    return to.concat(ar || Array.prototype.slice.call(from));
56662  }
56663  typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
56664    var e = new Error(message);
56665    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
56666  };
56667  var contentType = {};
56668  /*!
56669  * content-type
56670  * Copyright(c) 2015 Douglas Christopher Wilson
56671  * MIT Licensed
56672  */
56673  var hasRequiredContentType;
56674  function requireContentType() {
56675    if (hasRequiredContentType) return contentType;
56676    hasRequiredContentType = 1;
56677    var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
56678    var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
56679    var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
56680    var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
56681    var QUOTE_REGEXP = /([\\"])/g;
56682    var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
56683    contentType.format = format;
56684    contentType.parse = parse2;
56685    function format(obj) {
56686      if (!obj || typeof obj !== "object") {
56687        throw new TypeError("argument obj is required");
56688      }
56689      var parameters = obj.parameters;
56690      var type2 = obj.type;
56691      if (!type2 || !TYPE_REGEXP.test(type2)) {
56692        throw new TypeError("invalid type");
56693      }
56694      var string = type2;
56695      if (parameters && typeof parameters === "object") {
56696        var param;
56697        var params = Object.keys(parameters).sort();
56698        for (var i2 = 0; i2 < params.length; i2++) {
56699          param = params[i2];
56700          if (!TOKEN_REGEXP.test(param)) {
56701            throw new TypeError("invalid parameter name");
56702          }
56703          string += "; " + param + "=" + qstring(parameters[param]);
56704        }
56705      }
56706      return string;
56707    }
56708    function parse2(string) {
56709      if (!string) {
56710        throw new TypeError("argument string is required");
56711      }
56712      var header = typeof string === "object" ? getcontenttype(string) : string;
56713      if (typeof header !== "string") {
56714        throw new TypeError("argument string is required to be a string");
56715      }
56716      var index = header.indexOf(";");
56717      var type2 = index !== -1 ? header.slice(0, index).trim() : header.trim();
56718      if (!TYPE_REGEXP.test(type2)) {
56719        throw new TypeError("invalid media type");
56720      }
56721      var obj = new ContentType(type2.toLowerCase());
56722      if (index !== -1) {
56723        var key2;
56724        var match;
56725        var value;
56726        PARAM_REGEXP.lastIndex = index;
56727        while (match = PARAM_REGEXP.exec(header)) {
56728          if (match.index !== index) {
56729            throw new TypeError("invalid parameter format");
56730          }
56731          index += match[0].length;
56732          key2 = match[1].toLowerCase();
56733          value = match[2];
56734          if (value.charCodeAt(0) === 34) {
56735            value = value.slice(1, -1);
56736            if (value.indexOf("\\") !== -1) {
56737              value = value.replace(QESC_REGEXP, "$1");
56738            }
56739          }
56740          obj.parameters[key2] = value;
56741        }
56742        if (index !== header.length) {
56743          throw new TypeError("invalid parameter format");
56744        }
56745      }
56746      return obj;
56747    }
56748    function getcontenttype(obj) {
56749      var header;
56750      if (typeof obj.getHeader === "function") {
56751        header = obj.getHeader("content-type");
56752      } else if (typeof obj.headers === "object") {
56753        header = obj.headers && obj.headers["content-type"];
56754      }
56755      if (typeof header !== "string") {
56756        throw new TypeError("content-type header is missing from object");
56757      }
56758      return header;
56759    }
56760    function qstring(val) {
56761      var str = String(val);
56762      if (TOKEN_REGEXP.test(str)) {
56763        return str;
56764      }
56765      if (str.length > 0 && !TEXT_REGEXP.test(str)) {
56766        throw new TypeError("invalid parameter value");
56767      }
56768      return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
56769    }
56770    function ContentType(type2) {
56771      this.parameters = /* @__PURE__ */ Object.create(null);
56772      this.type = type2;
56773    }
56774    return contentType;
56775  }
56776  var contentTypeExports = requireContentType();
56777  var cache = /* @__PURE__ */ new Map();
56778  var cloneSvg = function cloneSvg2(sourceSvg) {
56779    return sourceSvg.cloneNode(true);
56780  };
56781  var isLocal = function isLocal2() {
56782    return window.location.protocol === "file:";
56783  };
56784  var makeAjaxRequest = function makeAjaxRequest2(url2, httpRequestWithCredentials, callback) {
56785    var httpRequest = new XMLHttpRequest();
56786    httpRequest.onreadystatechange = function() {

56787      try {
56788        if (!/\.svg/i.test(url2) && httpRequest.readyState === 2) {
56789          var contentType2 = httpRequest.getResponseHeader("Content-Type");
56790          if (!contentType2) {
56791            throw new Error("Content type not found");
56792          }
56793          var type2 = contentTypeExports.parse(contentType2).type;
56794          if (!(type2 === "image/svg+xml" || type2 === "text/plain")) {
56795            throw new Error("Invalid content type: ".concat(type2));
56796          }
56797        }
56798        if (httpRequest.readyState === 4) {
56799          if (httpRequest.status === 404 || httpRequest.responseXML === null) {
56800            throw new Error(isLocal() ? "Note: SVG injection ajax calls do not work locally without adjusting security settings in your browser. Or consider using a local webserver." : "Unable to load SVG file: " + url2);
56801          }
56802          if (httpRequest.status === 200 || isLocal() && httpRequest.status === 0) {
56803            callback(null, httpRequest);
56804          } else {
56805            throw new Error("There was a problem injecting the SVG: " + httpRequest.status + " " + httpRequest.statusText);
56806          }
56807        }
56808      } catch (error) {
56809        httpRequest.abort();
56810        if (error instanceof Error) {
56811          callback(error, httpRequest);
56812        } else {
56813          throw error;
56814        }
56815      }
56816    };
56817    httpRequest.open("GET", url2);
56818    httpRequest.withCredentials = httpRequestWithCredentials;
56819    if (httpRequest.overrideMimeType) {
56820      httpRequest.overrideMimeType("text/xml");
56821    }
56822    httpRequest.send();
56823  };
56824  var requestQueue = {};
56825  var queueRequest = function queueRequest2(url2, callback) {
56826    requestQueue[url2] = requestQueue[url2] || [];
56827    requestQueue[url2].push(callback);
56828  };
56829  var processRequestQueue = function processRequestQueue2(url2) {
56830    var _loop_1 = function _loop_12(i3, len3) {
56831      setTimeout(function() {
56832        if (Array.isArray(requestQueue[url2])) {
56833          var cacheValue = cache.get(url2);
56834          var callback = requestQueue[url2][i3];
56835          if (cacheValue instanceof SVGSVGElement) {
56836            callback(null, cloneSvg(cacheValue));
56837          }
56838          if (cacheValue instanceof Error) {
56839            callback(cacheValue);
56840          }
56841          if (i3 === requestQueue[url2].length - 1) {
56842            delete requestQueue[url2];
56843          }
56844        }
56845      }, 0);
56846    };
56847    for (var i2 = 0, len2 = requestQueue[url2].length; i2 < len2; i2++) {
56848      _loop_1(i2);
56849    }
56850  };
56851  var loadSvgCached = function loadSvgCached2(url2, httpRequestWithCredentials, callback) {
56852    if (cache.has(url2)) {
56853      var cacheValue = cache.get(url2);
56854      if (cacheValue === void 0) {
56855        queueRequest(url2, callback);
56856        return;
56857      }
56858      if (cacheValue instanceof SVGSVGElement) {
56859        callback(null, cloneSvg(cacheValue));
56860        return;
56861      }
56862    }
56863    cache.set(url2, void 0);
56864    queueRequest(url2, callback);
56865    makeAjaxRequest(url2, httpRequestWithCredentials, function(error, httpRequest) {
56866      var _a;
56867      if (error) {
56868        cache.set(url2, error);
56869      } else if (((_a = httpRequest.responseXML) === null || _a === void 0 ? void 0 : _a.documentElement) instanceof SVGSVGElement) {
56870        cache.set(url2, httpRequest.responseXML.documentElement);
56871      }
56872      processRequestQueue(url2);
56873    });
56874  };
56875  var loadSvgUncached = function loadSvgUncached2(url2, httpRequestWithCredentials, callback) {
56876    makeAjaxRequest(url2, httpRequestWithCredentials, function(error, httpRequest) {
56877      var _a;
56878      if (error) {
56879        callback(error);
56880      } else if (((_a = httpRequest.responseXML) === null || _a === void 0 ? void 0 : _a.documentElement) instanceof SVGSVGElement) {
56881        callback(null, httpRequest.responseXML.documentElement);
56882      }
56883    });
56884  };
56885  var idCounter = 0;
56886  var uniqueId = function uniqueId2() {
56887    return ++idCounter;
56888  };
56889  var injectedElements = [];
56890  var ranScripts = {};
56891  var svgNamespace$1 = "http://www.w3.org/2000/svg";
56892  var xlinkNamespace$1 = "http://www.w3.org/1999/xlink";
56893  var injectElement = function injectElement2(el, evalScripts, renumerateIRIElements, cacheRequests, httpRequestWithCredentials, beforeEach, callback) {
56894    var elUrl = el.getAttribute("data-src") || el.getAttribute("src");
56895    if (!elUrl) {
56896      callback(new Error("Invalid data-src or src attribute"));
56897      return;
56898    }
56899    if (injectedElements.indexOf(el) !== -1) {
56900      injectedElements.splice(injectedElements.indexOf(el), 1);
56901      el = null;
56902      return;
56903    }
56904    injectedElements.push(el);
56905    el.setAttribute("src", "");
56906    var loadSvg = cacheRequests ? loadSvgCached : loadSvgUncached;
56907    loadSvg(elUrl, httpRequestWithCredentials, function(error, svg) {
56908      if (!svg) {
56909        injectedElements.splice(injectedElements.indexOf(el), 1);
56910        el = null;
56911        callback(error);
56912        return;
56913      }
56914      var elId = el.getAttribute("id");
56915      if (elId) {
56916        svg.setAttribute("id", elId);
56917      }
56918      var elTitle = el.getAttribute("title");
56919      if (elTitle) {
56920        svg.setAttribute("title", elTitle);
56921      }
56922      var elWidth = el.getAttribute("width");
56923      if (elWidth) {
56924        svg.setAttribute("width", elWidth);
56925      }
56926      var elHeight = el.getAttribute("height");
56927      if (elHeight) {
56928        svg.setAttribute("height", elHeight);
56929      }
56930      var mergedClasses = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], (svg.getAttribute("class") || "").split(" "), true), ["injected-svg"], false), (el.getAttribute("class") || "").split(" "), true))).join(" ").trim();
56931      svg.setAttribute("class", mergedClasses);
56932      var elStyle = el.getAttribute("style");
56933      if (elStyle) {
56934        svg.setAttribute("style", elStyle);
56935      }
56936      svg.setAttribute("data-src", elUrl);
56937      var elData = [].filter.call(el.attributes, function(at) {
56938        return /^data-\w[\w-]*$/.test(at.name);
56939      });
56940      Array.prototype.forEach.call(elData, function(dataAttr) {
56941        if (dataAttr.name && dataAttr.value) {
56942          svg.setAttribute(dataAttr.name, dataAttr.value);
56943        }
56944      });
56945      if (renumerateIRIElements) {
56946        var iriElementsAndProperties_1 = {
56947          clipPath: ["clip-path"],
56948          "color-profile": ["color-profile"],
56949          cursor: ["cursor"],
56950          filter: ["filter"],
56951          linearGradient: ["fill", "stroke"],
56952          marker: ["marker", "marker-start", "marker-mid", "marker-end"],
56953          mask: ["mask"],
56954          path: [],
56955          pattern: ["fill", "stroke"],
56956          radialGradient: ["fill", "stroke"]
56957        };
56958        var element_1;
56959        var elements_1;
56960        var properties_1;
56961        var currentId_1;
56962        var newId_1;

56963        Object.keys(iriElementsAndProperties_1).forEach(function(key2) {
56964          element_1 = key2;
56965          properties_1 = iriElementsAndProperties_1[key2];
56966          elements_1 = svg.querySelectorAll(element_1 + "[id]");
56967          var _loop_1 = function _loop_12(a2, elementsLen2) {
56968            currentId_1 = elements_1[a2].id;
56969            newId_1 = currentId_1 + "-" + uniqueId();
56970            var referencingElements;
56971            Array.prototype.forEach.call(properties_1, function(property) {
56972              referencingElements = svg.querySelectorAll("[" + property + '*="' + currentId_1 + '"]');
56973              for (var b = 0, referencingElementLen = referencingElements.length; b < referencingElementLen; b++) {
56974                var attrValue = referencingElements[b].getAttribute(property);
56975                if (attrValue && !attrValue.match(new RegExp('url\\("?#' + currentId_1 + '"?\\)'))) {
56976                  continue;
56977                }
56978                referencingElements[b].setAttribute(property, "url(#" + newId_1 + ")");
56979              }
56980            });
56981            var allLinks = svg.querySelectorAll("[*|href]");
56982            var links = [];
56983            for (var c = 0, allLinksLen = allLinks.length; c < allLinksLen; c++) {
56984              var href = allLinks[c].getAttributeNS(xlinkNamespace$1, "href");
56985              if (href && href.toString() === "#" + elements_1[a2].id) {
56986                links.push(allLinks[c]);
56987              }
56988            }
56989            for (var d = 0, linksLen = links.length; d < linksLen; d++) {
56990              links[d].setAttributeNS(xlinkNamespace$1, "href", "#" + newId_1);
56991            }
56992            elements_1[a2].id = newId_1;
56993          };
56994          for (var a = 0, elementsLen = elements_1.length; a < elementsLen; a++) {
56995            _loop_1(a);
56996          }
56997        });
56998      }
56999      svg.removeAttribute("xmlns:a");
57000      var scripts = svg.querySelectorAll("script");
57001      var scriptsToEval = [];
57002      var script;
57003      var scriptType;
57004      for (var i2 = 0, scriptsLen = scripts.length; i2 < scriptsLen; i2++) {
57005        scriptType = scripts[i2].getAttribute("type");
57006        if (!scriptType || scriptType === "application/ecmascript" || scriptType === "application/javascript" || scriptType === "text/javascript") {
57007          script = scripts[i2].innerText || scripts[i2].textContent;
57008          if (script) {
57009            scriptsToEval.push(script);
57010          }
57011          svg.removeChild(scripts[i2]);
57012        }
57013      }
57014      if (scriptsToEval.length > 0 && (evalScripts === "always" || evalScripts === "once" && !ranScripts[elUrl])) {
57015        for (var l = 0, scriptsToEvalLen = scriptsToEval.length; l < scriptsToEvalLen; l++) {
57016          new Function(scriptsToEval[l])(window);
57017        }
57018        ranScripts[elUrl] = true;
57019      }
57020      var styleTags = svg.querySelectorAll("style");
57021      Array.prototype.forEach.call(styleTags, function(styleTag) {
57022        styleTag.textContent += "";
57023      });
57024      svg.setAttribute("xmlns", svgNamespace$1);
57025      svg.setAttribute("xmlns:xlink", xlinkNamespace$1);
57026      beforeEach(svg);
57027      if (!el.parentNode) {
57028        injectedElements.splice(injectedElements.indexOf(el), 1);
57029        el = null;
57030        callback(new Error("Parent node is null"));
57031        return;
57032      }
57033      el.parentNode.replaceChild(svg, el);
57034      injectedElements.splice(injectedElements.indexOf(el), 1);
57035      el = null;
57036      callback(null, svg);
57037    });
57038  };
57039  var SVGInjector = function SVGInjector2(elements, _a) {
57040    var _b = _a === void 0 ? {} : _a, _c = _b.afterAll, afterAll = _c === void 0 ? function() {
57041      return void 0;
57042    } : _c, _d = _b.afterEach, afterEach = _d === void 0 ? function() {
57043      return void 0;
57044    } : _d, _e = _b.beforeEach, beforeEach = _e === void 0 ? function() {
57045      return void 0;
57046    } : _e, _f = _b.cacheRequests, cacheRequests = _f === void 0 ? true : _f, _g = _b.evalScripts, evalScripts = _g === void 0 ? "never" : _g, _h = _b.httpRequestWithCredentials, httpRequestWithCredentials = _h === void 0 ? false : _h, _j = _b.renumerateIRIElements, renumerateIRIElements = _j === void 0 ? true : _j;
57047    if (elements && "length" in elements) {
57048      var elementsLoaded_1 = 0;
57049      for (var i2 = 0, j = elements.length; i2 < j; i2++) {
57050        injectElement(elements[i2], evalScripts, renumerateIRIElements, cacheRequests, httpRequestWithCredentials, beforeEach, function(error, svg) {
57051          afterEach(error, svg);
57052          if (elements && "length" in elements && elements.length === ++elementsLoaded_1) {
57053            afterAll(elementsLoaded_1);
57054          }
57055        });
57056      }
57057    } else if (elements) {
57058      injectElement(elements, evalScripts, renumerateIRIElements, cacheRequests, httpRequestWithCredentials, beforeEach, function(error, svg) {
57059        afterEach(error, svg);
57060        afterAll(1);
57061        elements = null;
57062      });
57063    } else {
57064      afterAll(0);
57065    }
57066  };
57067  var ownerWindow = function ownerWindow2(node2) {
57068    var doc = (node2 == null ? void 0 : node2.ownerDocument) || document;
57069    return doc.defaultView || window;
57070  };
57071  var shallowDiffers = function shallowDiffers2(a, b) {
57072    for (var i2 in a) {
57073      if (!(i2 in b)) {
57074        return true;
57075      }
57076    }
57077    for (var _i in b) {
57078      if (a[_i] !== b[_i]) {
57079        return true;
57080      }
57081    }
57082    return false;

57083  };
57084  var _excluded = ["afterInjection", "beforeInjection", "desc", "evalScripts", "fallback", "httpRequestWithCredentials", "loading", "renumerateIRIElements", "src", "title", "useRequestCache", "wrapper"];
57085  var svgNamespace = "http://www.w3.org/2000/svg";
57086  var xlinkNamespace = "http://www.w3.org/1999/xlink";
57087  var ReactSVG = /* @__PURE__ */ (function(_React$Component) {
57088    function ReactSVG2() {
57089      var _this;
57090      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
57091        args[_key] = arguments[_key];
57092      }
57093      _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
57094      _this.initialState = {
57095        hasError: false,
57096        isLoading: true
57097      };
57098      _this.state = _this.initialState;
57099      _this._isMounted = false;
57100      _this.reactWrapper = void 0;
57101      _this.nonReactWrapper = void 0;
57102      _this.refCallback = function(reactWrapper) {
57103        _this.reactWrapper = reactWrapper;
57104      };
57105      return _this;
57106    }
57107    _inheritsLoose(ReactSVG2, _React$Component);
57108    var _proto = ReactSVG2.prototype;

57109    _proto.renderSVG = function renderSVG() {
57110      var _this2 = this;
57111      if (this.reactWrapper instanceof ownerWindow(this.reactWrapper).Node) {
57112        var _this$props = this.props, desc = _this$props.desc, evalScripts = _this$props.evalScripts, httpRequestWithCredentials = _this$props.httpRequestWithCredentials, renumerateIRIElements = _this$props.renumerateIRIElements, src2 = _this$props.src, title = _this$props.title, useRequestCache = _this$props.useRequestCache;
57113        var onError = this.props.onError;
57114        var beforeInjection = this.props.beforeInjection;
57115        var afterInjection = this.props.afterInjection;
57116        var wrapper = this.props.wrapper;
57117        var nonReactWrapper;
57118        var nonReactTarget;
57119        if (wrapper === "svg") {
57120          nonReactWrapper = document.createElementNS(svgNamespace, wrapper);
57121          nonReactWrapper.setAttribute("xmlns", svgNamespace);
57122          nonReactWrapper.setAttribute("xmlns:xlink", xlinkNamespace);
57123          nonReactTarget = document.createElementNS(svgNamespace, wrapper);
57124        } else {
57125          nonReactWrapper = document.createElement(wrapper);
57126          nonReactTarget = document.createElement(wrapper);
57127        }
57128        nonReactWrapper.appendChild(nonReactTarget);
57129        nonReactTarget.dataset.src = src2;
57130        this.nonReactWrapper = this.reactWrapper.appendChild(nonReactWrapper);
57131        var handleError = function handleError2(error) {
57132          _this2.removeSVG();
57133          if (!_this2._isMounted) {
57134            onError(error);
57135            return;
57136          }
57137          _this2.setState(function() {
57138            return {
57139              hasError: true,
57140              isLoading: false
57141            };
57142          }, function() {
57143            onError(error);
57144          });
57145        };
57146        var afterEach = function afterEach2(error, svg) {
57147          if (error) {
57148            handleError(error);
57149            return;
57150          }
57151          if (_this2._isMounted) {
57152            _this2.setState(function() {
57153              return {
57154                isLoading: false
57155              };
57156            }, function() {
57157              try {
57158                afterInjection(svg);
57159              } catch (afterInjectionError) {
57160                handleError(afterInjectionError);
57161              }
57162            });
57163          }
57164        };
57165        var beforeEach = function beforeEach2(svg) {
57166          svg.setAttribute("role", "img");
57167          if (desc) {
57168            var originalDesc = svg.querySelector(":scope > desc");
57169            if (originalDesc) {
57170              svg.removeChild(originalDesc);
57171            }
57172            var newDesc = document.createElement("desc");
57173            newDesc.innerHTML = desc;
57174            svg.prepend(newDesc);
57175          }
57176          if (title) {
57177            var originalTitle = svg.querySelector(":scope > title");
57178            if (originalTitle) {
57179              svg.removeChild(originalTitle);
57180            }
57181            var newTitle = document.createElement("title");
57182            newTitle.innerHTML = title;
57183            svg.prepend(newTitle);
57184          }
57185          try {
57186            beforeInjection(svg);
57187          } catch (error) {
57188            handleError(error);
57189          }
57190        };
57191        SVGInjector(nonReactTarget, {
57192          afterEach,
57193          beforeEach,
57194          cacheRequests: useRequestCache,
57195          evalScripts,
57196          httpRequestWithCredentials,
57197          renumerateIRIElements
57198        });
57199      }
57200    };
57201    _proto.removeSVG = function removeSVG() {
57202      var _this$nonReactWrapper;
57203      if ((_this$nonReactWrapper = this.nonReactWrapper) != null && _this$nonReactWrapper.parentNode) {
57204        this.nonReactWrapper.parentNode.removeChild(this.nonReactWrapper);
57205        this.nonReactWrapper = null;
57206      }
57207    };
57208    _proto.componentDidMount = function componentDidMount() {
57209      this._isMounted = true;
57210      this.renderSVG();
57211    };
57212    _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
57213      var _this3 = this;
57214      if (shallowDiffers(_extends({}, prevProps), this.props)) {
57215        this.setState(function() {
57216          return _this3.initialState;
57217        }, function() {
57218          _this3.removeSVG();
57219          _this3.renderSVG();
57220        });
57221      }
57222    };
57223    _proto.componentWillUnmount = function componentWillUnmount() {
57224      this._isMounted = false;

57225      this.removeSVG();
57226    };
57227    _proto.render = function render() {
57228      var _this$props2 = this.props;
57229      _this$props2.afterInjection;
57230      _this$props2.beforeInjection;
57231      _this$props2.desc;
57232      _this$props2.evalScripts;
57233      var Fallback = _this$props2.fallback;
57234      _this$props2.httpRequestWithCredentials;
57235      var Loading = _this$props2.loading;
57236      _this$props2.renumerateIRIElements;
57237      _this$props2.src;
57238      _this$props2.title;
57239      _this$props2.useRequestCache;
57240      var wrapper = _this$props2.wrapper, rest = _objectWithoutPropertiesLoose(_this$props2, _excluded);
57241      var Wrapper = wrapper;
57242      return /* @__PURE__ */ reactExports.createElement(Wrapper, _extends({}, rest, {
57243        ref: this.refCallback
57244      }, wrapper === "svg" ? {
57245        xmlns: svgNamespace,
57246        xmlnsXlink: xlinkNamespace
57247      } : {}), this.state.isLoading && Loading && /* @__PURE__ */ reactExports.createElement(Loading, null), this.state.hasError && Fallback && /* @__PURE__ */ reactExports.createElement(Fallback, null));
57248    };
57249    return ReactSVG2;
57250  })(reactExports.Component);
57251  ReactSVG.defaultProps = {
57252    afterInjection: function afterInjection() {
57253      return void 0;
57254    },
57255    beforeInjection: function beforeInjection() {
57256      return void 0;
57257    },
57258    desc: "",
57259    evalScripts: "never",
57260    fallback: null,
57261    httpRequestWithCredentials: false,
57262    loading: null,
57263    onError: function onError() {
57264      return void 0;
57265    },
57266    renumerateIRIElements: true,
57267    title: "",
57268    useRequestCache: true,
57269    wrapper: "div"
57270  };
57271  ReactSVG.propTypes = {
57272    afterInjection: propTypesExports.func,
57273    beforeInjection: propTypesExports.func,
57274    desc: propTypesExports.string,
57275    evalScripts: propTypesExports.oneOf(["always", "once", "never"]),
57276    fallback: propTypesExports.oneOfType([propTypesExports.func, propTypesExports.object, propTypesExports.string]),
57277    httpRequestWithCredentials: propTypesExports.bool,
57278    loading: propTypesExports.oneOfType([propTypesExports.func, propTypesExports.object, propTypesExports.string]),
57279    onError: propTypesExports.func,
57280    renumerateIRIElements: propTypesExports.bool,
57281    src: propTypesExports.string.isRequired,
57282    title: propTypesExports.string,
57283    useRequestCache: propTypesExports.bool,
57284    wrapper: propTypesExports.oneOf(["div", "span", "svg"])
57285  };
57286  var lodash$1 = { exports: {} };
57287  /**
57288  * @license
57289  * Lodash <https://lodash.com/>
57290  * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
57291  * Released under MIT license <https://lodash.com/license>
57292  * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
57293  * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
57294  */
57295  var lodash = lodash$1.exports;
57296  var hasRequiredLodash;
57297  function requireLodash() {
57298    if (hasRequiredLodash) return lodash$1.exports;
57299    hasRequiredLodash = 1;
57300    (function(module, exports$12) {
57301      (function() {
57302        var undefined$1;
57303        var VERSION2 = "4.18.1";
57304        var LARGE_ARRAY_SIZE = 200;
57305        var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`", INVALID_TEMPL_IMPORTS_ERROR_TEXT = "Invalid `imports` option passed into `_.template`";
57306        var HASH_UNDEFINED = "__lodash_hash_undefined__";
57307        var MAX_MEMOIZE_SIZE = 500;
57308        var PLACEHOLDER = "__lodash_placeholder__";
57309        var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
57310        var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
57311        var WRAP_BIND_FLAG = 1, WRAP_BIND_KEY_FLAG = 2, WRAP_CURRY_BOUND_FLAG = 4, WRAP_CURRY_FLAG = 8, WRAP_CURRY_RIGHT_FLAG = 16, WRAP_PARTIAL_FLAG = 32, WRAP_PARTIAL_RIGHT_FLAG = 64, WRAP_ARY_FLAG = 128, WRAP_REARG_FLAG = 256, WRAP_FLIP_FLAG = 512;
57312        var DEFAULT_TRUNC_LENGTH = 30, DEFAULT_TRUNC_OMISSION = "...";
57313        var HOT_COUNT = 800, HOT_SPAN = 16;
57314        var LAZY_FILTER_FLAG = 1, LAZY_MAP_FLAG = 2, LAZY_WHILE_FLAG = 3;
57315        var INFINITY = 1 / 0, MAX_SAFE_INTEGER = 9007199254740991, MAX_INTEGER = 17976931348623157e292, NAN = 0 / 0;
57316        var MAX_ARRAY_LENGTH = 4294967295, MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1, HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
57317        var wrapFlags = [
57318          ["ary", WRAP_ARY_FLAG],
57319          ["bind", WRAP_BIND_FLAG],
57320          ["bindKey", WRAP_BIND_KEY_FLAG],
57321          ["curry", WRAP_CURRY_FLAG],
57322          ["curryRight", WRAP_CURRY_RIGHT_FLAG],
57323          ["flip", WRAP_FLIP_FLAG],
57324          ["partial", WRAP_PARTIAL_FLAG],
57325          ["partialRight", WRAP_PARTIAL_RIGHT_FLAG],
57326          ["rearg", WRAP_REARG_FLAG]
57327        ];
57328        var argsTag = "[object Arguments]", arrayTag = "[object Array]", asyncTag = "[object AsyncFunction]", boolTag = "[object Boolean]", dateTag = "[object Date]", domExcTag = "[object DOMException]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", nullTag = "[object Null]", objectTag = "[object Object]", promiseTag = "[object Promise]", proxyTag = "[object Proxy]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", undefinedTag = "[object Undef

57328ined]", weakMapTag = "[object WeakMap]", weakSetTag = "[object WeakSet]";
57329        var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
57330        var reEmptyStringLeading = /\b__p \+= '';/g, reEmptyStringMiddle = /\b(__p \+=) '' \+/g, reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
57331        var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g, reUnescapedHtml = /[&<>"']/g, reHasEscapedHtml = RegExp(reEscapedHtml.source), reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
57332        var reEscape = /<%-([\s\S]+?)%>/g, reEvaluate = /<%([\s\S]+?)%>/g, reInterpolate = /<%=([\s\S]+?)%>/g;
57333        var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/, rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
57334        var reRegExpChar = /[\\^$.*+?()[\]{}|]/g, reHasRegExpChar = RegExp(reRegExpChar.source);
57335        var reTrimStart = /^\s+/;
57336        var reWhitespace = /\s/;
57337        var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/, reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/, reSplitDetails = /,? & /;
57338        var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
57339        var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
57340        var reEscapeChar = /\\(\\)?/g;
57341        var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
57342        var reFlags = /\w*$/;
57343        var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
57344        var reIsBinary = /^0b[01]+$/i;
57345        var reIsHostCtor = /^\[object .+?Constructor\]$/;
57346        var reIsOctal = /^0o[0-7]+$/i;
57347        var reIsUint = /^(?:0|[1-9]\d*)$/;

vendor: 4,405 bytes, lines 57348-57404

57348        var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
57349        var reNoMatch = /($^)/;
57350        var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
57351        var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsDingbatRange = "\\u2700-\\u27bf", rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff", rsMathOpRange = "\\xac\\xb1\\xd7\\xf7", rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf", rsPunctuationRange = "\\u2000-\\u206f", rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000", rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde", rsVarRange = "\\ufe0e\\ufe0f", rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
57352        var rsApos = "['â]", rsAstral = "[" + rsAstralRange + "]", rsBreak = "[" + rsBreakRange + "]", rsCombo = "[" + rsComboRange + "]", rsDigits = "\\d+", rsDingbat = "[" + rsDingbatRange + "]", rsLower = "[" + rsLowerRange + "]", rsMisc = "[^" + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsUpper = "[" + rsUpperRange + "]", rsZWJ = "\\u200d";
57353        var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")", rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")", rsOptContrLower = "(?:" + rsApos + "(?:d|ll|m|re|s|t|ve))?", rsOptContrUpper = "(?:" + rsApos + "(?:D|LL|M|RE|S|T|VE))?", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange + "]?", rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])", rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsEmoji = "(?:" + [rsDingbat, rsRegional, rsSurrPair].join("|") + ")" + rsSeq, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
57354        var reApos = RegExp(rsApos, "g");
57355        var reComboMark = RegExp(rsCombo, "g");
57356        var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
57357        var reUnicodeWord = RegExp([
57358          rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
57359          rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
57360          rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
57361          rsUpper + "+" + rsOptContrUpper,
57362          rsOrdUpper,
57363          rsOrdLower,
57364          rsDigits,
57365          rsEmoji
57366        ].join("|"), "g");
57367        var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
57368        var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
57369        var contextProps = [
57370          "Array",
57371          "Buffer",
57372          "DataView",
57373          "Date",
57374          "Error",
57375          "Float32Array",
57376          "Float64Array",
57377          "Function",
57378          "Int8Array",
57379          "Int16Array",
57380          "Int32Array",
57381          "Map",
57382          "Math",
57383          "Object",
57384          "Promise",
57385          "RegExp",
57386          "Set",
57387          "String",
57388          "Symbol",
57389          "TypeError",
57390          "Uint8Array",
57391          "Uint8ClampedArray",
57392          "Uint16Array",
57393          "Uint32Array",
57394          "WeakMap",
57395          "_",
57396          "clearTimeout",
57397          "isFinite",
57398          "parseInt",
57399          "setTimeout"
57400        ];
57401        var templateCounter = -1;
57402        var typedArrayTags = {};
57403        typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
57404        typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag]

vendor: 6,289 bytes, lines 57404-57631

57404= typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
57405        var cloneableTags = {};
57406        cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
57407        cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
57408        var deburredLetters = {
57409          // Latin-1 Supplement block.
57410          "Ã": "A",
57411          "Ã": "A",
57412          "Ã": "A",
57413          "Ã": "A",
57414          "Ã": "A",
57415          "Ã": "A",
57416          "Ã ": "a",
57417          "Ã¡": "a",
57418          "Ã¢": "a",
57419          "Ã£": "a",
57420          "Ã¤": "a",
57421          "Ã¥": "a",
57422          "Ã": "C",
57423          "Ã§": "c",
57424          "Ã": "D",
57425          "Ã°": "d",
57426          "Ã": "E",
57427          "Ã": "E",
57428          "Ã": "E",
57429          "Ã": "E",
57430          "Ã¨": "e",
57431          "Ã©": "e",
57432          "Ãª": "e",
57433          "Ã«": "e",
57434          "Ã": "I",
57435          "Ã": "I",
57436          "Ã": "I",
57437          "Ã": "I",
57438          "Ã¬": "i",
57439          "Ã": "i",
57440          "Ã®": "i",
57441          "Ã¯": "i",
57442          "Ã": "N",
57443          "Ã±": "n",
57444          "Ã": "O",
57445          "Ã": "O",
57446          "Ã": "O",
57447          "Ã": "O",
57448          "Ã": "O",
57449          "Ã": "O",
57450          "Ã²": "o",
57451          "Ã³": "o",
57452          "Ã´": "o",
57453          "Ãµ": "o",
57454          "Ã¶": "o",
57455          "Ã¸": "o",
57456          "Ã": "U",
57457          "Ã": "U",
57458          "Ã": "U",
57459          "Ã": "U",
57460          "Ã¹": "u",
57461          "Ãº": "u",
57462          "Ã»": "u",
57463          "Ã¼": "u",
57464          "Ã": "Y",
57465          "Ã½": "y",
57466          "Ã¿": "y",
57467          "Ã": "Ae",
57468          "Ã¦": "ae",
57469          "Ã": "Th",
57470          "Ã¾": "th",
57471          "Ã": "ss",
57472          // Latin Extended-A block.
57473          "Ä": "A",
57474          "Ä": "A",
57475          "Ä": "A",
57476          "Ä": "a",
57477          "Ä": "a",
57478          "Ä": "a",
57479          "Ä": "C",
57480          "Ä": "C",
57481          "Ä": "C",
57482          "Ä": "C",
57483          "Ä": "c",
57484          "Ä": "c",
57485          "Ä": "c",
57486          "Ä": "c",
57487          "Ä": "D",
57488          "Ä": "D",
57489          "Ä": "d",
57490          "Ä": "d",
57491          "Ä": "E",
57492          "Ä": "E",
57493          "Ä": "E",
57494          "Ä": "E",
57495          "Ä": "E",
57496          "Ä": "e",
57497          "Ä": "e",
57498          "Ä": "e",
57499          "Ä": "e",
57500          "Ä": "e",
57501          "Ä": "G",
57502          "Ä": "G",
57503          "Ä ": "G",
57504          "Ä¢": "G",
57505          "Ä": "g",
57506          "Ä": "g",
57507          "Ä¡": "g",
57508          "Ä£": "g",
57509          "Ä¤": "H",
57510          "Ä¦": "H",
57511          "Ä¥": "h",
57512          "Ä§": "h",
57513          "Ä¨": "I",
57514          "Äª": "I",
57515          "Ä¬": "I",
57516          "Ä®": "I",
57517          "Ä°": "I",
57518          "Ä©": "i",
57519          "Ä«": "i",
57520          "Ä": "i",
57521          "Ä¯": "i",
57522          "Ä±": "i",
57523          "Ä´": "J",
57524          "Äµ": "j",
57525          "Ä¶": "K",
57526          "Ä·": "k",
57527          "Ä¸": "k",
57528          "Ä¹": "L",
57529          "Ä»": "L",
57530          "Ä½": "L",
57531          "Ä¿": "L",
57532          "Å": "L",
57533          "Äº": "l",
57534          "Ä¼": "l",
57535          "Ä¾": "l",
57536          "Å": "l",
57537          "Å": "l",
57538          "Å": "N",
57539          "Å": "N",
57540          "Å": "N",
57541          "Å": "N",
57542          "Å": "n",
57543          "Å": "n",
57544          "Å": "n",
57545          "Å": "n",
57546          "Å": "O",
57547          "Å": "O",
57548          "Å": "O",
57549          "Å": "o",
57550          "Å": "o",
57551          "Å": "o",
57552          "Å": "R",
57553          "Å": "R",
57554          "Å": "R",
57555          "Å": "r",
57556          "Å": "r",
57557          "Å": "r",
57558          "Å": "S",
57559          "Å": "S",
57560          "Å": "S",
57561          "Å ": "S",
57562          "Å": "s",
57563          "Å": "s",
57564          "Å": "s",
57565          "Å¡": "s",
57566          "Å¢": "T",
57567          "Å¤": "T",
57568          "Å¦": "T",
57569          "Å£": "t",
57570          "Å¥": "t",
57571          "Å§": "t",
57572          "Å¨": "U",
57573          "Åª": "U",
57574          "Å¬": "U",
57575          "Å®": "U",
57576          "Å°": "U",
57577          "Å²": "U",
57578          "Å©": "u",
57579          "Å«": "u",
57580          "Å": "u",
57581          "Å¯": "u",
57582          "Å±": "u",
57583          "Å³": "u",
57584          "Å´": "W",
57585          "Åµ": "w",
57586          "Å¶": "Y",
57587          "Å·": "y",
57588          "Å¸": "Y",
57589          "Å¹": "Z",
57590          "Å»": "Z",
57591          "Å½": "Z",
57592          "Åº": "z",
57593          "Å¼": "z",
57594          "Å¾": "z",
57595          "Ä²": "IJ",
57596          "Ä³": "ij",
57597          "Å": "Oe",
57598          "Å": "oe",
57599          "Å": "'n",
57600          "Å¿": "s"
57601        };
57602        var htmlEscapes = {
57603          "&": "&amp;",
57604          "<": "&lt;",
57605          ">": "&gt;",
57606          '"': "&quot;",
57607          "'": "&#39;"
57608        };
57609        var htmlUnescapes = {
57610          "&amp;": "&",
57611          "&lt;": "<",
57612          "&gt;": ">",
57613          "&quot;": '"',
57614          "&#39;": "'"
57615        };
57616        var stringEscapes = {
57617          "\\": "\\",
57618          "'": "'",
57619          "\n": "n",
57620          "\r": "r",
57621          "\u2028": "u2028",
57622          "\u2029": "u2029"
57623        };
57624        var freeParseFloat = parseFloat, freeParseInt = parseInt;
57625        var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
57626        var freeSelf = typeof self == "object" && self && self.Object === Object && self;
57627        var root = freeGlobal || freeSelf || Function("return this")();
57628        var freeExports = exports$12 && !exports$12.nodeType && exports$12;
57629        var freeModule = freeExports && true && module && !module.nodeType && module;
57630        var moduleExports = freeModule && freeModule.exports === freeExports;
57631        var freeProcess = moduleExports && freeGlobal.process;

vendor: 4,771 bytes, lines 57632-57755

57632        var nodeUtil = (function() {
57633          try {
57634            var types2 = freeModule && freeModule.require && freeModule.require("util").types;
57635            if (types2) {
57636              return types2;
57637            }
57638            return freeProcess && freeProcess.binding && freeProcess.binding("util");
57639          } catch (e) {
57640          }
57641        })();
57642        var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer, nodeIsDate = nodeUtil && nodeUtil.isDate, nodeIsMap = nodeUtil && nodeUtil.isMap, nodeIsRegExp = nodeUtil && nodeUtil.isRegExp, nodeIsSet = nodeUtil && nodeUtil.isSet, nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
57643        function apply(func, thisArg, args) {
57644          switch (args.length) {
57645            case 0:
57646              return func.call(thisArg);
57647            case 1:
57648              return func.call(thisArg, args[0]);
57649            case 2:
57650              return func.call(thisArg, args[0], args[1]);
57651            case 3:
57652              return func.call(thisArg, args[0], args[1], args[2]);
57653          }
57654          return func.apply(thisArg, args);
57655        }
57656        function arrayAggregator(array, setter, iteratee, accumulator) {
57657          var index = -1, length = array == null ? 0 : array.length;
57658          while (++index < length) {
57659            var value = array[index];
57660            setter(accumulator, value, iteratee(value), array);
57661          }
57662          return accumulator;
57663        }
57664        function arrayEach(array, iteratee) {
57665          var index = -1, length = array == null ? 0 : array.length;
57666          while (++index < length) {
57667            if (iteratee(array[index], index, array) === false) {
57668              break;
57669            }
57670          }
57671          return array;
57672        }
57673        function arrayEachRight(array, iteratee) {
57674          var length = array == null ? 0 : array.length;
57675          while (length--) {
57676            if (iteratee(array[length], length, array) === false) {
57677              break;
57678            }
57679          }
57680          return array;
57681        }
57682        function arrayEvery(array, predicate) {
57683          var index = -1, length = array == null ? 0 : array.length;
57684          while (++index < length) {
57685            if (!predicate(array[index], index, array)) {
57686              return false;
57687            }
57688          }
57689          return true;
57690        }
57691        function arrayFilter(array, predicate) {
57692          var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
57693          while (++index < length) {
57694            var value = array[index];
57695            if (predicate(value, index, array)) {
57696              result[resIndex++] = value;
57697            }
57698          }
57699          return result;
57700        }
57701        function arrayIncludes(array, value) {
57702          var length = array == null ? 0 : array.length;
57703          return !!length && baseIndexOf(array, value, 0) > -1;
57704        }
57705        function arrayIncludesWith(array, value, comparator) {
57706          var index = -1, length = array == null ? 0 : array.length;
57707          while (++index < length) {
57708            if (comparator(value, array[index])) {
57709              return true;
57710            }
57711          }
57712          return false;
57713        }
57714        function arrayMap(array, iteratee) {
57715          var index = -1, length = array == null ? 0 : array.length, result = Array(length);
57716          while (++index < length) {
57717            result[index] = iteratee(array[index], index, array);
57718          }
57719          return result;
57720        }
57721        function arrayPush(array, values) {
57722          var index = -1, length = values.length, offset = array.length;
57723          while (++index < length) {
57724            array[offset + index] = values[index];
57725          }
57726          return array;
57727        }
57728        function arrayReduce(array, iteratee, accumulator, initAccum) {
57729          var index = -1, length = array == null ? 0 : array.length;
57730          if (initAccum && length) {
57731            accumulator = array[++index];
57732          }
57733          while (++index < length) {
57734            accumulator = iteratee(accumulator, array[index], index, array);
57735          }
57736          return accumulator;
57737        }
57738        function arrayReduceRight(array, iteratee, accumulator, initAccum) {
57739          var length = array == null ? 0 : array.length;
57740          if (initAccum && length) {
57741            accumulator = array[--length];
57742          }
57743          while (length--) {
57744            accumulator = iteratee(accumulator, array[length], length, array);
57745          }
57746          return accumulator;
57747        }
57748        function arraySome(array, predicate) {
57749          var index = -1, length = array == null ? 0 : array.length;
57750          while (++index < length) {
57751            if (predicate(array[index], index, array)) {
57752              return true;
57753            }
57754          }
57755          return false;

vendor: 4,239 bytes, lines 57756-57872

57756        }
57757        var asciiSize = baseProperty("length");
57758        function asciiToArray(string) {
57759          return string.split("");
57760        }
57761        function asciiWords(string) {
57762          return string.match(reAsciiWord) || [];
57763        }
57764        function baseFindKey(collection, predicate, eachFunc) {
57765          var result;
57766          eachFunc(collection, function(value, key2, collection2) {
57767            if (predicate(value, key2, collection2)) {
57768              result = key2;
57769              return false;
57770            }
57771          });
57772          return result;
57773        }
57774        function baseFindIndex(array, predicate, fromIndex, fromRight) {
57775          var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
57776          while (fromRight ? index-- : ++index < length) {
57777            if (predicate(array[index], index, array)) {
57778              return index;
57779            }
57780          }
57781          return -1;
57782        }
57783        function baseIndexOf(array, value, fromIndex) {
57784          return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
57785        }
57786        function baseIndexOfWith(array, value, fromIndex, comparator) {
57787          var index = fromIndex - 1, length = array.length;
57788          while (++index < length) {
57789            if (comparator(array[index], value)) {
57790              return index;
57791            }
57792          }
57793          return -1;
57794        }
57795        function baseIsNaN(value) {
57796          return value !== value;
57797        }
57798        function baseMean(array, iteratee) {
57799          var length = array == null ? 0 : array.length;
57800          return length ? baseSum(array, iteratee) / length : NAN;
57801        }
57802        function baseProperty(key2) {
57803          return function(object) {
57804            return object == null ? undefined$1 : object[key2];
57805          };
57806        }
57807        function basePropertyOf(object) {
57808          return function(key2) {
57809            return object == null ? undefined$1 : object[key2];
57810          };
57811        }
57812        function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
57813          eachFunc(collection, function(value, index, collection2) {
57814            accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
57815          });
57816          return accumulator;
57817        }
57818        function baseSortBy(array, comparer) {
57819          var length = array.length;
57820          array.sort(comparer);
57821          while (length--) {
57822            array[length] = array[length].value;
57823          }
57824          return array;
57825        }
57826        function baseSum(array, iteratee) {
57827          var result, index = -1, length = array.length;
57828          while (++index < length) {
57829            var current = iteratee(array[index]);
57830            if (current !== undefined$1) {
57831              result = result === undefined$1 ? current : result + current;
57832            }
57833          }
57834          return result;
57835        }
57836        function baseTimes(n, iteratee) {
57837          var index = -1, result = Array(n);
57838          while (++index < n) {
57839            result[index] = iteratee(index);
57840          }
57841          return result;
57842        }
57843        function baseToPairs(object, props) {
57844          return arrayMap(props, function(key2) {
57845            return [key2, object[key2]];
57846          });
57847        }
57848        function baseTrim(string) {
57849          return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
57850        }
57851        function baseUnary(func) {
57852          return function(value) {
57853            return func(value);
57854          };
57855        }
57856        function baseValues(object, props) {
57857          return arrayMap(props, function(key2) {
57858            return object[key2];
57859          });
57860        }
57861        function cacheHas(cache2, key2) {
57862          return cache2.has(key2);
57863        }
57864        function charsStartIndex(strSymbols, chrSymbols) {
57865          var index = -1, length = strSymbols.length;
57866          while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
57867          }
57868          return index;
57869        }
57870        function charsEndIndex(strSymbols, chrSymbols) {
57871          var index = strSymbols.length;
57872          while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0

vendor: 4,605 bytes, lines 57872-57996

57872) > -1) {
57873          }
57874          return index;
57875        }
57876        function countHolders(array, placeholder) {
57877          var length = array.length, result = 0;
57878          while (length--) {
57879            if (array[length] === placeholder) {
57880              ++result;
57881            }
57882          }
57883          return result;
57884        }
57885        var deburrLetter = basePropertyOf(deburredLetters);
57886        var escapeHtmlChar = basePropertyOf(htmlEscapes);
57887        function escapeStringChar(chr) {
57888          return "\\" + stringEscapes[chr];
57889        }
57890        function getValue(object, key2) {
57891          return object == null ? undefined$1 : object[key2];
57892        }
57893        function hasUnicode(string) {
57894          return reHasUnicode.test(string);
57895        }
57896        function hasUnicodeWord(string) {
57897          return reHasUnicodeWord.test(string);
57898        }
57899        function iteratorToArray(iterator2) {
57900          var data, result = [];
57901          while (!(data = iterator2.next()).done) {
57902            result.push(data.value);
57903          }
57904          return result;
57905        }
57906        function mapToArray(map) {
57907          var index = -1, result = Array(map.size);
57908          map.forEach(function(value, key2) {
57909            result[++index] = [key2, value];
57910          });
57911          return result;
57912        }
57913        function overArg(func, transform) {
57914          return function(arg) {
57915            return func(transform(arg));
57916          };
57917        }
57918        function replaceHolders(array, placeholder) {
57919          var index = -1, length = array.length, resIndex = 0, result = [];
57920          while (++index < length) {
57921            var value = array[index];
57922            if (value === placeholder || value === PLACEHOLDER) {
57923              array[index] = PLACEHOLDER;
57924              result[resIndex++] = index;
57925            }
57926          }
57927          return result;
57928        }
57929        function setToArray(set) {
57930          var index = -1, result = Array(set.size);
57931          set.forEach(function(value) {
57932            result[++index] = value;
57933          });
57934          return result;
57935        }
57936        function setToPairs(set) {
57937          var index = -1, result = Array(set.size);
57938          set.forEach(function(value) {
57939            result[++index] = [value, value];
57940          });
57941          return result;
57942        }
57943        function strictIndexOf(array, value, fromIndex) {
57944          var index = fromIndex - 1, length = array.length;
57945          while (++index < length) {
57946            if (array[index] === value) {
57947              return index;
57948            }
57949          }
57950          return -1;
57951        }
57952        function strictLastIndexOf(array, value, fromIndex) {
57953          var index = fromIndex + 1;
57954          while (index--) {
57955            if (array[index] === value) {
57956              return index;
57957            }
57958          }
57959          return index;
57960        }
57961        function stringSize(string) {
57962          return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
57963        }
57964        function stringToArray(string) {
57965          return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
57966        }
57967        function trimmedEndIndex(string) {
57968          var index = string.length;
57969          while (index-- && reWhitespace.test(string.charAt(index))) {
57970          }
57971          return index;
57972        }
57973        var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
57974        function unicodeSize(string) {
57975          var result = reUnicode.lastIndex = 0;
57976          while (reUnicode.test(string)) {
57977            ++result;
57978          }
57979          return result;
57980        }
57981        function unicodeToArray(string) {
57982          return string.match(reUnicode) || [];
57983        }
57984        function unicodeWords(string) {
57985          return string.match(reUnicodeWord) || [];
57986        }
57987        var runInContext = (function runInContext2(context) {
57988          context = context == null ? root : _2.defaults(root.Object(), context, _2.pick(root, contextProps));
57989          var Array2 = context.Array, Date2 = context.Date, Error2 = context.Error, Function2 = context.Function, Math2 = context.Math, Object2 = context.Object, RegExp2 = context.RegExp, String2 = context.String, TypeError2 = context.TypeError;
57990          var arrayProto = Array2.prototype, funcProto = Function2.prototype, objectProto = Object2.prototype;
57991          var coreJsData = context["__core-js_shared__"];
57992          var funcToString = funcProto.toString;
57993          var hasOwnProperty2 = objectProto.hasOwnProperty;
57994          var idCounter2 = 0;
57995          var maskSrcKey = (function() {
57996            var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");

vendor: 1,665 bytes, lines 57997-58015

57997            return uid ? "Symbol(src)_1." + uid : "";
57998          })();
57999          var nativeObjectToString = objectProto.toString;
58000          var objectCtorString = funcToString.call(Object2);
58001          var oldDash = root._;
58002          var reIsNative = RegExp2(
58003            "^" + funcToString.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
58004          );
58005          var Buffer2 = moduleExports ? context.Buffer : undefined$1, Symbol2 = context.Symbol, Uint8Array2 = context.Uint8Array, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : undefined$1, getPrototype = overArg(Object2.getPrototypeOf, Object2), objectCreate = Object2.create, propertyIsEnumerable = objectProto.propertyIsEnumerable, splice = arrayProto.splice, spreadableSymbol = Symbol2 ? Symbol2.isConcatSpreadable : undefined$1, symIterator = Symbol2 ? Symbol2.iterator : undefined$1, symToStringTag = Symbol2 ? Symbol2.toStringTag : undefined$1;
58006          var defineProperty = (function() {
58007            try {
58008              var func = getNative(Object2, "defineProperty");
58009              func({}, "", {});
58010              return func;
58011            } catch (e) {
58012            }
58013          })();
58014          var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout, ctxNow = Date2 && Date2.now !== root.Date.now && Date2.now, ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
58015          var nativeCeil = Math2.ceil, nativeFloor = Math2.floor, nativeGetSymbols = Object2.getOwnPropertySymbols, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined$1, nativeIsFinite = context.

vendor: 37,888 bytes, lines 58015-58898

58015isFinite, nativeJoin = arrayProto.join, nativeKeys = overArg(Object2.keys, Object2), nativeMax = Math2.max, nativeMin = Math2.min, nativeNow = Date2.now, nativeParseInt = context.parseInt, nativeRandom = Math2.random, nativeReverse = arrayProto.reverse;
58016          var DataView2 = getNative(context, "DataView"), Map2 = getNative(context, "Map"), Promise2 = getNative(context, "Promise"), Set2 = getNative(context, "Set"), WeakMap2 = getNative(context, "WeakMap"), nativeCreate = getNative(Object2, "create");
58017          var metaMap = WeakMap2 && new WeakMap2();
58018          var realNames = {};
58019          var dataViewCtorString = toSource(DataView2), mapCtorString = toSource(Map2), promiseCtorString = toSource(Promise2), setCtorString = toSource(Set2), weakMapCtorString = toSource(WeakMap2);
58020          var symbolProto = Symbol2 ? Symbol2.prototype : undefined$1, symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1, symbolToString = symbolProto ? symbolProto.toString : undefined$1;
58021          function lodash2(value) {
58022            if (isObjectLike(value) && !isArray2(value) && !(value instanceof LazyWrapper)) {
58023              if (value instanceof LodashWrapper) {
58024                return value;
58025              }
58026              if (hasOwnProperty2.call(value, "__wrapped__")) {
58027                return wrapperClone(value);
58028              }
58029            }
58030            return new LodashWrapper(value);
58031          }
58032          var baseCreate = /* @__PURE__ */ (function() {
58033            function object() {
58034            }
58035            return function(proto) {
58036              if (!isObject2(proto)) {
58037                return {};
58038              }
58039              if (objectCreate) {
58040                return objectCreate(proto);
58041              }
58042              object.prototype = proto;
58043              var result2 = new object();
58044              object.prototype = undefined$1;
58045              return result2;
58046            };
58047          })();
58048          function baseLodash() {
58049          }
58050          function LodashWrapper(value, chainAll) {
58051            this.__wrapped__ = value;
58052            this.__actions__ = [];
58053            this.__chain__ = !!chainAll;
58054            this.__index__ = 0;
58055            this.__values__ = undefined$1;
58056          }
58057          lodash2.templateSettings = {
58058            /**
58059             * Used to detect `data` property values to be HTML-escaped.
58060             *
58061             * @memberOf _.templateSettings
58062             * @type {RegExp}
58063             */
58064            "escape": reEscape,
58065            /**
58066             * Used to detect code to be evaluated.
58067             *
58068             * @memberOf _.templateSettings
58069             * @type {RegExp}
58070             */
58071            "evaluate": reEvaluate,
58072            /**
58073             * Used to detect `data` property values to inject.
58074             *
58075             * @memberOf _.templateSettings
58076             * @type {RegExp}
58077             */
58078            "interpolate": reInterpolate,
58079            /**
58080             * Used to reference the data object in the template text.
58081             *
58082             * @memberOf _.templateSettings
58083             * @type {string}
58084             */
58085            "variable": "",
58086            /**
58087             * Used to import variables into the compiled template.
58088             *
58089             * @memberOf _.templateSettings
58090             * @type {Object}
58091             */
58092            "imports": {
58093              /**
58094               * A reference to the `lodash` function.
58095               *
58096               * @memberOf _.templateSettings.imports
58097               * @type {Function}
58098               */
58099              "_": lodash2
58100            }
58101          };
58102          lodash2.prototype = baseLodash.prototype;
58103          lodash2.prototype.constructor = lodash2;
58104          LodashWrapper.prototype = baseCreate(baseLodash.prototype);
58105          LodashWrapper.prototype.constructor = LodashWrapper;
58106          function LazyWrapper(value) {
58107            this.__wrapped__ = value;
58108            this.__actions__ = [];
58109            this.__dir__ = 1;
58110            this.__filtered__ = false;
58111            this.__iteratees__ = [];
58112            this.__takeCount__ = MAX_ARRAY_LENGTH;
58113            this.__views__ = [];
58114          }
58115          function lazyClone() {
58116            var result2 = new LazyWrapper(this.__wrapped__);
58117            result2.__actions__ = copyArray(this.__actions__);
58118            result2.__dir__ = this.__dir__;
58119            result2.__filtered__ = this.__filtered__;
58120            result2.__iteratees__ = copyArray(this.__iteratees__);
58121            result2.__takeCount__ = this.__takeCount__;
58122            result2.__views__ = copyArray(this.__views__);
58123            return result2;
58124          }
58125          function lazyReverse() {
58126            if (this.__filtered__) {
58127              var result2 = new LazyWrapper(this);
58128              result2.__dir__ = -1;
58129              result2.__filtered__ = true;
58130            } else {
58131              result2 = this.clone();
58132              result2.__dir__ *= -1;
58133            }
58134            return result2;
58135          }
58136          function lazyValue() {
58137            var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray2(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin(length, this.__takeCount__);
58138            if (!isArr || !isRight && arrLength == length && takeCount == length) {
58139              return baseWrapperValue(array, this.__actions__);
58140            }
58141            var result2 = [];
58142            outer:
58143              while (length-- && resIndex < takeCount) {
58144                index += dir;
58145                var iterIndex = -1, value = array[index];
58146                while (++iterIndex < iterLength) {
58147                  var data = iteratees[iterIndex], iteratee2 = data.iteratee, type2 = data.type, computed = iteratee2(value);
58148                  if (type2 == LAZY_MAP_FLAG) {
58149                    value = computed;
58150                  } else if (!computed) {
58151                    if (type2 == LAZY_FILTER_FLAG) {
58152                      continue outer;
58153                    } else {
58154                      break outer;
58155                    }
58156                  }
58157                }
58158                result2[resIndex++] = value;
58159              }
58160            return result2;
58161          }
58162          LazyWrapper.prototype = baseCreate(baseLodash.prototype);
58163          LazyWrapper.prototype.constructor = LazyWrapper;
58164          function Hash(entries) {
58165            var index = -1, length = entries == null ? 0 : entries.length;
58166            this.clear();
58167            while (++index < length) {
58168              var entry = entries[index];
58169              this.set(entry[0], entry[1]);
58170            }
58171          }
58172          function hashClear() {
58173            this.__data__ = nativeCreate ? nativeCreate(null) : {};
58174            this.size = 0;
58175          }
58176          function hashDelete(key2) {
58177            var result2 = this.has(key2) && delete this.__data__[key2];
58178            this.size -= result2 ? 1 : 0;
58179            return result2;
58180          }
58181          function hashGet(key2) {
58182            var data = this.__data__;
58183            if (nativeCreate) {
58184              var result2 = data[key2];
58185              return result2 === HASH_UNDEFINED ? undefined$1 : result2;
58186            }
58187            return hasOwnProperty2.call(data, key2) ? data[key2] : undefined$1;
58188          }
58189          function hashHas(key2) {
58190            var data = this.__data__;
58191            return nativeCreate ? data[key2] !== undefined$1 : hasOwnProperty2.call(data, key2);
58192          }
58193          function hashSet(key2, value) {
58194            var data = this.__data__;
58195            this.size += this.has(key2) ? 0 : 1;
58196            data[key2] = nativeCreate && value === undefined$1 ? HASH_UNDEFINED : value;
58197            return this;
58198          }
58199          Hash.prototype.clear = hashClear;
58200          Hash.prototype["delete"] = hashDelete;
58201          Hash.prototype.get = hashGet;
58202          Hash.prototype.has = hashHas;
58203          Hash.prototype.set = hashSet;
58204          function ListCache(entries) {
58205            var index = -1, length = entries == null ? 0 : entries.length;
58206            this.clear();
58207            while (++index < length) {
58208              var entry = entries[index];
58209              this.set(entry[0], entry[1]);
58210            }
58211          }
58212          function listCacheClear() {
58213            this.__data__ = [];
58214            this.size = 0;
58215          }
58216          function listCacheDelete(key2) {
58217            var data = this.__data__, index = assocIndexOf(data, key2);
58218            if (index < 0) {
58219              return false;
58220            }
58221            var lastIndex = data.length - 1;
58222            if (index == lastIndex) {
58223              data.pop();
58224            } else {
58225              splice.call(data, index, 1);
58226            }
58227            --this.size;
58228            return true;
58229          }
58230          function listCacheGet(key2) {
58231            var data = this.__data__, index = assocIndexOf(data, key2);
58232            return index < 0 ? undefined$1 : data[index][1];
58233          }
58234          function listCacheHas(key2) {
58235            return assocIndexOf(this.__data__, key2) > -1;
58236          }
58237          function listCacheSet(key2, value) {
58238            var data = this.__data__, index = assocIndexOf(data, key2);
58239            if (index < 0) {
58240              ++this.size;
58241              data.push([key2, value]);
58242            } else {
58243              data[index][1] = value;
58244            }
58245            return this;
58246          }
58247          ListCache.prototype.clear = listCacheClear;
58248          ListCache.prototype["delete"] = listCacheDelete;
58249          ListCache.prototype.get = listCacheGet;
58250          ListCache.prototype.has = listCacheHas;
58251          ListCache.prototype.set = listCacheSet;
58252          function MapCache(entries) {
58253            var index = -1, length = entries == null ? 0 : entries.length;
58254            this.clear();
58255            while (++index < length) {
58256              var entry = entries[index];
58257              this.set(entry[0], entry[1]);
58258            }
58259          }
58260          function mapCacheClear() {
58261            this.size = 0;
58262            this.__data__ = {
58263              "hash": new Hash(),
58264              "map": new (Map2 || ListCache)(),
58265              "string": new Hash()
58266            };
58267          }
58268          function mapCacheDelete(key2) {
58269            var result2 = getMapData(this, key2)["delete"](key2);
58270            this.size -= result2 ? 1 : 0;
58271            return result2;
58272          }
58273          function mapCacheGet(key2) {
58274            return getMapData(this, key2).get(key2);
58275          }
58276          function mapCacheHas(key2) {
58277            return getMapData(this, key2).has(key2);
58278          }
58279          function mapCacheSet(key2, value) {
58280            var data = getMapData(this, key2), size2 = data.size;
58281            data.set(key2, value);
58282            this.size += data.size == size2 ? 0 : 1;
58283            return this;
58284          }
58285          MapCache.prototype.clear = mapCacheClear;
58286          MapCache.prototype["delete"] = mapCacheDelete;
58287          MapCache.prototype.get = mapCacheGet;
58288          MapCache.prototype.has = mapCacheHas;
58289          MapCache.prototype.set = mapCacheSet;
58290          function SetCache(values2) {
58291            var index = -1, length = values2 == null ? 0 : values2.length;
58292            this.__data__ = new MapCache();
58293            while (++index < length) {
58294              this.add(values2[index]);
58295            }
58296          }
58297          function setCacheAdd(value) {
58298            this.__data__.set(value, HASH_UNDEFINED);
58299            return this;
58300          }
58301          function setCacheHas(value) {
58302            return this.__data__.has(value);
58303          }
58304          SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
58305          SetCache.prototype.has = setCacheHas;
58306          function Stack(entries) {
58307            var data = this.__data__ = new ListCache(entries);
58308            this.size = data.size;
58309          }
58310          function stackClear() {
58311            this.__data__ = new ListCache();
58312            this.size = 0;
58313          }
58314          function stackDelete(key2) {
58315            var data = this.__data__, result2 = data["delete"](key2);
58316            this.size = data.size;
58317            return result2;
58318          }
58319          function stackGet(key2) {
58320            return this.__data__.get(key2);
58321          }
58322          function stackHas(key2) {
58323            return this.__data__.has(key2);
58324          }
58325          function stackSet(key2, value) {
58326            var data = this.__data__;
58327            if (data instanceof ListCache) {
58328              var pairs = data.__data__;
58329              if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
58330                pairs.push([key2, value]);
58331                this.size = ++data.size;
58332                return this;
58333              }
58334              data = this.__data__ = new MapCache(pairs);
58335            }
58336            data.set(key2, value);
58337            this.size = data.size;
58338            return this;
58339          }
58340          Stack.prototype.clear = stackClear;
58341          Stack.prototype["delete"] = stackDelete;
58342          Stack.prototype.get = stackGet;
58343          Stack.prototype.has = stackHas;
58344          Stack.prototype.set = stackSet;
58345          function arrayLikeKeys(value, inherited) {
58346            var isArr = isArray2(value), isArg = !isArr && isArguments2(value), isBuff = !isArr && !isArg && isBuffer2(value), isType = !isArr && !isArg && !isBuff && isTypedArray2(value), skipIndexes = isArr || isArg || isBuff || isType, result2 = skipIndexes ? baseTimes(value.length, String2) : [], length = result2.length;
58347            for (var key2 in value) {
58348              if ((inherited || hasOwnProperty2.call(value, key2)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
58349              (key2 == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
58350              isBuff && (key2 == "offset" || key2 == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
58351              isType && (key2 == "buffer" || key2 == "byteLength" || key2 == "byteOffset") || // Skip index properties.
58352              isIndex(key2, length)))) {
58353                result2.push(key2);
58354              }
58355            }
58356            return result2;
58357          }
58358          function arraySample(array) {
58359            var length = array.length;
58360            return length ? array[baseRandom(0, length - 1)] : undefined$1;
58361          }
58362          function arraySampleSize(array, n) {
58363            return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
58364          }
58365          function arrayShuffle(array) {
58366            return shuffleSelf(copyArray(array));
58367          }
58368          function assignMergeValue(object, key2, value) {
58369            if (value !== undefined$1 && !eq(object[key2], value) || value === undefined$1 && !(key2 in object)) {
58370              baseAssignValue(object, key2, value);
58371            }
58372          }
58373          function assignValue(object, key2, value) {
58374            var objValue = object[key2];
58375            if (!(hasOwnProperty2.call(object, key2) && eq(objValue, value)) || value === undefined$1 && !(key2 in object)) {
58376              baseAssignValue(object, key2, value);
58377            }
58378          }
58379          function assocIndexOf(array, key2) {
58380            var length = array.length;
58381            while (length--) {
58382              if (eq(array[length][0], key2)) {
58383                return length;
58384              }
58385            }
58386            return -1;
58387          }
58388          function baseAggregator(collection, setter, iteratee2, accumulator) {
58389            baseEach(collection, function(value, key2, collection2) {
58390              setter(accumulator, value, iteratee2(value), collection2);
58391            });
58392            return accumulator;
58393          }
58394          function baseAssign(object, source) {
58395            return object && copyObject(source, keys(source), object);
58396          }
58397          function baseAssignIn(object, source) {
58398            return object && copyObject(source, keysIn(source), object);
58399          }
58400          function baseAssignValue(object, key2, value) {
58401            if (key2 == "__proto__" && defineProperty) {
58402              defineProperty(object, key2, {
58403                "configurable": true,
58404                "enumerable": true,
58405                "value": value,
58406                "writable": true
58407              });
58408            } else {
58409              object[key2] = value;
58410            }
58411          }
58412          function baseAt(object, paths) {
58413            var index = -1, length = paths.length, result2 = Array2(length), skip = object == null;
58414            while (++index < length) {
58415              result2[index] = skip ? undefined$1 : get2(object, paths[index]);
58416            }
58417            return result2;
58418          }
58419          function baseClamp(number, lower, upper) {
58420            if (number === number) {
58421              if (upper !== undefined$1) {
58422                number = number <= upper ? number : upper;
58423              }
58424              if (lower !== undefined$1) {
58425                number = number >= lower ? number : lower;
58426              }
58427            }
58428            return number;
58429          }
58430          function baseClone(value, bitmask, customizer, key2, object, stack) {
58431            var result2, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
58432            if (customizer) {
58433              result2 = object ? customizer(value, key2, object, stack) : customizer(value);
58434            }
58435            if (result2 !== undefined$1) {
58436              return result2;
58437            }
58438            if (!isObject2(value)) {
58439              return value;
58440            }
58441            var isArr = isArray2(value);
58442            if (isArr) {
58443              result2 = initCloneArray(value);
58444              if (!isDeep) {
58445                return copyArray(value, result2);
58446              }
58447            } else {
58448              var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
58449              if (isBuffer2(value)) {
58450                return cloneBuffer(value, isDeep);
58451              }
58452              if (tag == objectTag || tag == argsTag || isFunc && !object) {
58453                result2 = isFlat || isFunc ? {} : initCloneObject(value);
58454                if (!isDeep) {
58455                  return isFlat ? copySymbolsIn(value, baseAssignIn(result2, value)) : copySymbols(value, baseAssign(result2, value));
58456                }
58457              } else {
58458                if (!cloneableTags[tag]) {
58459                  return object ? value : {};
58460                }
58461                result2 = initCloneByTag(value, tag, isDeep);
58462              }
58463            }
58464            stack || (stack = new Stack());
58465            var stacked = stack.get(value);
58466            if (stacked) {
58467              return stacked;
58468            }
58469            stack.set(value, result2);
58470            if (isSet(value)) {
58471              value.forEach(function(subValue) {
58472                result2.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
58473              });
58474            } else if (isMap(value)) {
58475              value.forEach(function(subValue, key3) {
58476                result2.set(key3, baseClone(subValue, bitmask, customizer, key3, value, stack));
58477              });
58478            }
58479            var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
58480            var props = isArr ? undefined$1 : keysFunc(value);
58481            arrayEach(props || value, function(subValue, key3) {
58482              if (props) {
58483                key3 = subValue;
58484                subValue = value[key3];
58485              }
58486              assignValue(result2, key3, baseClone(subValue, bitmask, customizer, key3, value, stack));
58487            });
58488            return result2;
58489          }
58490          function baseConforms(source) {
58491            var props = keys(source);
58492            return function(object) {
58493              return baseConformsTo(object, source, props);
58494            };
58495          }
58496          function baseConformsTo(object, source, props) {
58497            var length = props.length;
58498            if (object == null) {
58499              return !length;
58500            }
58501            object = Object2(object);
58502            while (length--) {
58503              var key2 = props[length], predicate = source[key2], value = object[key2];
58504              if (value === undefined$1 && !(key2 in object) || !predicate(value)) {
58505                return false;
58506              }
58507            }
58508            return true;
58509          }
58510          function baseDelay(func, wait, args) {
58511            if (typeof func != "function") {
58512              throw new TypeError2(FUNC_ERROR_TEXT);
58513            }
58514            return setTimeout2(function() {
58515              func.apply(undefined$1, args);
58516            }, wait);
58517          }
58518          function baseDifference(array, values2, iteratee2, comparator) {
58519            var index = -1, includes2 = arrayIncludes, isCommon = true, length = array.length, result2 = [], valuesLength = values2.length;
58520            if (!length) {
58521              return result2;
58522            }
58523            if (iteratee2) {
58524              values2 = arrayMap(values2, baseUnary(iteratee2));
58525            }
58526            if (comparator) {
58527              includes2 = arrayIncludesWith;
58528              isCommon = false;
58529            } else if (values2.length >= LARGE_ARRAY_SIZE) {
58530              includes2 = cacheHas;
58531              isCommon = false;
58532              values2 = new SetCache(values2);
58533            }
58534            outer:
58535              while (++index < length) {
58536                var value = array[index], computed = iteratee2 == null ? value : iteratee2(value);
58537                value = comparator || value !== 0 ? value : 0;
58538                if (isCommon && computed === computed) {
58539                  var valuesIndex = valuesLength;
58540                  while (valuesIndex--) {
58541                    if (values2[valuesIndex] === computed) {
58542                      continue outer;
58543                    }
58544                  }
58545                  result2.push(value);
58546                } else if (!includes2(values2, computed, comparator)) {
58547                  result2.push(value);
58548                }
58549              }
58550            return result2;
58551          }
58552          var baseEach = createBaseEach(baseForOwn);
58553          var baseEachRight = createBaseEach(baseForOwnRight, true);
58554          function baseEvery(collection, predicate) {
58555            var result2 = true;
58556            baseEach(collection, function(value, index, collection2) {
58557              result2 = !!predicate(value, index, collection2);
58558              return result2;
58559            });
58560            return result2;
58561          }
58562          function baseExtremum(array, iteratee2, comparator) {
58563            var index = -1, length = array.length;
58564            while (++index < length) {
58565              var value = array[index], current = iteratee2(value);
58566              if (current != null && (computed === undefined$1 ? current === current && !isSymbol(current) : comparator(current, computed))) {
58567                var computed = current, result2 = value;
58568              }
58569            }
58570            return result2;
58571          }
58572          function baseFill(array, value, start, end) {
58573            var length = array.length;
58574            start = toInteger(start);
58575            if (start < 0) {
58576              start = -start > length ? 0 : length + start;
58577            }
58578            end = end === undefined$1 || end > length ? length : toInteger(end);
58579            if (end < 0) {
58580              end += length;
58581            }
58582            end = start > end ? 0 : toLength(end);
58583            while (start < end) {
58584              array[start++] = value;
58585            }
58586            return array;
58587          }
58588          function baseFilter(collection, predicate) {
58589            var result2 = [];
58590            baseEach(collection, function(value, index, collection2) {
58591              if (predicate(value, index, collection2)) {
58592                result2.push(value);
58593              }
58594            });
58595            return result2;
58596          }
58597          function baseFlatten(array, depth, predicate, isStrict, result2) {
58598            var index = -1, length = array.length;
58599            predicate || (predicate = isFlattenable);
58600            result2 || (result2 = []);
58601            while (++index < length) {
58602              var value = array[index];
58603              if (depth > 0 && predicate(value)) {
58604                if (depth > 1) {
58605                  baseFlatten(value, depth - 1, predicate, isStrict, result2);
58606                } else {
58607                  arrayPush(result2, value);
58608                }
58609              } else if (!isStrict) {
58610                result2[result2.length] = value;
58611              }
58612            }
58613            return result2;
58614          }
58615          var baseFor = createBaseFor();
58616          var baseForRight = createBaseFor(true);
58617          function baseForOwn(object, iteratee2) {
58618            return object && baseFor(object, iteratee2, keys);
58619          }
58620          function baseForOwnRight(object, iteratee2) {
58621            return object && baseForRight(object, iteratee2, keys);
58622          }
58623          function baseFunctions(object, props) {
58624            return arrayFilter(props, function(key2) {
58625              return isFunction2(object[key2]);
58626            });
58627          }
58628          function baseGet(object, path) {
58629            path = castPath(path, object);
58630            var index = 0, length = path.length;
58631            while (object != null && index < length) {
58632              object = object[toKey(path[index++])];
58633            }
58634            return index && index == length ? object : undefined$1;
58635          }
58636          function baseGetAllKeys(object, keysFunc, symbolsFunc) {
58637            var result2 = keysFunc(object);
58638            return isArray2(object) ? result2 : arrayPush(result2, symbolsFunc(object));
58639          }
58640          function baseGetTag(value) {
58641            if (value == null) {
58642              return value === undefined$1 ? undefinedTag : nullTag;
58643            }
58644            return symToStringTag && symToStringTag in Object2(value) ? getRawTag(value) : objectToString(value);
58645          }
58646          function baseGt(value, other) {
58647            return value > other;
58648          }
58649          function baseHas(object, key2) {
58650            return object != null && hasOwnProperty2.call(object, key2);
58651          }
58652          function baseHasIn(object, key2) {
58653            return object != null && key2 in Object2(object);
58654          }
58655          function baseInRange(number, start, end) {
58656            return number >= nativeMin(start, end) && number < nativeMax(start, end);
58657          }
58658          function baseIntersection(arrays, iteratee2, comparator) {
58659            var includes2 = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array2(othLength), maxLength = Infinity, result2 = [];
58660            while (othIndex--) {
58661              var array = arrays[othIndex];
58662              if (othIndex && iteratee2) {
58663                array = arrayMap(array, baseUnary(iteratee2));
58664              }
58665              maxLength = nativeMin(array.length, maxLength);
58666              caches[othIndex] = !comparator && (iteratee2 || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : undefined$1;
58667            }
58668            array = arrays[0];
58669            var index = -1, seen = caches[0];
58670            outer:
58671              while (++index < length && result2.length < maxLength) {
58672                var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
58673                value = comparator || value !== 0 ? value : 0;
58674                if (!(seen ? cacheHas(seen, computed) : includes2(result2, computed, comparator))) {
58675                  othIndex = othLength;
58676                  while (--othIndex) {
58677                    var cache2 = caches[othIndex];
58678                    if (!(cache2 ? cacheHas(cache2, computed) : includes2(arrays[othIndex], computed, comparator))) {
58679                      continue outer;
58680                    }
58681                  }
58682                  if (seen) {
58683                    seen.push(computed);
58684                  }
58685                  result2.push(value);
58686                }
58687              }
58688            return result2;
58689          }
58690          function baseInverter(object, setter, iteratee2, accumulator) {
58691            baseForOwn(object, function(value, key2, object2) {
58692              setter(accumulator, iteratee2(value), key2, object2);
58693            });
58694            return accumulator;
58695          }
58696          function baseInvoke(object, path, args) {
58697            path = castPath(path, object);
58698            object = parent(object, path);
58699            var func = object == null ? object : object[toKey(last(path))];
58700            return func == null ? undefined$1 : apply(func, object, args);
58701          }
58702          function baseIsArguments(value) {
58703            return isObjectLike(value) && baseGetTag(value) == argsTag;
58704          }
58705          function baseIsArrayBuffer(value) {
58706            return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
58707          }
58708          function baseIsDate(value) {
58709            return isObjectLike(value) && baseGetTag(value) == dateTag;
58710          }
58711          function baseIsEqual(value, other, bitmask, customizer, stack) {
58712            if (value === other) {
58713              return true;
58714            }
58715            if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
58716              return value !== value && other !== other;
58717            }
58718            return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
58719          }
58720          function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
58721            var objIsArr = isArray2(object), othIsArr = isArray2(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
58722            objTag = objTag == argsTag ? objectTag : objTag;
58723            othTag = othTag == argsTag ? objectTag : othTag;
58724            var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
58725            if (isSameTag && isBuffer2(object)) {
58726              if (!isBuffer2(other)) {
58727                return false;
58728              }
58729              objIsArr = true;
58730              objIsObj = false;
58731            }
58732            if (isSameTag && !objIsObj) {
58733              stack || (stack = new Stack());
58734              return objIsArr || isTypedArray2(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
58735            }
58736            if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
58737              var objIsWrapped = objIsObj && hasOwnProperty2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty2.call(other, "__wrapped__");
58738              if (objIsWrapped || othIsWrapped) {
58739                var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
58740                stack || (stack = new Stack());
58741                return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
58742              }
58743            }
58744            if (!isSameTag) {
58745              return false;
58746            }
58747            stack || (stack = new Stack());
58748            return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
58749          }
58750          function baseIsMap(value) {
58751            return isObjectLike(value) && getTag(value) == mapTag;
58752          }
58753          function baseIsMatch(object, source, matchData, customizer) {
58754            var index = matchData.length, length = index, noCustomizer = !customizer;
58755            if (object == null) {
58756              return !length;
58757            }
58758            object = Object2(object);
58759            while (index--) {
58760              var data = matchData[index];
58761              if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
58762                return false;
58763              }
58764            }
58765            while (++index < length) {
58766              data = matchData[index];
58767              var key2 = data[0], objValue = object[key2], srcValue = data[1];
58768              if (noCustomizer && data[2]) {
58769                if (objValue === undefined$1 && !(key2 in object)) {
58770                  return false;
58771                }
58772              } else {
58773                var stack = new Stack();
58774                if (customizer) {
58775                  var result2 = customizer(objValue, srcValue, key2, object, source, stack);
58776                }
58777                if (!(result2 === undefined$1 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result2)) {
58778                  return false;
58779                }
58780              }
58781            }
58782            return true;
58783          }
58784          function baseIsNative(value) {
58785            if (!isObject2(value) || isMasked(value)) {
58786              return false;
58787            }
58788            var pattern = isFunction2(value) ? reIsNative : reIsHostCtor;
58789            return pattern.test(toSource(value));
58790          }
58791          function baseIsRegExp(value) {
58792            return isObjectLike(value) && baseGetTag(value) == regexpTag;
58793          }
58794          function baseIsSet(value) {
58795            return isObjectLike(value) && getTag(value) == setTag;
58796          }
58797          function baseIsTypedArray(value) {
58798            return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
58799          }
58800          function baseIteratee(value) {
58801            if (typeof value == "function") {
58802              return value;
58803            }
58804            if (value == null) {
58805              return identity;
58806            }
58807            if (typeof value == "object") {
58808              return isArray2(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
58809            }
58810            return property(value);
58811          }
58812          function baseKeys(object) {
58813            if (!isPrototype(object)) {
58814              return nativeKeys(object);
58815            }
58816            var result2 = [];
58817            for (var key2 in Object2(object)) {
58818              if (hasOwnProperty2.call(object, key2) && key2 != "constructor") {
58819                result2.push(key2);
58820              }
58821            }
58822            return result2;
58823          }
58824          function baseKeysIn(object) {
58825            if (!isObject2(object)) {
58826              return nativeKeysIn(object);
58827            }
58828            var isProto = isPrototype(object), result2 = [];
58829            for (var key2 in object) {
58830              if (!(key2 == "constructor" && (isProto || !hasOwnProperty2.call(object, key2)))) {
58831                result2.push(key2);
58832              }
58833            }
58834            return result2;
58835          }
58836          function baseLt(value, other) {
58837            return value < other;
58838          }
58839          function baseMap(collection, iteratee2) {
58840            var index = -1, result2 = isArrayLike(collection) ? Array2(collection.length) : [];
58841            baseEach(collection, function(value, key2, collection2) {
58842              result2[++index] = iteratee2(value, key2, collection2);
58843            });
58844            return result2;
58845          }
58846          function baseMatches(source) {
58847            var matchData = getMatchData(source);
58848            if (matchData.length == 1 && matchData[0][2]) {
58849              return matchesStrictComparable(matchData[0][0], matchData[0][1]);
58850            }
58851            return function(object) {
58852              return object === source || baseIsMatch(object, source, matchData);
58853            };
58854          }
58855          function baseMatchesProperty(path, srcValue) {
58856            if (isKey(path) && isStrictComparable(srcValue)) {
58857              return matchesStrictComparable(toKey(path), srcValue);
58858            }
58859            return function(object) {
58860              var objValue = get2(object, path);
58861              return objValue === undefined$1 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
58862            };
58863          }
58864          function baseMerge(object, source, srcIndex, customizer, stack) {
58865            if (object === source) {
58866              return;
58867            }
58868            baseFor(source, function(srcValue, key2) {
58869              stack || (stack = new Stack());
58870              if (isObject2(srcValue)) {
58871                baseMergeDeep(object, source, key2, srcIndex, baseMerge, customizer, stack);
58872              } else {
58873                var newValue = customizer ? customizer(safeGet(object, key2), srcValue, key2 + "", object, source, stack) : undefined$1;
58874                if (newValue === undefined$1) {
58875                  newValue = srcValue;
58876                }
58877                assignMergeValue(object, key2, newValue);
58878              }
58879            }, keysIn);
58880          }
58881          function baseMergeDeep(object, source, key2, srcIndex, mergeFunc, customizer, stack) {
58882            var objValue = safeGet(object, key2), srcValue = safeGet(source, key2), stacked = stack.get(srcValue);
58883            if (stacked) {
58884              assignMergeValue(object, key2, stacked);
58885              return;
58886            }
58887            var newValue = customizer ? customizer(objValue, srcValue, key2 + "", object, source, stack) : undefined$1;
58888            var isCommon = newValue === undefined$1;
58889            if (isCommon) {
58890              var isArr = isArray2(srcValue), isBuff = !isArr && isBuffer2(srcValue), isTyped = !isArr && !isBuff && isTypedArray2(srcValue);
58891              newValue = srcValue;
58892              if (isArr || isBuff || isTyped) {
58893                if (isArray2(objValue)) {
58894                  newValue = objValue;
58895                } else if (isArrayLikeObject(objValue)) {
58896                  newValue = copyArray(objValue);
58897                } else if (isBuff) {
58898                  isCommon = false;

vendor: 5,283 bytes, lines 58899-59032

58899                  newValue = cloneBuffer(srcValue, true);
58900                } else if (isTyped) {
58901                  isCommon = false;
58902                  newValue = cloneTypedArray(srcValue, true);
58903                } else {
58904                  newValue = [];
58905                }
58906              } else if (isPlainObject2(srcValue) || isArguments2(srcValue)) {
58907                newValue = objValue;
58908                if (isArguments2(objValue)) {
58909                  newValue = toPlainObject(objValue);
58910                } else if (!isObject2(objValue) || isFunction2(objValue)) {
58911                  newValue = initCloneObject(srcValue);
58912                }
58913              } else {
58914                isCommon = false;
58915              }
58916            }
58917            if (isCommon) {
58918              stack.set(srcValue, newValue);
58919              mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
58920              stack["delete"](srcValue);
58921            }
58922            assignMergeValue(object, key2, newValue);
58923          }
58924          function baseNth(array, n) {
58925            var length = array.length;
58926            if (!length) {
58927              return;
58928            }
58929            n += n < 0 ? length : 0;
58930            return isIndex(n, length) ? array[n] : undefined$1;
58931          }
58932          function baseOrderBy(collection, iteratees, orders) {
58933            if (iteratees.length) {
58934              iteratees = arrayMap(iteratees, function(iteratee2) {
58935                if (isArray2(iteratee2)) {
58936                  return function(value) {
58937                    return baseGet(value, iteratee2.length === 1 ? iteratee2[0] : iteratee2);
58938                  };
58939                }
58940                return iteratee2;
58941              });
58942            } else {
58943              iteratees = [identity];
58944            }
58945            var index = -1;
58946            iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
58947            var result2 = baseMap(collection, function(value, key2, collection2) {
58948              var criteria = arrayMap(iteratees, function(iteratee2) {
58949                return iteratee2(value);
58950              });
58951              return { "criteria": criteria, "index": ++index, "value": value };
58952            });
58953            return baseSortBy(result2, function(object, other) {
58954              return compareMultiple(object, other, orders);
58955            });
58956          }
58957          function basePick(object, paths) {
58958            return basePickBy(object, paths, function(value, path) {
58959              return hasIn(object, path);
58960            });
58961          }
58962          function basePickBy(object, paths, predicate) {
58963            var index = -1, length = paths.length, result2 = {};
58964            while (++index < length) {
58965              var path = paths[index], value = baseGet(object, path);
58966              if (predicate(value, path)) {
58967                baseSet(result2, castPath(path, object), value);
58968              }
58969            }
58970            return result2;
58971          }
58972          function basePropertyDeep(path) {
58973            return function(object) {
58974              return baseGet(object, path);
58975            };
58976          }
58977          function basePullAll(array, values2, iteratee2, comparator) {
58978            var indexOf3 = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values2.length, seen = array;
58979            if (array === values2) {
58980              values2 = copyArray(values2);
58981            }
58982            if (iteratee2) {
58983              seen = arrayMap(array, baseUnary(iteratee2));
58984            }
58985            while (++index < length) {
58986              var fromIndex = 0, value = values2[index], computed = iteratee2 ? iteratee2(value) : value;
58987              while ((fromIndex = indexOf3(seen, computed, fromIndex, comparator)) > -1) {
58988                if (seen !== array) {
58989                  splice.call(seen, fromIndex, 1);
58990                }
58991                splice.call(array, fromIndex, 1);
58992              }
58993            }
58994            return array;
58995          }
58996          function basePullAt(array, indexes) {
58997            var length = array ? indexes.length : 0, lastIndex = length - 1;
58998            while (length--) {
58999              var index = indexes[length];
59000              if (length == lastIndex || index !== previous) {
59001                var previous = index;
59002                if (isIndex(index)) {
59003                  splice.call(array, index, 1);
59004                } else {
59005                  baseUnset(array, index);
59006                }
59007              }
59008            }
59009            return array;
59010          }
59011          function baseRandom(lower, upper) {
59012            return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
59013          }
59014          function baseRange(start, end, step, fromRight) {
59015            var index = -1, length = nativeMax(nativeCeil((end - start) / (step || 1)), 0), result2 = Array2(length);
59016            while (length--) {
59017              result2[fromRight ? length : ++index] = start;
59018              start += step;
59019            }
59020            return result2;
59021          }
59022          function baseRepeat(string, n) {
59023            var result2 = "";
59024            if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
59025              return result2;
59026            }
59027            do {
59028              if (n % 2) {
59029                result2 += string;
59030              }
59031              n = nativeFloor(n / 2);
59032              if (n) {

vendor: 126,272 bytes, lines 59033-61944

59033                string += string;
59034              }
59035            } while (n);
59036            return result2;
59037          }
59038          function baseRest(func, start) {
59039            return setToString(overRest(func, start, identity), func + "");
59040          }
59041          function baseSample(collection) {
59042            return arraySample(values(collection));
59043          }
59044          function baseSampleSize(collection, n) {
59045            var array = values(collection);
59046            return shuffleSelf(array, baseClamp(n, 0, array.length));
59047          }
59048          function baseSet(object, path, value, customizer) {
59049            if (!isObject2(object)) {
59050              return object;
59051            }
59052            path = castPath(path, object);
59053            var index = -1, length = path.length, lastIndex = length - 1, nested = object;
59054            while (nested != null && ++index < length) {
59055              var key2 = toKey(path[index]), newValue = value;
59056              if (key2 === "__proto__" || key2 === "constructor" || key2 === "prototype") {
59057                return object;
59058              }
59059              if (index != lastIndex) {
59060                var objValue = nested[key2];
59061                newValue = customizer ? customizer(objValue, key2, nested) : undefined$1;
59062                if (newValue === undefined$1) {
59063                  newValue = isObject2(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
59064                }
59065              }
59066              assignValue(nested, key2, newValue);
59067              nested = nested[key2];
59068            }
59069            return object;
59070          }
59071          var baseSetData = !metaMap ? identity : function(func, data) {
59072            metaMap.set(func, data);
59073            return func;
59074          };
59075          var baseSetToString = !defineProperty ? identity : function(func, string) {
59076            return defineProperty(func, "toString", {
59077              "configurable": true,
59078              "enumerable": false,
59079              "value": constant(string),
59080              "writable": true
59081            });
59082          };
59083          function baseShuffle(collection) {
59084            return shuffleSelf(values(collection));
59085          }
59086          function baseSlice(array, start, end) {
59087            var index = -1, length = array.length;
59088            if (start < 0) {
59089              start = -start > length ? 0 : length + start;
59090            }
59091            end = end > length ? length : end;
59092            if (end < 0) {
59093              end += length;
59094            }
59095            length = start > end ? 0 : end - start >>> 0;
59096            start >>>= 0;
59097            var result2 = Array2(length);
59098            while (++index < length) {
59099              result2[index] = array[index + start];
59100            }
59101            return result2;
59102          }
59103          function baseSome(collection, predicate) {
59104            var result2;
59105            baseEach(collection, function(value, index, collection2) {
59106              result2 = predicate(value, index, collection2);
59107              return !result2;
59108            });
59109            return !!result2;
59110          }
59111          function baseSortedIndex(array, value, retHighest) {
59112            var low = 0, high = array == null ? low : array.length;
59113            if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
59114              while (low < high) {
59115                var mid = low + high >>> 1, computed = array[mid];
59116                if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {
59117                  low = mid + 1;
59118                } else {
59119                  high = mid;
59120                }
59121              }
59122              return high;
59123            }
59124            return baseSortedIndexBy(array, value, identity, retHighest);
59125          }
59126          function baseSortedIndexBy(array, value, iteratee2, retHighest) {
59127            var low = 0, high = array == null ? 0 : array.length;
59128            if (high === 0) {
59129              return 0;
59130            }
59131            value = iteratee2(value);
59132            var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === undefined$1;
59133            while (low < high) {
59134              var mid = nativeFloor((low + high) / 2), computed = iteratee2(array[mid]), othIsDefined = computed !== undefined$1, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
59135              if (valIsNaN) {
59136                var setLow = retHighest || othIsReflexive;
59137              } else if (valIsUndefined) {
59138                setLow = othIsReflexive && (retHighest || othIsDefined);
59139              } else if (valIsNull) {
59140                setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
59141              } else if (valIsSymbol) {
59142                setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
59143              } else if (othIsNull || othIsSymbol) {
59144                setLow = false;
59145              } else {
59146                setLow = retHighest ? computed <= value : computed < value;
59147              }
59148              if (setLow) {
59149                low = mid + 1;
59150              } else {
59151                high = mid;
59152              }
59153            }
59154            return nativeMin(high, MAX_ARRAY_INDEX);
59155          }
59156          function baseSortedUniq(array, iteratee2) {
59157            var index = -1, length = array.length, resIndex = 0, result2 = [];
59158            while (++index < length) {
59159              var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
59160              if (!index || !eq(computed, seen)) {
59161                var seen = computed;
59162                result2[resIndex++] = value === 0 ? 0 : value;
59163              }
59164            }
59165            return result2;
59166          }
59167          function baseToNumber(value) {
59168            if (typeof value == "number") {
59169              return value;
59170            }
59171            if (isSymbol(value)) {
59172              return NAN;
59173            }
59174            return +value;
59175          }
59176          function baseToString(value) {
59177            if (typeof value == "string") {
59178              return value;
59179            }
59180            if (isArray2(value)) {
59181              return arrayMap(value, baseToString) + "";
59182            }
59183            if (isSymbol(value)) {
59184              return symbolToString ? symbolToString.call(value) : "";
59185            }
59186            var result2 = value + "";
59187            return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
59188          }
59189          function baseUniq(array, iteratee2, comparator) {
59190            var index = -1, includes2 = arrayIncludes, length = array.length, isCommon = true, result2 = [], seen = result2;
59191            if (comparator) {
59192              isCommon = false;
59193              includes2 = arrayIncludesWith;
59194            } else if (length >= LARGE_ARRAY_SIZE) {
59195              var set2 = iteratee2 ? null : createSet(array);
59196              if (set2) {
59197                return setToArray(set2);
59198              }
59199              isCommon = false;
59200              includes2 = cacheHas;
59201              seen = new SetCache();
59202            } else {
59203              seen = iteratee2 ? [] : result2;
59204            }
59205            outer:
59206              while (++index < length) {
59207                var value = array[index], computed = iteratee2 ? iteratee2(value) : value;
59208                value = comparator || value !== 0 ? value : 0;
59209                if (isCommon && computed === computed) {
59210                  var seenIndex = seen.length;
59211                  while (seenIndex--) {
59212                    if (seen[seenIndex] === computed) {
59213                      continue outer;
59214                    }
59215                  }
59216                  if (iteratee2) {
59217                    seen.push(computed);
59218                  }
59219                  result2.push(value);
59220                } else if (!includes2(seen, computed, comparator)) {
59221                  if (seen !== result2) {
59222                    seen.push(computed);
59223                  }
59224                  result2.push(value);
59225                }
59226              }
59227            return result2;
59228          }
59229          function baseUnset(object, path) {
59230            path = castPath(path, object);
59231            var index = -1, length = path.length;
59232            if (!length) {
59233              return true;
59234            }
59235            while (++index < length) {
59236              var key2 = toKey(path[index]);
59237              if (key2 === "__proto__" && !hasOwnProperty2.call(object, "__proto__")) {
59238                return false;
59239              }
59240              if ((key2 === "constructor" || key2 === "prototype") && index < length - 1) {
59241                return false;
59242              }
59243            }
59244            var obj = parent(object, path);
59245            return obj == null || delete obj[toKey(last(path))];
59246          }
59247          function baseUpdate(object, path, updater, customizer) {
59248            return baseSet(object, path, updater(baseGet(object, path)), customizer);
59249          }
59250          function baseWhile(array, predicate, isDrop, fromRight) {
59251            var length = array.length, index = fromRight ? length : -1;
59252            while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {
59253            }
59254            return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
59255          }
59256          function baseWrapperValue(value, actions) {
59257            var result2 = value;
59258            if (result2 instanceof LazyWrapper) {
59259              result2 = result2.value();
59260            }
59261            return arrayReduce(actions, function(result3, action) {
59262              return action.func.apply(action.thisArg, arrayPush([result3], action.args));
59263            }, result2);
59264          }
59265          function baseXor(arrays, iteratee2, comparator) {
59266            var length = arrays.length;
59267            if (length < 2) {
59268              return length ? baseUniq(arrays[0]) : [];
59269            }
59270            var index = -1, result2 = Array2(length);
59271            while (++index < length) {
59272              var array = arrays[index], othIndex = -1;
59273              while (++othIndex < length) {
59274                if (othIndex != index) {
59275                  result2[index] = baseDifference(result2[index] || array, arrays[othIndex], iteratee2, comparator);
59276                }
59277              }
59278            }
59279            return baseUniq(baseFlatten(result2, 1), iteratee2, comparator);
59280          }
59281          function baseZipObject(props, values2, assignFunc) {
59282            var index = -1, length = props.length, valsLength = values2.length, result2 = {};
59283            while (++index < length) {
59284              var value = index < valsLength ? values2[index] : undefined$1;
59285              assignFunc(result2, props[index], value);
59286            }
59287            return result2;
59288          }
59289          function castArrayLikeObject(value) {
59290            return isArrayLikeObject(value) ? value : [];
59291          }
59292          function castFunction(value) {
59293            return typeof value == "function" ? value : identity;
59294          }
59295          function castPath(value, object) {
59296            if (isArray2(value)) {
59297              return value;
59298            }
59299            return isKey(value, object) ? [value] : stringToPath(toString2(value));
59300          }
59301          var castRest = baseRest;
59302          function castSlice(array, start, end) {
59303            var length = array.length;
59304            end = end === undefined$1 ? length : end;
59305            return !start && end >= length ? array : baseSlice(array, start, end);
59306          }
59307          var clearTimeout2 = ctxClearTimeout || function(id) {
59308            return root.clearTimeout(id);
59309          };
59310          function cloneBuffer(buffer2, isDeep) {
59311            if (isDeep) {
59312              return buffer2.slice();
59313            }
59314            var length = buffer2.length, result2 = allocUnsafe ? allocUnsafe(length) : new buffer2.constructor(length);
59315            buffer2.copy(result2);
59316            return result2;
59317          }
59318          function cloneArrayBuffer(arrayBuffer) {
59319            var result2 = new arrayBuffer.constructor(arrayBuffer.byteLength);
59320            new Uint8Array2(result2).set(new Uint8Array2(arrayBuffer));
59321            return result2;
59322          }
59323          function cloneDataView(dataView, isDeep) {
59324            var buffer2 = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
59325            return new dataView.constructor(buffer2, dataView.byteOffset, dataView.byteLength);
59326          }
59327          function cloneRegExp(regexp) {
59328            var result2 = new regexp.constructor(regexp.source, reFlags.exec(regexp));
59329            result2.lastIndex = regexp.lastIndex;
59330            return result2;
59331          }
59332          function cloneSymbol(symbol) {
59333            return symbolValueOf ? Object2(symbolValueOf.call(symbol)) : {};
59334          }
59335          function cloneTypedArray(typedArray, isDeep) {
59336            var buffer2 = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
59337            return new typedArray.constructor(buffer2, typedArray.byteOffset, typedArray.length);
59338          }
59339          function compareAscending(value, other) {
59340            if (value !== other) {
59341              var valIsDefined = value !== undefined$1, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
59342              var othIsDefined = other !== undefined$1, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
59343              if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
59344                return 1;
59345              }
59346              if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
59347                return -1;
59348              }
59349            }
59350            return 0;
59351          }
59352          function compareMultiple(object, other, orders) {
59353            var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
59354            while (++index < length) {
59355              var result2 = compareAscending(objCriteria[index], othCriteria[index]);
59356              if (result2) {
59357                if (index >= ordersLength) {
59358                  return result2;
59359                }
59360                var order = orders[index];
59361                return result2 * (order == "desc" ? -1 : 1);
59362              }
59363            }
59364            return object.index - other.index;
59365          }
59366          function composeArgs(args, partials, holders, isCurried) {
59367            var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(leftLength + rangeLength), isUncurried = !isCurried;
59368            while (++leftIndex < leftLength) {
59369              result2[leftIndex] = partials[leftIndex];
59370            }
59371            while (++argsIndex < holdersLength) {
59372              if (isUncurried || argsIndex < argsLength) {
59373                result2[holders[argsIndex]] = args[argsIndex];
59374              }
59375            }
59376            while (rangeLength--) {
59377              result2[leftIndex++] = args[argsIndex++];
59378            }
59379            return result2;
59380          }
59381          function composeArgsRight(args, partials, holders, isCurried) {
59382            var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax(argsLength - holdersLength, 0), result2 = Array2(rangeLength + rightLength), isUncurried = !isCurried;
59383            while (++argsIndex < rangeLength) {
59384              result2[argsIndex] = args[argsIndex];
59385            }
59386            var offset = argsIndex;
59387            while (++rightIndex < rightLength) {
59388              result2[offset + rightIndex] = partials[rightIndex];
59389            }
59390            while (++holdersIndex < holdersLength) {
59391              if (isUncurried || argsIndex < argsLength) {
59392                result2[offset + holders[holdersIndex]] = args[argsIndex++];
59393              }
59394            }
59395            return result2;
59396          }
59397          function copyArray(source, array) {
59398            var index = -1, length = source.length;
59399            array || (array = Array2(length));
59400            while (++index < length) {
59401              array[index] = source[index];
59402            }
59403            return array;
59404          }
59405          function copyObject(source, props, object, customizer) {
59406            var isNew = !object;
59407            object || (object = {});
59408            var index = -1, length = props.length;
59409            while (++index < length) {
59410              var key2 = props[index];
59411              var newValue = customizer ? customizer(object[key2], source[key2], key2, object, source) : undefined$1;
59412              if (newValue === undefined$1) {
59413                newValue = source[key2];
59414              }
59415              if (isNew) {
59416                baseAssignValue(object, key2, newValue);
59417              } else {
59418                assignValue(object, key2, newValue);
59419              }
59420            }
59421            return object;
59422          }
59423          function copySymbols(source, object) {
59424            return copyObject(source, getSymbols(source), object);
59425          }
59426          function copySymbolsIn(source, object) {
59427            return copyObject(source, getSymbolsIn(source), object);
59428          }
59429          function createAggregator(setter, initializer) {
59430            return function(collection, iteratee2) {
59431              var func = isArray2(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
59432              return func(collection, setter, getIteratee(iteratee2, 2), accumulator);
59433            };
59434          }
59435          function createAssigner(assigner) {
59436            return baseRest(function(object, sources) {
59437              var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : undefined$1, guard = length > 2 ? sources[2] : undefined$1;
59438              customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : undefined$1;
59439              if (guard && isIterateeCall(sources[0], sources[1], guard)) {
59440                customizer = length < 3 ? undefined$1 : customizer;
59441                length = 1;
59442              }
59443              object = Object2(object);
59444              while (++index < length) {
59445                var source = sources[index];
59446                if (source) {
59447                  assigner(object, source, index, customizer);
59448                }
59449              }
59450              return object;
59451            });
59452          }
59453          function createBaseEach(eachFunc, fromRight) {
59454            return function(collection, iteratee2) {
59455              if (collection == null) {
59456                return collection;
59457              }
59458              if (!isArrayLike(collection)) {
59459                return eachFunc(collection, iteratee2);
59460              }
59461              var length = collection.length, index = fromRight ? length : -1, iterable = Object2(collection);
59462              while (fromRight ? index-- : ++index < length) {
59463                if (iteratee2(iterable[index], index, iterable) === false) {
59464                  break;
59465                }
59466              }
59467              return collection;
59468            };
59469          }
59470          function createBaseFor(fromRight) {
59471            return function(object, iteratee2, keysFunc) {
59472              var index = -1, iterable = Object2(object), props = keysFunc(object), length = props.length;
59473              while (length--) {
59474                var key2 = props[fromRight ? length : ++index];
59475                if (iteratee2(iterable[key2], key2, iterable) === false) {
59476                  break;
59477                }
59478              }
59479              return object;
59480            };
59481          }
59482          function createBind(func, bitmask, thisArg) {
59483            var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
59484            function wrapper() {
59485              var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
59486              return fn.apply(isBind ? thisArg : this, arguments);
59487            }
59488            return wrapper;
59489          }
59490          function createCaseFirst(methodName) {
59491            return function(string) {
59492              string = toString2(string);
59493              var strSymbols = hasUnicode(string) ? stringToArray(string) : undefined$1;
59494              var chr = strSymbols ? strSymbols[0] : string.charAt(0);
59495              var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
59496              return chr[methodName]() + trailing;
59497            };
59498          }
59499          function createCompounder(callback) {
59500            return function(string) {
59501              return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
59502            };
59503          }
59504          function createCtor(Ctor) {
59505            return function() {
59506              var args = arguments;
59507              switch (args.length) {
59508                case 0:
59509                  return new Ctor();
59510                case 1:
59511                  return new Ctor(args[0]);
59512                case 2:
59513                  return new Ctor(args[0], args[1]);
59514                case 3:
59515                  return new Ctor(args[0], args[1], args[2]);
59516                case 4:
59517                  return new Ctor(args[0], args[1], args[2], args[3]);
59518                case 5:
59519                  return new Ctor(args[0], args[1], args[2], args[3], args[4]);
59520                case 6:
59521                  return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
59522                case 7:
59523                  return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
59524              }
59525              var thisBinding = baseCreate(Ctor.prototype), result2 = Ctor.apply(thisBinding, args);
59526              return isObject2(result2) ? result2 : thisBinding;
59527            };
59528          }
59529          function createCurry(func, bitmask, arity) {
59530            var Ctor = createCtor(func);
59531            function wrapper() {
59532              var length = arguments.length, args = Array2(length), index = length, placeholder = getHolder(wrapper);
59533              while (index--) {
59534                args[index] = arguments[index];
59535              }
59536              var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
59537              length -= holders.length;
59538              if (length < arity) {
59539                return createRecurry(
59540                  func,
59541                  bitmask,
59542                  createHybrid,
59543                  wrapper.placeholder,
59544                  undefined$1,
59545                  args,
59546                  holders,
59547                  undefined$1,
59548                  undefined$1,
59549                  arity - length
59550                );
59551              }
59552              var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
59553              return apply(fn, this, args);
59554            }
59555            return wrapper;
59556          }
59557          function createFind(findIndexFunc) {
59558            return function(collection, predicate, fromIndex) {
59559              var iterable = Object2(collection);
59560              if (!isArrayLike(collection)) {
59561                var iteratee2 = getIteratee(predicate, 3);
59562                collection = keys(collection);
59563                predicate = function(key2) {
59564                  return iteratee2(iterable[key2], key2, iterable);
59565                };
59566              }
59567              var index = findIndexFunc(collection, predicate, fromIndex);
59568              return index > -1 ? iterable[iteratee2 ? collection[index] : index] : undefined$1;
59569            };
59570          }
59571          function createFlow(fromRight) {
59572            return flatRest(function(funcs) {
59573              var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
59574              if (fromRight) {
59575                funcs.reverse();
59576              }
59577              while (index--) {
59578                var func = funcs[index];
59579                if (typeof func != "function") {
59580                  throw new TypeError2(FUNC_ERROR_TEXT);
59581                }
59582                if (prereq && !wrapper && getFuncName(func) == "wrapper") {
59583                  var wrapper = new LodashWrapper([], true);
59584                }
59585              }
59586              index = wrapper ? index : length;
59587              while (++index < length) {
59588                func = funcs[index];
59589                var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : undefined$1;
59590                if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) && !data[4].length && data[9] == 1) {
59591                  wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
59592                } else {
59593                  wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
59594                }
59595              }
59596              return function() {
59597                var args = arguments, value = args[0];
59598                if (wrapper && args.length == 1 && isArray2(value)) {
59599                  return wrapper.plant(value).value();
59600                }
59601                var index2 = 0, result2 = length ? funcs[index2].apply(this, args) : value;
59602                while (++index2 < length) {
59603                  result2 = funcs[index2].call(this, result2);
59604                }
59605                return result2;
59606              };
59607            });
59608          }
59609          function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary2, arity) {
59610            var isAry = bitmask & WRAP_ARY_FLAG, isBind = bitmask & WRAP_BIND_FLAG, isBindKey = bitmask & WRAP_BIND_KEY_FLAG, isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG), isFlip = bitmask & WRAP_FLIP_FLAG, Ctor = isBindKey ? undefined$1 : createCtor(func);
59611            function wrapper() {
59612              var length = arguments.length, args = Array2(length), index = length;
59613              while (index--) {
59614                args[index] = arguments[index];
59615              }
59616              if (isCurried) {
59617                var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
59618              }
59619              if (partials) {
59620                args = composeArgs(args, partials, holders, isCurried);
59621              }
59622              if (partialsRight) {
59623                args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
59624              }
59625              length -= holdersCount;
59626              if (isCurried && length < arity) {
59627                var newHolders = replaceHolders(args, placeholder);
59628                return createRecurry(
59629                  func,
59630                  bitmask,
59631                  createHybrid,
59632                  wrapper.placeholder,
59633                  thisArg,
59634                  args,
59635                  newHolders,
59636                  argPos,
59637                  ary2,
59638                  arity - length
59639                );
59640              }
59641              var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
59642              length = args.length;
59643              if (argPos) {
59644                args = reorder(args, argPos);
59645              } else if (isFlip && length > 1) {
59646                args.reverse();
59647              }
59648              if (isAry && ary2 < length) {
59649                args.length = ary2;
59650              }
59651              if (this && this !== root && this instanceof wrapper) {
59652                fn = Ctor || createCtor(fn);
59653              }
59654              return fn.apply(thisBinding, args);
59655            }
59656            return wrapper;
59657          }
59658          function createInverter(setter, toIteratee) {
59659            return function(object, iteratee2) {
59660              return baseInverter(object, setter, toIteratee(iteratee2), {});
59661            };
59662          }
59663          function createMathOperation(operator, defaultValue) {
59664            return function(value, other) {
59665              var result2;
59666              if (value === undefined$1 && other === undefined$1) {
59667                return defaultValue;
59668              }
59669              if (value !== undefined$1) {
59670                result2 = value;
59671              }
59672              if (other !== undefined$1) {
59673                if (result2 === undefined$1) {
59674                  return other;
59675                }
59676                if (typeof value == "string" || typeof other == "string") {
59677                  value = baseToString(value);
59678                  other = baseToString(other);
59679                } else {
59680                  value = baseToNumber(value);
59681                  other = baseToNumber(other);
59682                }
59683                result2 = operator(value, other);
59684              }
59685              return result2;
59686            };
59687          }
59688          function createOver(arrayFunc) {
59689            return flatRest(function(iteratees) {
59690              iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
59691              return baseRest(function(args) {
59692                var thisArg = this;
59693                return arrayFunc(iteratees, function(iteratee2) {
59694                  return apply(iteratee2, thisArg, args);
59695                });
59696              });
59697            });
59698          }
59699          function createPadding(length, chars) {
59700            chars = chars === undefined$1 ? " " : baseToString(chars);
59701            var charsLength = chars.length;
59702            if (charsLength < 2) {
59703              return charsLength ? baseRepeat(chars, length) : chars;
59704            }
59705            var result2 = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
59706            return hasUnicode(chars) ? castSlice(stringToArray(result2), 0, length).join("") : result2.slice(0, length);
59707          }
59708          function createPartial(func, bitmask, thisArg, partials) {
59709            var isBind = bitmask & WRAP_BIND_FLAG, Ctor = createCtor(func);
59710            function wrapper() {
59711              var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array2(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;
59712              while (++leftIndex < leftLength) {
59713                args[leftIndex] = partials[leftIndex];
59714              }
59715              while (argsLength--) {
59716                args[leftIndex++] = arguments[++argsIndex];
59717              }
59718              return apply(fn, isBind ? thisArg : this, args);
59719            }
59720            return wrapper;
59721          }
59722          function createRange(fromRight) {
59723            return function(start, end, step) {
59724              if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
59725                end = step = undefined$1;
59726              }
59727              start = toFinite(start);
59728              if (end === undefined$1) {
59729                end = start;
59730                start = 0;
59731              } else {
59732                end = toFinite(end);
59733              }
59734              step = step === undefined$1 ? start < end ? 1 : -1 : toFinite(step);
59735              return baseRange(start, end, step, fromRight);
59736            };
59737          }
59738          function createRelationalOperation(operator) {
59739            return function(value, other) {
59740              if (!(typeof value == "string" && typeof other == "string")) {
59741                value = toNumber(value);
59742                other = toNumber(other);
59743              }
59744              return operator(value, other);
59745            };
59746          }
59747          function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary2, arity) {
59748            var isCurry = bitmask & WRAP_CURRY_FLAG, newHolders = isCurry ? holders : undefined$1, newHoldersRight = isCurry ? undefined$1 : holders, newPartials = isCurry ? partials : undefined$1, newPartialsRight = isCurry ? undefined$1 : partials;
59749            bitmask |= isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG;
59750            bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
59751            if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
59752              bitmask &= -4;
59753            }
59754            var newData = [
59755              func,
59756              bitmask,
59757              thisArg,
59758              newPartials,
59759              newHolders,
59760              newPartialsRight,
59761              newHoldersRight,
59762              argPos,
59763              ary2,
59764              arity
59765            ];
59766            var result2 = wrapFunc.apply(undefined$1, newData);
59767            if (isLaziable(func)) {
59768              setData(result2, newData);
59769            }
59770            result2.placeholder = placeholder;
59771            return setWrapToString(result2, func, bitmask);
59772          }
59773          function createRound(methodName) {
59774            var func = Math2[methodName];
59775            return function(number, precision) {
59776              number = toNumber(number);
59777              precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
59778              if (precision && nativeIsFinite(number)) {
59779                var pair = (toString2(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
59780                pair = (toString2(value) + "e").split("e");
59781                return +(pair[0] + "e" + (+pair[1] - precision));
59782              }
59783              return func(number);
59784            };
59785          }
59786          var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop2 : function(values2) {
59787            return new Set2(values2);
59788          };
59789          function createToPairs(keysFunc) {
59790            return function(object) {
59791              var tag = getTag(object);
59792              if (tag == mapTag) {
59793                return mapToArray(object);
59794              }
59795              if (tag == setTag) {
59796                return setToPairs(object);
59797              }
59798              return baseToPairs(object, keysFunc(object));
59799            };
59800          }
59801          function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary2, arity) {
59802            var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
59803            if (!isBindKey && typeof func != "function") {
59804              throw new TypeError2(FUNC_ERROR_TEXT);
59805            }
59806            var length = partials ? partials.length : 0;
59807            if (!length) {
59808              bitmask &= -97;
59809              partials = holders = undefined$1;
59810            }
59811            ary2 = ary2 === undefined$1 ? ary2 : nativeMax(toInteger(ary2), 0);
59812            arity = arity === undefined$1 ? arity : toInteger(arity);
59813            length -= holders ? holders.length : 0;
59814            if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
59815              var partialsRight = partials, holdersRight = holders;
59816              partials = holders = undefined$1;
59817            }
59818            var data = isBindKey ? undefined$1 : getData(func);
59819            var newData = [
59820              func,
59821              bitmask,
59822              thisArg,
59823              partials,
59824              holders,
59825              partialsRight,
59826              holdersRight,
59827              argPos,
59828              ary2,
59829              arity
59830            ];
59831            if (data) {
59832              mergeData(newData, data);
59833            }
59834            func = newData[0];
59835            bitmask = newData[1];
59836            thisArg = newData[2];
59837            partials = newData[3];
59838            holders = newData[4];
59839            arity = newData[9] = newData[9] === undefined$1 ? isBindKey ? 0 : func.length : nativeMax(newData[9] - length, 0);
59840            if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
59841              bitmask &= -25;
59842            }
59843            if (!bitmask || bitmask == WRAP_BIND_FLAG) {
59844              var result2 = createBind(func, bitmask, thisArg);
59845            } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
59846              result2 = createCurry(func, bitmask, arity);
59847            } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
59848              result2 = createPartial(func, bitmask, thisArg, partials);
59849            } else {
59850              result2 = createHybrid.apply(undefined$1, newData);
59851            }
59852            var setter = data ? baseSetData : setData;
59853            return setWrapToString(setter(result2, newData), func, bitmask);
59854          }
59855          function customDefaultsAssignIn(objValue, srcValue, key2, object) {
59856            if (objValue === undefined$1 || eq(objValue, objectProto[key2]) && !hasOwnProperty2.call(object, key2)) {
59857              return srcValue;
59858            }
59859            return objValue;
59860          }
59861          function customDefaultsMerge(objValue, srcValue, key2, object, source, stack) {
59862            if (isObject2(objValue) && isObject2(srcValue)) {
59863              stack.set(srcValue, objValue);
59864              baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack);
59865              stack["delete"](srcValue);
59866            }
59867            return objValue;
59868          }
59869          function customOmitClone(value) {
59870            return isPlainObject2(value) ? undefined$1 : value;
59871          }
59872          function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
59873            var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
59874            if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
59875              return false;
59876            }
59877            var arrStacked = stack.get(array);
59878            var othStacked = stack.get(other);
59879            if (arrStacked && othStacked) {
59880              return arrStacked == other && othStacked == array;
59881            }
59882            var index = -1, result2 = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined$1;
59883            stack.set(array, other);
59884            stack.set(other, array);
59885            while (++index < arrLength) {
59886              var arrValue = array[index], othValue = other[index];
59887              if (customizer) {
59888                var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
59889              }
59890              if (compared !== undefined$1) {
59891                if (compared) {
59892                  continue;
59893                }
59894                result2 = false;
59895                break;
59896              }
59897              if (seen) {
59898                if (!arraySome(other, function(othValue2, othIndex) {
59899                  if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
59900                    return seen.push(othIndex);
59901                  }
59902                })) {
59903                  result2 = false;
59904                  break;
59905                }
59906              } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
59907                result2 = false;
59908                break;
59909              }
59910            }
59911            stack["delete"](array);
59912            stack["delete"](other);
59913            return result2;
59914          }
59915          function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
59916            switch (tag) {
59917              case dataViewTag:
59918                if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
59919                  return false;
59920                }
59921                object = object.buffer;
59922                other = other.buffer;
59923              case arrayBufferTag:
59924                if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
59925                  return false;
59926                }
59927                return true;
59928              case boolTag:
59929              case dateTag:
59930              case numberTag:
59931                return eq(+object, +other);
59932              case errorTag:
59933                return object.name == other.name && object.message == other.message;
59934              case regexpTag:
59935              case stringTag:
59936                return object == other + "";
59937              case mapTag:
59938                var convert = mapToArray;
59939              case setTag:
59940                var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
59941                convert || (convert = setToArray);
59942                if (object.size != other.size && !isPartial) {
59943                  return false;
59944                }
59945                var stacked = stack.get(object);
59946                if (stacked) {
59947                  return stacked == other;
59948                }
59949                bitmask |= COMPARE_UNORDERED_FLAG;
59950                stack.set(object, other);
59951                var result2 = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
59952                stack["delete"](object);
59953                return result2;
59954              case symbolTag:
59955                if (symbolValueOf) {
59956                  return symbolValueOf.call(object) == symbolValueOf.call(other);
59957                }
59958            }
59959            return false;
59960          }
59961          function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
59962            var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
59963            if (objLength != othLength && !isPartial) {
59964              return false;
59965            }
59966            var index = objLength;
59967            while (index--) {
59968              var key2 = objProps[index];
59969              if (!(isPartial ? key2 in other : hasOwnProperty2.call(other, key2))) {
59970                return false;
59971              }
59972            }
59973            var objStacked = stack.get(object);
59974            var othStacked = stack.get(other);
59975            if (objStacked && othStacked) {
59976              return objStacked == other && othStacked == object;
59977            }
59978            var result2 = true;
59979            stack.set(object, other);
59980            stack.set(other, object);
59981            var skipCtor = isPartial;
59982            while (++index < objLength) {
59983              key2 = objProps[index];
59984              var objValue = object[key2], othValue = other[key2];
59985              if (customizer) {
59986                var compared = isPartial ? customizer(othValue, objValue, key2, other, object, stack) : customizer(objValue, othValue, key2, object, other, stack);
59987              }
59988              if (!(compared === undefined$1 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
59989                result2 = false;
59990                break;
59991              }
59992              skipCtor || (skipCtor = key2 == "constructor");
59993            }
59994            if (result2 && !skipCtor) {
59995              var objCtor = object.constructor, othCtor = other.constructor;
59996              if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
59997                result2 = false;
59998              }
59999            }
60000            stack["delete"](object);
60001            stack["delete"](other);
60002            return result2;
60003          }
60004          function flatRest(func) {
60005            return setToString(overRest(func, undefined$1, flatten), func + "");
60006          }
60007          function getAllKeys(object) {
60008            return baseGetAllKeys(object, keys, getSymbols);
60009          }
60010          function getAllKeysIn(object) {
60011            return baseGetAllKeys(object, keysIn, getSymbolsIn);
60012          }
60013          var getData = !metaMap ? noop2 : function(func) {
60014            return metaMap.get(func);
60015          };
60016          function getFuncName(func) {
60017            var result2 = func.name + "", array = realNames[result2], length = hasOwnProperty2.call(realNames, result2) ? array.length : 0;
60018            while (length--) {
60019              var data = array[length], otherFunc = data.func;
60020              if (otherFunc == null || otherFunc == func) {
60021                return data.name;
60022              }
60023            }
60024            return result2;
60025          }
60026          function getHolder(func) {
60027            var object = hasOwnProperty2.call(lodash2, "placeholder") ? lodash2 : func;
60028            return object.placeholder;
60029          }
60030          function getIteratee() {
60031            var result2 = lodash2.iteratee || iteratee;
60032            result2 = result2 === iteratee ? baseIteratee : result2;
60033            return arguments.length ? result2(arguments[0], arguments[1]) : result2;
60034          }
60035          function getMapData(map2, key2) {
60036            var data = map2.__data__;
60037            return isKeyable(key2) ? data[typeof key2 == "string" ? "string" : "hash"] : data.map;
60038          }
60039          function getMatchData(object) {
60040            var result2 = keys(object), length = result2.length;
60041            while (length--) {
60042              var key2 = result2[length], value = object[key2];
60043              result2[length] = [key2, value, isStrictComparable(value)];
60044            }
60045            return result2;
60046          }
60047          function getNative(object, key2) {
60048            var value = getValue(object, key2);
60049            return baseIsNative(value) ? value : undefined$1;
60050          }
60051          function getRawTag(value) {
60052            var isOwn = hasOwnProperty2.call(value, symToStringTag), tag = value[symToStringTag];
60053            try {
60054              value[symToStringTag] = undefined$1;
60055              var unmasked = true;
60056            } catch (e) {
60057            }
60058            var result2 = nativeObjectToString.call(value);
60059            if (unmasked) {
60060              if (isOwn) {
60061                value[symToStringTag] = tag;
60062              } else {
60063                delete value[symToStringTag];
60064              }
60065            }
60066            return result2;
60067          }
60068          var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
60069            if (object == null) {
60070              return [];
60071            }
60072            object = Object2(object);
60073            return arrayFilter(nativeGetSymbols(object), function(symbol) {
60074              return propertyIsEnumerable.call(object, symbol);
60075            });
60076          };
60077          var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
60078            var result2 = [];
60079            while (object) {
60080              arrayPush(result2, getSymbols(object));
60081              object = getPrototype(object);
60082            }
60083            return result2;
60084          };
60085          var getTag = baseGetTag;
60086          if (DataView2 && getTag(new DataView2(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
60087            getTag = function(value) {
60088              var result2 = baseGetTag(value), Ctor = result2 == objectTag ? value.constructor : undefined$1, ctorString = Ctor ? toSource(Ctor) : "";
60089              if (ctorString) {
60090                switch (ctorString) {
60091                  case dataViewCtorString:
60092                    return dataViewTag;
60093                  case mapCtorString:
60094                    return mapTag;
60095                  case promiseCtorString:
60096                    return promiseTag;
60097                  case setCtorString:
60098                    return setTag;
60099                  case weakMapCtorString:
60100                    return weakMapTag;
60101                }
60102              }
60103              return result2;
60104            };
60105          }
60106          function getView(start, end, transforms) {
60107            var index = -1, length = transforms.length;
60108            while (++index < length) {
60109              var data = transforms[index], size2 = data.size;
60110              switch (data.type) {
60111                case "drop":
60112                  start += size2;
60113                  break;
60114                case "dropRight":
60115                  end -= size2;
60116                  break;
60117                case "take":
60118                  end = nativeMin(end, start + size2);
60119                  break;
60120                case "takeRight":
60121                  start = nativeMax(start, end - size2);
60122                  break;
60123              }
60124            }
60125            return { "start": start, "end": end };
60126          }
60127          function getWrapDetails(source) {
60128            var match = source.match(reWrapDetails);
60129            return match ? match[1].split(reSplitDetails) : [];
60130          }
60131          function hasPath(object, path, hasFunc) {
60132            path = castPath(path, object);
60133            var index = -1, length = path.length, result2 = false;
60134            while (++index < length) {
60135              var key2 = toKey(path[index]);
60136              if (!(result2 = object != null && hasFunc(object, key2))) {
60137                break;
60138              }
60139              object = object[key2];
60140            }
60141            if (result2 || ++index != length) {
60142              return result2;
60143            }
60144            length = object == null ? 0 : object.length;
60145            return !!length && isLength(length) && isIndex(key2, length) && (isArray2(object) || isArguments2(object));
60146          }
60147          function initCloneArray(array) {
60148            var length = array.length, result2 = new array.constructor(length);
60149            if (length && typeof array[0] == "string" && hasOwnProperty2.call(array, "index")) {
60150              result2.index = array.index;
60151              result2.input = array.input;
60152            }
60153            return result2;
60154          }
60155          function initCloneObject(object) {
60156            return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
60157          }
60158          function initCloneByTag(object, tag, isDeep) {
60159            var Ctor = object.constructor;
60160            switch (tag) {
60161              case arrayBufferTag:
60162                return cloneArrayBuffer(object);
60163              case boolTag:
60164              case dateTag:
60165                return new Ctor(+object);
60166              case dataViewTag:
60167                return cloneDataView(object, isDeep);
60168              case float32Tag:
60169              case float64Tag:
60170              case int8Tag:
60171              case int16Tag:
60172              case int32Tag:
60173              case uint8Tag:
60174              case uint8ClampedTag:
60175              case uint16Tag:
60176              case uint32Tag:
60177                return cloneTypedArray(object, isDeep);
60178              case mapTag:
60179                return new Ctor();
60180              case numberTag:
60181              case stringTag:
60182                return new Ctor(object);
60183              case regexpTag:
60184                return cloneRegExp(object);
60185              case setTag:
60186                return new Ctor();
60187              case symbolTag:
60188                return cloneSymbol(object);
60189            }
60190          }
60191          function insertWrapDetails(source, details) {
60192            var length = details.length;
60193            if (!length) {
60194              return source;
60195            }
60196            var lastIndex = length - 1;
60197            details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
60198            details = details.join(length > 2 ? ", " : " ");
60199            return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
60200          }
60201          function isFlattenable(value) {
60202            return isArray2(value) || isArguments2(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
60203          }
60204          function isIndex(value, length) {
60205            var type2 = typeof value;
60206            length = length == null ? MAX_SAFE_INTEGER : length;
60207            return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
60208          }
60209          function isIterateeCall(value, index, object) {
60210            if (!isObject2(object)) {
60211              return false;
60212            }
60213            var type2 = typeof index;
60214            if (type2 == "number" ? isArrayLike(object) && isIndex(index, object.length) : type2 == "string" && index in object) {
60215              return eq(object[index], value);
60216            }
60217            return false;
60218          }
60219          function isKey(value, object) {
60220            if (isArray2(value)) {
60221              return false;
60222            }
60223            var type2 = typeof value;
60224            if (type2 == "number" || type2 == "symbol" || type2 == "boolean" || value == null || isSymbol(value)) {
60225              return true;
60226            }
60227            return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object2(object);
60228          }
60229          function isKeyable(value) {
60230            var type2 = typeof value;
60231            return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
60232          }
60233          function isLaziable(func) {
60234            var funcName = getFuncName(func), other = lodash2[funcName];
60235            if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
60236              return false;
60237            }
60238            if (func === other) {
60239              return true;
60240            }
60241            var data = getData(other);
60242            return !!data && func === data[0];
60243          }
60244          function isMasked(func) {
60245            return !!maskSrcKey && maskSrcKey in func;
60246          }
60247          var isMaskable = coreJsData ? isFunction2 : stubFalse;
60248          function isPrototype(value) {
60249            var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
60250            return value === proto;
60251          }
60252          function isStrictComparable(value) {
60253            return value === value && !isObject2(value);
60254          }
60255          function matchesStrictComparable(key2, srcValue) {
60256            return function(object) {
60257              if (object == null) {
60258                return false;
60259              }
60260              return object[key2] === srcValue && (srcValue !== undefined$1 || key2 in Object2(object));
60261            };
60262          }
60263          function memoizeCapped(func) {
60264            var result2 = memoize(func, function(key2) {
60265              if (cache2.size === MAX_MEMOIZE_SIZE) {
60266                cache2.clear();
60267              }
60268              return key2;
60269            });
60270            var cache2 = result2.cache;
60271            return result2;
60272          }
60273          function mergeData(data, source) {
60274            var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
60275            var isCombo = srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_CURRY_FLAG || srcBitmask == WRAP_ARY_FLAG && bitmask == WRAP_REARG_FLAG && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG;
60276            if (!(isCommon || isCombo)) {
60277              return data;
60278            }
60279            if (srcBitmask & WRAP_BIND_FLAG) {
60280              data[2] = source[2];
60281              newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
60282            }
60283            var value = source[3];
60284            if (value) {
60285              var partials = data[3];
60286              data[3] = partials ? composeArgs(partials, value, source[4]) : value;
60287              data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
60288            }
60289            value = source[5];
60290            if (value) {
60291              partials = data[5];
60292              data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
60293              data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
60294            }
60295            value = source[7];
60296            if (value) {
60297              data[7] = value;
60298            }
60299            if (srcBitmask & WRAP_ARY_FLAG) {
60300              data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
60301            }
60302            if (data[9] == null) {
60303              data[9] = source[9];
60304            }
60305            data[0] = source[0];
60306            data[1] = newBitmask;
60307            return data;
60308          }
60309          function nativeKeysIn(object) {
60310            var result2 = [];
60311            if (object != null) {
60312              for (var key2 in Object2(object)) {
60313                result2.push(key2);
60314              }
60315            }
60316            return result2;
60317          }
60318          function objectToString(value) {
60319            return nativeObjectToString.call(value);
60320          }
60321          function overRest(func, start, transform2) {
60322            start = nativeMax(start === undefined$1 ? func.length - 1 : start, 0);
60323            return function() {
60324              var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array2(length);
60325              while (++index < length) {
60326                array[index] = args[start + index];
60327              }
60328              index = -1;
60329              var otherArgs = Array2(start + 1);
60330              while (++index < start) {
60331                otherArgs[index] = args[index];
60332              }
60333              otherArgs[start] = transform2(array);
60334              return apply(func, this, otherArgs);
60335            };
60336          }
60337          function parent(object, path) {
60338            return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
60339          }
60340          function reorder(array, indexes) {
60341            var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
60342            while (length--) {
60343              var index = indexes[length];
60344              array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1;
60345            }
60346            return array;
60347          }
60348          function safeGet(object, key2) {
60349            if (key2 === "constructor" && typeof object[key2] === "function") {
60350              return;
60351            }
60352            if (key2 == "__proto__") {
60353              return;
60354            }
60355            return object[key2];
60356          }
60357          var setData = shortOut(baseSetData);
60358          var setTimeout2 = ctxSetTimeout || function(func, wait) {
60359            return root.setTimeout(func, wait);
60360          };
60361          var setToString = shortOut(baseSetToString);
60362          function setWrapToString(wrapper, reference, bitmask) {
60363            var source = reference + "";
60364            return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
60365          }
60366          function shortOut(func) {
60367            var count = 0, lastCalled = 0;
60368            return function() {
60369              var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
60370              lastCalled = stamp;
60371              if (remaining > 0) {
60372                if (++count >= HOT_COUNT) {
60373                  return arguments[0];
60374                }
60375              } else {
60376                count = 0;
60377              }
60378              return func.apply(undefined$1, arguments);
60379            };
60380          }
60381          function shuffleSelf(array, size2) {
60382            var index = -1, length = array.length, lastIndex = length - 1;
60383            size2 = size2 === undefined$1 ? length : size2;
60384            while (++index < size2) {
60385              var rand = baseRandom(index, lastIndex), value = array[rand];
60386              array[rand] = array[index];
60387              array[index] = value;
60388            }
60389            array.length = size2;
60390            return array;
60391          }
60392          var stringToPath = memoizeCapped(function(string) {
60393            var result2 = [];
60394            if (string.charCodeAt(0) === 46) {
60395              result2.push("");
60396            }
60397            string.replace(rePropName, function(match, number, quote, subString) {
60398              result2.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
60399            });
60400            return result2;
60401          });
60402          function toKey(value) {
60403            if (typeof value == "string" || isSymbol(value)) {
60404              return value;
60405            }
60406            var result2 = value + "";
60407            return result2 == "0" && 1 / value == -INFINITY ? "-0" : result2;
60408          }
60409          function toSource(func) {
60410            if (func != null) {
60411              try {
60412                return funcToString.call(func);
60413              } catch (e) {
60414              }
60415              try {
60416                return func + "";
60417              } catch (e) {
60418              }
60419            }
60420            return "";
60421          }
60422          function updateWrapDetails(details, bitmask) {
60423            arrayEach(wrapFlags, function(pair) {
60424              var value = "_." + pair[0];
60425              if (bitmask & pair[1] && !arrayIncludes(details, value)) {
60426                details.push(value);
60427              }
60428            });
60429            return details.sort();
60430          }
60431          function wrapperClone(wrapper) {
60432            if (wrapper instanceof LazyWrapper) {
60433              return wrapper.clone();
60434            }
60435            var result2 = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
60436            result2.__actions__ = copyArray(wrapper.__actions__);
60437            result2.__index__ = wrapper.__index__;
60438            result2.__values__ = wrapper.__values__;
60439            return result2;
60440          }
60441          function chunk(array, size2, guard) {
60442            if (guard ? isIterateeCall(array, size2, guard) : size2 === undefined$1) {
60443              size2 = 1;
60444            } else {
60445              size2 = nativeMax(toInteger(size2), 0);
60446            }
60447            var length = array == null ? 0 : array.length;
60448            if (!length || size2 < 1) {
60449              return [];
60450            }
60451            var index = 0, resIndex = 0, result2 = Array2(nativeCeil(length / size2));
60452            while (index < length) {
60453              result2[resIndex++] = baseSlice(array, index, index += size2);
60454            }
60455            return result2;
60456          }
60457          function compact(array) {
60458            var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result2 = [];
60459            while (++index < length) {
60460              var value = array[index];
60461              if (value) {
60462                result2[resIndex++] = value;
60463              }
60464            }
60465            return result2;
60466          }
60467          function concat() {
60468            var length = arguments.length;
60469            if (!length) {
60470              return [];
60471            }
60472            var args = Array2(length - 1), array = arguments[0], index = length;
60473            while (index--) {
60474              args[index - 1] = arguments[index];
60475            }
60476            return arrayPush(isArray2(array) ? copyArray(array) : [array], baseFlatten(args, 1));
60477          }
60478          var difference = baseRest(function(array, values2) {
60479            return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true)) : [];
60480          });
60481          var differenceBy = baseRest(function(array, values2) {
60482            var iteratee2 = last(values2);
60483            if (isArrayLikeObject(iteratee2)) {
60484              iteratee2 = undefined$1;
60485            }
60486            return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2)) : [];
60487          });
60488          var differenceWith = baseRest(function(array, values2) {
60489            var comparator = last(values2);
60490            if (isArrayLikeObject(comparator)) {
60491              comparator = undefined$1;
60492            }
60493            return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values2, 1, isArrayLikeObject, true), undefined$1, comparator) : [];
60494          });
60495          function drop(array, n, guard) {
60496            var length = array == null ? 0 : array.length;
60497            if (!length) {
60498              return [];
60499            }
60500            n = guard || n === undefined$1 ? 1 : toInteger(n);
60501            return baseSlice(array, n < 0 ? 0 : n, length);
60502          }
60503          function dropRight(array, n, guard) {
60504            var length = array == null ? 0 : array.length;
60505            if (!length) {
60506              return [];
60507            }
60508            n = guard || n === undefined$1 ? 1 : toInteger(n);
60509            n = length - n;
60510            return baseSlice(array, 0, n < 0 ? 0 : n);
60511          }
60512          function dropRightWhile(array, predicate) {
60513            return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true, true) : [];
60514          }
60515          function dropWhile(array, predicate) {
60516            return array && array.length ? baseWhile(array, getIteratee(predicate, 3), true) : [];
60517          }
60518          function fill(array, value, start, end) {
60519            var length = array == null ? 0 : array.length;
60520            if (!length) {
60521              return [];
60522            }
60523            if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
60524              start = 0;
60525              end = length;
60526            }
60527            return baseFill(array, value, start, end);
60528          }
60529          function findIndex(array, predicate, fromIndex) {
60530            var length = array == null ? 0 : array.length;
60531            if (!length) {
60532              return -1;
60533            }
60534            var index = fromIndex == null ? 0 : toInteger(fromIndex);
60535            if (index < 0) {
60536              index = nativeMax(length + index, 0);
60537            }
60538            return baseFindIndex(array, getIteratee(predicate, 3), index);
60539          }
60540          function findLastIndex(array, predicate, fromIndex) {
60541            var length = array == null ? 0 : array.length;
60542            if (!length) {
60543              return -1;
60544            }
60545            var index = length - 1;
60546            if (fromIndex !== undefined$1) {
60547              index = toInteger(fromIndex);
60548              index = fromIndex < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
60549            }
60550            return baseFindIndex(array, getIteratee(predicate, 3), index, true);
60551          }
60552          function flatten(array) {
60553            var length = array == null ? 0 : array.length;
60554            return length ? baseFlatten(array, 1) : [];
60555          }
60556          function flattenDeep(array) {
60557            var length = array == null ? 0 : array.length;
60558            return length ? baseFlatten(array, INFINITY) : [];
60559          }
60560          function flattenDepth(array, depth) {
60561            var length = array == null ? 0 : array.length;
60562            if (!length) {
60563              return [];
60564            }
60565            depth = depth === undefined$1 ? 1 : toInteger(depth);
60566            return baseFlatten(array, depth);
60567          }
60568          function fromPairs(pairs) {
60569            var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
60570            while (++index < length) {
60571              var pair = pairs[index];
60572              baseAssignValue(result2, pair[0], pair[1]);
60573            }
60574            return result2;
60575          }
60576          function head(array) {
60577            return array && array.length ? array[0] : undefined$1;
60578          }
60579          function indexOf2(array, value, fromIndex) {
60580            var length = array == null ? 0 : array.length;
60581            if (!length) {
60582              return -1;
60583            }
60584            var index = fromIndex == null ? 0 : toInteger(fromIndex);
60585            if (index < 0) {
60586              index = nativeMax(length + index, 0);
60587            }
60588            return baseIndexOf(array, value, index);
60589          }
60590          function initial(array) {
60591            var length = array == null ? 0 : array.length;
60592            return length ? baseSlice(array, 0, -1) : [];
60593          }
60594          var intersection = baseRest(function(arrays) {
60595            var mapped = arrayMap(arrays, castArrayLikeObject);
60596            return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
60597          });
60598          var intersectionBy = baseRest(function(arrays) {
60599            var iteratee2 = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
60600            if (iteratee2 === last(mapped)) {
60601              iteratee2 = undefined$1;
60602            } else {
60603              mapped.pop();
60604            }
60605            return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, getIteratee(iteratee2, 2)) : [];
60606          });
60607          var intersectionWith = baseRest(function(arrays) {
60608            var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
60609            comparator = typeof comparator == "function" ? comparator : undefined$1;
60610            if (comparator) {
60611              mapped.pop();
60612            }
60613            return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined$1, comparator) : [];
60614          });
60615          function join(array, separator) {
60616            return array == null ? "" : nativeJoin.call(array, separator);
60617          }
60618          function last(array) {
60619            var length = array == null ? 0 : array.length;
60620            return length ? array[length - 1] : undefined$1;
60621          }
60622          function lastIndexOf(array, value, fromIndex) {
60623            var length = array == null ? 0 : array.length;
60624            if (!length) {
60625              return -1;
60626            }
60627            var index = length;
60628            if (fromIndex !== undefined$1) {
60629              index = toInteger(fromIndex);
60630              index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
60631            }
60632            return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);
60633          }
60634          function nth(array, n) {
60635            return array && array.length ? baseNth(array, toInteger(n)) : undefined$1;
60636          }
60637          var pull = baseRest(pullAll);
60638          function pullAll(array, values2) {
60639            return array && array.length && values2 && values2.length ? basePullAll(array, values2) : array;
60640          }
60641          function pullAllBy(array, values2, iteratee2) {
60642            return array && array.length && values2 && values2.length ? basePullAll(array, values2, getIteratee(iteratee2, 2)) : array;
60643          }
60644          function pullAllWith(array, values2, comparator) {
60645            return array && array.length && values2 && values2.length ? basePullAll(array, values2, undefined$1, comparator) : array;
60646          }
60647          var pullAt = flatRest(function(array, indexes) {
60648            var length = array == null ? 0 : array.length, result2 = baseAt(array, indexes);
60649            basePullAt(array, arrayMap(indexes, function(index) {
60650              return isIndex(index, length) ? +index : index;
60651            }).sort(compareAscending));
60652            return result2;
60653          });
60654          function remove(array, predicate) {
60655            var result2 = [];
60656            if (!(array && array.length)) {
60657              return result2;
60658            }
60659            var index = -1, indexes = [], length = array.length;
60660            predicate = getIteratee(predicate, 3);
60661            while (++index < length) {
60662              var value = array[index];
60663              if (predicate(value, index, array)) {
60664                result2.push(value);
60665                indexes.push(index);
60666              }
60667            }
60668            basePullAt(array, indexes);
60669            return result2;
60670          }
60671          function reverse(array) {
60672            return array == null ? array : nativeReverse.call(array);
60673          }
60674          function slice(array, start, end) {
60675            var length = array == null ? 0 : array.length;
60676            if (!length) {
60677              return [];
60678            }
60679            if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
60680              start = 0;
60681              end = length;
60682            } else {
60683              start = start == null ? 0 : toInteger(start);
60684              end = end === undefined$1 ? length : toInteger(end);
60685            }
60686            return baseSlice(array, start, end);
60687          }
60688          function sortedIndex(array, value) {
60689            return baseSortedIndex(array, value);
60690          }
60691          function sortedIndexBy(array, value, iteratee2) {
60692            return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2));
60693          }
60694          function sortedIndexOf(array, value) {
60695            var length = array == null ? 0 : array.length;
60696            if (length) {
60697              var index = baseSortedIndex(array, value);
60698              if (index < length && eq(array[index], value)) {
60699                return index;
60700              }
60701            }
60702            return -1;
60703          }
60704          function sortedLastIndex(array, value) {
60705            return baseSortedIndex(array, value, true);
60706          }
60707          function sortedLastIndexBy(array, value, iteratee2) {
60708            return baseSortedIndexBy(array, value, getIteratee(iteratee2, 2), true);
60709          }
60710          function sortedLastIndexOf(array, value) {
60711            var length = array == null ? 0 : array.length;
60712            if (length) {
60713              var index = baseSortedIndex(array, value, true) - 1;
60714              if (eq(array[index], value)) {
60715                return index;
60716              }
60717            }
60718            return -1;
60719          }
60720          function sortedUniq(array) {
60721            return array && array.length ? baseSortedUniq(array) : [];
60722          }
60723          function sortedUniqBy(array, iteratee2) {
60724            return array && array.length ? baseSortedUniq(array, getIteratee(iteratee2, 2)) : [];
60725          }
60726          function tail(array) {
60727            var length = array == null ? 0 : array.length;
60728            return length ? baseSlice(array, 1, length) : [];
60729          }
60730          function take(array, n, guard) {
60731            if (!(array && array.length)) {
60732              return [];
60733            }
60734            n = guard || n === undefined$1 ? 1 : toInteger(n);
60735            return baseSlice(array, 0, n < 0 ? 0 : n);
60736          }
60737          function takeRight(array, n, guard) {
60738            var length = array == null ? 0 : array.length;
60739            if (!length) {
60740              return [];
60741            }
60742            n = guard || n === undefined$1 ? 1 : toInteger(n);
60743            n = length - n;
60744            return baseSlice(array, n < 0 ? 0 : n, length);
60745          }
60746          function takeRightWhile(array, predicate) {
60747            return array && array.length ? baseWhile(array, getIteratee(predicate, 3), false, true) : [];
60748          }
60749          function takeWhile(array, predicate) {
60750            return array && array.length ? baseWhile(array, getIteratee(predicate, 3)) : [];
60751          }
60752          var union = baseRest(function(arrays) {
60753            return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
60754          });
60755          var unionBy = baseRest(function(arrays) {
60756            var iteratee2 = last(arrays);
60757            if (isArrayLikeObject(iteratee2)) {
60758              iteratee2 = undefined$1;
60759            }
60760            return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee2, 2));
60761          });
60762          var unionWith = baseRest(function(arrays) {
60763            var comparator = last(arrays);
60764            comparator = typeof comparator == "function" ? comparator : undefined$1;
60765            return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);
60766          });
60767          function uniq(array) {
60768            return array && array.length ? baseUniq(array) : [];
60769          }
60770          function uniqBy(array, iteratee2) {
60771            return array && array.length ? baseUniq(array, getIteratee(iteratee2, 2)) : [];
60772          }
60773          function uniqWith(array, comparator) {
60774            comparator = typeof comparator == "function" ? comparator : undefined$1;
60775            return array && array.length ? baseUniq(array, undefined$1, comparator) : [];
60776          }
60777          function unzip(array) {
60778            if (!(array && array.length)) {
60779              return [];
60780            }
60781            var length = 0;
60782            array = arrayFilter(array, function(group) {
60783              if (isArrayLikeObject(group)) {
60784                length = nativeMax(group.length, length);
60785                return true;
60786              }
60787            });
60788            return baseTimes(length, function(index) {
60789              return arrayMap(array, baseProperty(index));
60790            });
60791          }
60792          function unzipWith(array, iteratee2) {
60793            if (!(array && array.length)) {
60794              return [];
60795            }
60796            var result2 = unzip(array);
60797            if (iteratee2 == null) {
60798              return result2;
60799            }
60800            return arrayMap(result2, function(group) {
60801              return apply(iteratee2, undefined$1, group);
60802            });
60803          }
60804          var without = baseRest(function(array, values2) {
60805            return isArrayLikeObject(array) ? baseDifference(array, values2) : [];
60806          });
60807          var xor2 = baseRest(function(arrays) {
60808            return baseXor(arrayFilter(arrays, isArrayLikeObject));
60809          });
60810          var xorBy = baseRest(function(arrays) {
60811            var iteratee2 = last(arrays);
60812            if (isArrayLikeObject(iteratee2)) {
60813              iteratee2 = undefined$1;
60814            }
60815            return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee2, 2));
60816          });
60817          var xorWith = baseRest(function(arrays) {
60818            var comparator = last(arrays);
60819            comparator = typeof comparator == "function" ? comparator : undefined$1;
60820            return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator);
60821          });
60822          var zip = baseRest(unzip);
60823          function zipObject(props, values2) {
60824            return baseZipObject(props || [], values2 || [], assignValue);
60825          }
60826          function zipObjectDeep(props, values2) {
60827            return baseZipObject(props || [], values2 || [], baseSet);
60828          }
60829          var zipWith = baseRest(function(arrays) {
60830            var length = arrays.length, iteratee2 = length > 1 ? arrays[length - 1] : undefined$1;
60831            iteratee2 = typeof iteratee2 == "function" ? (arrays.pop(), iteratee2) : undefined$1;
60832            return unzipWith(arrays, iteratee2);
60833          });
60834          function chain(value) {
60835            var result2 = lodash2(value);
60836            result2.__chain__ = true;
60837            return result2;
60838          }
60839          function tap(value, interceptor) {
60840            interceptor(value);
60841            return value;
60842          }
60843          function thru(value, interceptor) {
60844            return interceptor(value);
60845          }
60846          var wrapperAt = flatRest(function(paths) {
60847            var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {
60848              return baseAt(object, paths);
60849            };
60850            if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {
60851              return this.thru(interceptor);
60852            }
60853            value = value.slice(start, +start + (length ? 1 : 0));
60854            value.__actions__.push({
60855              "func": thru,
60856              "args": [interceptor],
60857              "thisArg": undefined$1
60858            });
60859            return new LodashWrapper(value, this.__chain__).thru(function(array) {
60860              if (length && !array.length) {
60861                array.push(undefined$1);
60862              }
60863              return array;
60864            });
60865          });
60866          function wrapperChain() {
60867            return chain(this);
60868          }
60869          function wrapperCommit() {
60870            return new LodashWrapper(this.value(), this.__chain__);
60871          }
60872          function wrapperNext() {
60873            if (this.__values__ === undefined$1) {
60874              this.__values__ = toArray2(this.value());
60875            }
60876            var done = this.__index__ >= this.__values__.length, value = done ? undefined$1 : this.__values__[this.__index__++];
60877            return { "done": done, "value": value };
60878          }
60879          function wrapperToIterator() {
60880            return this;
60881          }
60882          function wrapperPlant(value) {
60883            var result2, parent2 = this;
60884            while (parent2 instanceof baseLodash) {
60885              var clone2 = wrapperClone(parent2);
60886              clone2.__index__ = 0;
60887              clone2.__values__ = undefined$1;
60888              if (result2) {
60889                previous.__wrapped__ = clone2;
60890              } else {
60891                result2 = clone2;
60892              }
60893              var previous = clone2;
60894              parent2 = parent2.__wrapped__;
60895            }
60896            previous.__wrapped__ = value;
60897            return result2;
60898          }
60899          function wrapperReverse() {
60900            var value = this.__wrapped__;
60901            if (value instanceof LazyWrapper) {
60902              var wrapped = value;
60903              if (this.__actions__.length) {
60904                wrapped = new LazyWrapper(this);
60905              }
60906              wrapped = wrapped.reverse();
60907              wrapped.__actions__.push({
60908                "func": thru,
60909                "args": [reverse],
60910                "thisArg": undefined$1
60911              });
60912              return new LodashWrapper(wrapped, this.__chain__);
60913            }
60914            return this.thru(reverse);
60915          }
60916          function wrapperValue() {
60917            return baseWrapperValue(this.__wrapped__, this.__actions__);
60918          }
60919          var countBy = createAggregator(function(result2, value, key2) {
60920            if (hasOwnProperty2.call(result2, key2)) {
60921              ++result2[key2];
60922            } else {
60923              baseAssignValue(result2, key2, 1);
60924            }
60925          });
60926          function every(collection, predicate, guard) {
60927            var func = isArray2(collection) ? arrayEvery : baseEvery;
60928            if (guard && isIterateeCall(collection, predicate, guard)) {
60929              predicate = undefined$1;
60930            }
60931            return func(collection, getIteratee(predicate, 3));
60932          }
60933          function filter(collection, predicate) {
60934            var func = isArray2(collection) ? arrayFilter : baseFilter;
60935            return func(collection, getIteratee(predicate, 3));
60936          }
60937          var find = createFind(findIndex);
60938          var findLast = createFind(findLastIndex);
60939          function flatMap(collection, iteratee2) {
60940            return baseFlatten(map(collection, iteratee2), 1);
60941          }
60942          function flatMapDeep(collection, iteratee2) {
60943            return baseFlatten(map(collection, iteratee2), INFINITY);
60944          }
60945          function flatMapDepth(collection, iteratee2, depth) {
60946            depth = depth === undefined$1 ? 1 : toInteger(depth);
60947            return baseFlatten(map(collection, iteratee2), depth);
60948          }
60949          function forEach2(collection, iteratee2) {
60950            var func = isArray2(collection) ? arrayEach : baseEach;
60951            return func(collection, getIteratee(iteratee2, 3));
60952          }
60953          function forEachRight(collection, iteratee2) {
60954            var func = isArray2(collection) ? arrayEachRight : baseEachRight;
60955            return func(collection, getIteratee(iteratee2, 3));
60956          }
60957          var groupBy = createAggregator(function(result2, value, key2) {
60958            if (hasOwnProperty2.call(result2, key2)) {
60959              result2[key2].push(value);
60960            } else {
60961              baseAssignValue(result2, key2, [value]);
60962            }
60963          });
60964          function includes(collection, value, fromIndex, guard) {
60965            collection = isArrayLike(collection) ? collection : values(collection);
60966            fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
60967            var length = collection.length;
60968            if (fromIndex < 0) {
60969              fromIndex = nativeMax(length + fromIndex, 0);
60970            }
60971            return isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
60972          }
60973          var invokeMap = baseRest(function(collection, path, args) {
60974            var index = -1, isFunc = typeof path == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
60975            baseEach(collection, function(value) {
60976              result2[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
60977            });
60978            return result2;
60979          });
60980          var keyBy = createAggregator(function(result2, value, key2) {
60981            baseAssignValue(result2, key2, value);
60982          });
60983          function map(collection, iteratee2) {
60984            var func = isArray2(collection) ? arrayMap : baseMap;
60985            return func(collection, getIteratee(iteratee2, 3));
60986          }
60987          function orderBy(collection, iteratees, orders, guard) {
60988            if (collection == null) {
60989              return [];
60990            }
60991            if (!isArray2(iteratees)) {
60992              iteratees = iteratees == null ? [] : [iteratees];
60993            }
60994            orders = guard ? undefined$1 : orders;
60995            if (!isArray2(orders)) {
60996              orders = orders == null ? [] : [orders];
60997            }
60998            return baseOrderBy(collection, iteratees, orders);
60999          }
61000          var partition = createAggregator(function(result2, value, key2) {
61001            result2[key2 ? 0 : 1].push(value);
61002          }, function() {
61003            return [[], []];
61004          });
61005          function reduce(collection, iteratee2, accumulator) {
61006            var func = isArray2(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
61007            return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEach);
61008          }
61009          function reduceRight(collection, iteratee2, accumulator) {
61010            var func = isArray2(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
61011            return func(collection, getIteratee(iteratee2, 4), accumulator, initAccum, baseEachRight);
61012          }
61013          function reject(collection, predicate) {
61014            var func = isArray2(collection) ? arrayFilter : baseFilter;
61015            return func(collection, negate(getIteratee(predicate, 3)));
61016          }
61017          function sample(collection) {
61018            var func = isArray2(collection) ? arraySample : baseSample;
61019            return func(collection);
61020          }
61021          function sampleSize(collection, n, guard) {
61022            if (guard ? isIterateeCall(collection, n, guard) : n === undefined$1) {
61023              n = 1;
61024            } else {
61025              n = toInteger(n);
61026            }
61027            var func = isArray2(collection) ? arraySampleSize : baseSampleSize;
61028            return func(collection, n);
61029          }
61030          function shuffle(collection) {
61031            var func = isArray2(collection) ? arrayShuffle : baseShuffle;
61032            return func(collection);
61033          }
61034          function size(collection) {
61035            if (collection == null) {
61036              return 0;
61037            }
61038            if (isArrayLike(collection)) {
61039              return isString2(collection) ? stringSize(collection) : collection.length;
61040            }
61041            var tag = getTag(collection);
61042            if (tag == mapTag || tag == setTag) {
61043              return collection.size;
61044            }
61045            return baseKeys(collection).length;
61046          }
61047          function some(collection, predicate, guard) {
61048            var func = isArray2(collection) ? arraySome : baseSome;
61049            if (guard && isIterateeCall(collection, predicate, guard)) {
61050              predicate = undefined$1;
61051            }
61052            return func(collection, getIteratee(predicate, 3));
61053          }
61054          var sortBy = baseRest(function(collection, iteratees) {
61055            if (collection == null) {
61056              return [];
61057            }
61058            var length = iteratees.length;
61059            if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
61060              iteratees = [];
61061            } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
61062              iteratees = [iteratees[0]];
61063            }
61064            return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
61065          });
61066          var now = ctxNow || function() {
61067            return root.Date.now();
61068          };
61069          function after(n, func) {
61070            if (typeof func != "function") {
61071              throw new TypeError2(FUNC_ERROR_TEXT);
61072            }
61073            n = toInteger(n);
61074            return function() {
61075              if (--n < 1) {
61076                return func.apply(this, arguments);
61077              }
61078            };
61079          }
61080          function ary(func, n, guard) {
61081            n = guard ? undefined$1 : n;
61082            n = func && n == null ? func.length : n;
61083            return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);
61084          }
61085          function before(n, func) {
61086            var result2;
61087            if (typeof func != "function") {
61088              throw new TypeError2(FUNC_ERROR_TEXT);
61089            }
61090            n = toInteger(n);
61091            return function() {
61092              if (--n > 0) {
61093                result2 = func.apply(this, arguments);
61094              }
61095              if (n <= 1) {
61096                func = undefined$1;
61097              }
61098              return result2;
61099            };
61100          }
61101          var bind2 = baseRest(function(func, thisArg, partials) {
61102            var bitmask = WRAP_BIND_FLAG;
61103            if (partials.length) {
61104              var holders = replaceHolders(partials, getHolder(bind2));
61105              bitmask |= WRAP_PARTIAL_FLAG;
61106            }
61107            return createWrap(func, bitmask, thisArg, partials, holders);
61108          });
61109          var bindKey = baseRest(function(object, key2, partials) {
61110            var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
61111            if (partials.length) {
61112              var holders = replaceHolders(partials, getHolder(bindKey));
61113              bitmask |= WRAP_PARTIAL_FLAG;
61114            }
61115            return createWrap(key2, bitmask, object, partials, holders);
61116          });
61117          function curry(func, arity, guard) {
61118            arity = guard ? undefined$1 : arity;
61119            var result2 = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
61120            result2.placeholder = curry.placeholder;
61121            return result2;
61122          }
61123          function curryRight(func, arity, guard) {
61124            arity = guard ? undefined$1 : arity;
61125            var result2 = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
61126            result2.placeholder = curryRight.placeholder;
61127            return result2;
61128          }
61129          function debounce(func, wait, options) {
61130            var lastArgs, lastThis, maxWait, result2, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
61131            if (typeof func != "function") {
61132              throw new TypeError2(FUNC_ERROR_TEXT);
61133            }
61134            wait = toNumber(wait) || 0;
61135            if (isObject2(options)) {
61136              leading = !!options.leading;
61137              maxing = "maxWait" in options;
61138              maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
61139              trailing = "trailing" in options ? !!options.trailing : trailing;
61140            }
61141            function invokeFunc(time) {
61142              var args = lastArgs, thisArg = lastThis;
61143              lastArgs = lastThis = undefined$1;
61144              lastInvokeTime = time;
61145              result2 = func.apply(thisArg, args);
61146              return result2;
61147            }
61148            function leadingEdge(time) {
61149              lastInvokeTime = time;
61150              timerId = setTimeout2(timerExpired, wait);
61151              return leading ? invokeFunc(time) : result2;
61152            }
61153            function remainingWait(time) {
61154              var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
61155              return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
61156            }
61157            function shouldInvoke(time) {
61158              var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
61159              return lastCallTime === undefined$1 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
61160            }
61161            function timerExpired() {
61162              var time = now();
61163              if (shouldInvoke(time)) {
61164                return trailingEdge(time);
61165              }
61166              timerId = setTimeout2(timerExpired, remainingWait(time));
61167            }
61168            function trailingEdge(time) {
61169              timerId = undefined$1;
61170              if (trailing && lastArgs) {
61171                return invokeFunc(time);
61172              }
61173              lastArgs = lastThis = undefined$1;
61174              return result2;
61175            }
61176            function cancel() {
61177              if (timerId !== undefined$1) {
61178                clearTimeout2(timerId);
61179              }
61180              lastInvokeTime = 0;
61181              lastArgs = lastCallTime = lastThis = timerId = undefined$1;
61182            }
61183            function flush() {
61184              return timerId === undefined$1 ? result2 : trailingEdge(now());
61185            }
61186            function debounced() {
61187              var time = now(), isInvoking = shouldInvoke(time);
61188              lastArgs = arguments;
61189              lastThis = this;
61190              lastCallTime = time;
61191              if (isInvoking) {
61192                if (timerId === undefined$1) {
61193                  return leadingEdge(lastCallTime);
61194                }
61195                if (maxing) {
61196                  clearTimeout2(timerId);
61197                  timerId = setTimeout2(timerExpired, wait);
61198                  return invokeFunc(lastCallTime);
61199                }
61200              }
61201              if (timerId === undefined$1) {
61202                timerId = setTimeout2(timerExpired, wait);
61203              }
61204              return result2;
61205            }
61206            debounced.cancel = cancel;
61207            debounced.flush = flush;
61208            return debounced;
61209          }
61210          var defer = baseRest(function(func, args) {
61211            return baseDelay(func, 1, args);
61212          });
61213          var delay = baseRest(function(func, wait, args) {
61214            return baseDelay(func, toNumber(wait) || 0, args);
61215          });
61216          function flip(func) {
61217            return createWrap(func, WRAP_FLIP_FLAG);
61218          }
61219          function memoize(func, resolver) {
61220            if (typeof func != "function" || resolver != null && typeof resolver != "function") {
61221              throw new TypeError2(FUNC_ERROR_TEXT);
61222            }
61223            var memoized = function() {
61224              var args = arguments, key2 = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
61225              if (cache2.has(key2)) {
61226                return cache2.get(key2);
61227              }
61228              var result2 = func.apply(this, args);
61229              memoized.cache = cache2.set(key2, result2) || cache2;
61230              return result2;
61231            };
61232            memoized.cache = new (memoize.Cache || MapCache)();
61233            return memoized;
61234          }
61235          memoize.Cache = MapCache;
61236          function negate(predicate) {
61237            if (typeof predicate != "function") {
61238              throw new TypeError2(FUNC_ERROR_TEXT);
61239            }
61240            return function() {
61241              var args = arguments;
61242              switch (args.length) {
61243                case 0:
61244                  return !predicate.call(this);
61245                case 1:
61246                  return !predicate.call(this, args[0]);
61247                case 2:
61248                  return !predicate.call(this, args[0], args[1]);
61249                case 3:
61250                  return !predicate.call(this, args[0], args[1], args[2]);
61251              }
61252              return !predicate.apply(this, args);
61253            };
61254          }
61255          function once(func) {
61256            return before(2, func);
61257          }
61258          var overArgs = castRest(function(func, transforms) {
61259            transforms = transforms.length == 1 && isArray2(transforms[0]) ? arrayMap(transforms[0], baseUnary(getIteratee())) : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
61260            var funcsLength = transforms.length;
61261            return baseRest(function(args) {
61262              var index = -1, length = nativeMin(args.length, funcsLength);
61263              while (++index < length) {
61264                args[index] = transforms[index].call(this, args[index]);
61265              }
61266              return apply(func, this, args);
61267            });
61268          });
61269          var partial = baseRest(function(func, partials) {
61270            var holders = replaceHolders(partials, getHolder(partial));
61271            return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);
61272          });
61273          var partialRight = baseRest(function(func, partials) {
61274            var holders = replaceHolders(partials, getHolder(partialRight));
61275            return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);
61276          });
61277          var rearg = flatRest(function(func, indexes) {
61278            return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);
61279          });
61280          function rest(func, start) {
61281            if (typeof func != "function") {
61282              throw new TypeError2(FUNC_ERROR_TEXT);
61283            }
61284            start = start === undefined$1 ? start : toInteger(start);
61285            return baseRest(func, start);
61286          }
61287          function spread2(func, start) {
61288            if (typeof func != "function") {
61289              throw new TypeError2(FUNC_ERROR_TEXT);
61290            }
61291            start = start == null ? 0 : nativeMax(toInteger(start), 0);
61292            return baseRest(function(args) {
61293              var array = args[start], otherArgs = castSlice(args, 0, start);
61294              if (array) {
61295                arrayPush(otherArgs, array);
61296              }
61297              return apply(func, this, otherArgs);
61298            });
61299          }
61300          function throttle2(func, wait, options) {
61301            var leading = true, trailing = true;
61302            if (typeof func != "function") {
61303              throw new TypeError2(FUNC_ERROR_TEXT);
61304            }
61305            if (isObject2(options)) {
61306              leading = "leading" in options ? !!options.leading : leading;
61307              trailing = "trailing" in options ? !!options.trailing : trailing;
61308            }
61309            return debounce(func, wait, {
61310              "leading": leading,
61311              "maxWait": wait,
61312              "trailing": trailing
61313            });
61314          }
61315          function unary(func) {
61316            return ary(func, 1);
61317          }
61318          function wrap(value, wrapper) {
61319            return partial(castFunction(wrapper), value);
61320          }
61321          function castArray() {
61322            if (!arguments.length) {
61323              return [];
61324            }
61325            var value = arguments[0];
61326            return isArray2(value) ? value : [value];
61327          }
61328          function clone(value) {
61329            return baseClone(value, CLONE_SYMBOLS_FLAG);
61330          }
61331          function cloneWith(value, customizer) {
61332            customizer = typeof customizer == "function" ? customizer : undefined$1;
61333            return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
61334          }
61335          function cloneDeep(value) {
61336            return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
61337          }
61338          function cloneDeepWith(value, customizer) {
61339            customizer = typeof customizer == "function" ? customizer : undefined$1;
61340            return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
61341          }
61342          function conformsTo(object, source) {
61343            return source == null || baseConformsTo(object, source, keys(source));
61344          }
61345          function eq(value, other) {
61346            return value === other || value !== value && other !== other;
61347          }
61348          var gt = createRelationalOperation(baseGt);
61349          var gte = createRelationalOperation(function(value, other) {
61350            return value >= other;
61351          });
61352          var isArguments2 = baseIsArguments(/* @__PURE__ */ (function() {
61353            return arguments;
61354          })()) ? baseIsArguments : function(value) {
61355            return isObjectLike(value) && hasOwnProperty2.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
61356          };
61357          var isArray2 = Array2.isArray;
61358          var isArrayBuffer2 = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
61359          function isArrayLike(value) {
61360            return value != null && isLength(value.length) && !isFunction2(value);
61361          }
61362          function isArrayLikeObject(value) {
61363            return isObjectLike(value) && isArrayLike(value);
61364          }
61365          function isBoolean2(value) {
61366            return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
61367          }
61368          var isBuffer2 = nativeIsBuffer || stubFalse;
61369          var isDate2 = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
61370          function isElement(value) {
61371            return isObjectLike(value) && value.nodeType === 1 && !isPlainObject2(value);
61372          }
61373          function isEmpty(value) {
61374            if (value == null) {
61375              return true;
61376            }
61377            if (isArrayLike(value) && (isArray2(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer2(value) || isTypedArray2(value) || isArguments2(value))) {
61378              return !value.length;
61379            }
61380            var tag = getTag(value);
61381            if (tag == mapTag || tag == setTag) {
61382              return !value.size;
61383            }
61384            if (isPrototype(value)) {
61385              return !baseKeys(value).length;
61386            }
61387            for (var key2 in value) {
61388              if (hasOwnProperty2.call(value, key2)) {
61389                return false;
61390              }
61391            }
61392            return true;
61393          }
61394          function isEqual(value, other) {
61395            return baseIsEqual(value, other);
61396          }
61397          function isEqualWith(value, other, customizer) {
61398            customizer = typeof customizer == "function" ? customizer : undefined$1;
61399            var result2 = customizer ? customizer(value, other) : undefined$1;
61400            return result2 === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result2;
61401          }
61402          function isError(value) {
61403            if (!isObjectLike(value)) {
61404              return false;
61405            }
61406            var tag = baseGetTag(value);
61407            return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject2(value);
61408          }
61409          function isFinite2(value) {
61410            return typeof value == "number" && nativeIsFinite(value);
61411          }
61412          function isFunction2(value) {
61413            if (!isObject2(value)) {
61414              return false;
61415            }
61416            var tag = baseGetTag(value);
61417            return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
61418          }
61419          function isInteger(value) {
61420            return typeof value == "number" && value == toInteger(value);
61421          }
61422          function isLength(value) {
61423            return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
61424          }
61425          function isObject2(value) {
61426            var type2 = typeof value;
61427            return value != null && (type2 == "object" || type2 == "function");
61428          }
61429          function isObjectLike(value) {
61430            return value != null && typeof value == "object";
61431          }
61432          var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
61433          function isMatch(object, source) {
61434            return object === source || baseIsMatch(object, source, getMatchData(source));
61435          }
61436          function isMatchWith(object, source, customizer) {
61437            customizer = typeof customizer == "function" ? customizer : undefined$1;
61438            return baseIsMatch(object, source, getMatchData(source), customizer);
61439          }
61440          function isNaN2(value) {
61441            return isNumber2(value) && value != +value;
61442          }
61443          function isNative(value) {
61444            if (isMaskable(value)) {
61445              throw new Error2(CORE_ERROR_TEXT);
61446            }
61447            return baseIsNative(value);
61448          }
61449          function isNull(value) {
61450            return value === null;
61451          }
61452          function isNil(value) {
61453            return value == null;
61454          }
61455          function isNumber2(value) {
61456            return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
61457          }
61458          function isPlainObject2(value) {
61459            if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
61460              return false;
61461            }
61462            var proto = getPrototype(value);
61463            if (proto === null) {
61464              return true;
61465            }
61466            var Ctor = hasOwnProperty2.call(proto, "constructor") && proto.constructor;
61467            return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
61468          }
61469          var isRegExp2 = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
61470          function isSafeInteger(value) {
61471            return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
61472          }
61473          var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
61474          function isString2(value) {
61475            return typeof value == "string" || !isArray2(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
61476          }
61477          function isSymbol(value) {
61478            return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
61479          }
61480          var isTypedArray2 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
61481          function isUndefined2(value) {
61482            return value === undefined$1;
61483          }
61484          function isWeakMap(value) {
61485            return isObjectLike(value) && getTag(value) == weakMapTag;
61486          }
61487          function isWeakSet(value) {
61488            return isObjectLike(value) && baseGetTag(value) == weakSetTag;
61489          }
61490          var lt = createRelationalOperation(baseLt);
61491          var lte = createRelationalOperation(function(value, other) {
61492            return value <= other;
61493          });
61494          function toArray2(value) {
61495            if (!value) {
61496              return [];
61497            }
61498            if (isArrayLike(value)) {
61499              return isString2(value) ? stringToArray(value) : copyArray(value);
61500            }
61501            if (symIterator && value[symIterator]) {
61502              return iteratorToArray(value[symIterator]());
61503            }
61504            var tag = getTag(value), func = tag == mapTag ? mapToArray : tag == setTag ? setToArray : values;
61505            return func(value);
61506          }
61507          function toFinite(value) {
61508            if (!value) {
61509              return value === 0 ? value : 0;
61510            }
61511            value = toNumber(value);
61512            if (value === INFINITY || value === -INFINITY) {
61513              var sign2 = value < 0 ? -1 : 1;
61514              return sign2 * MAX_INTEGER;
61515            }
61516            return value === value ? value : 0;
61517          }
61518          function toInteger(value) {
61519            var result2 = toFinite(value), remainder = result2 % 1;
61520            return result2 === result2 ? remainder ? result2 - remainder : result2 : 0;
61521          }
61522          function toLength(value) {
61523            return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
61524          }
61525          function toNumber(value) {
61526            if (typeof value == "number") {
61527              return value;
61528            }
61529            if (isSymbol(value)) {
61530              return NAN;
61531            }
61532            if (isObject2(value)) {
61533              var other = typeof value.valueOf == "function" ? value.valueOf() : value;
61534              value = isObject2(other) ? other + "" : other;
61535            }
61536            if (typeof value != "string") {
61537              return value === 0 ? value : +value;
61538            }
61539            value = baseTrim(value);
61540            var isBinary = reIsBinary.test(value);
61541            return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
61542          }
61543          function toPlainObject(value) {
61544            return copyObject(value, keysIn(value));
61545          }
61546          function toSafeInteger(value) {
61547            return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
61548          }
61549          function toString2(value) {
61550            return value == null ? "" : baseToString(value);
61551          }
61552          var assign = createAssigner(function(object, source) {
61553            if (isPrototype(source) || isArrayLike(source)) {
61554              copyObject(source, keys(source), object);
61555              return;
61556            }
61557            for (var key2 in source) {
61558              if (hasOwnProperty2.call(source, key2)) {
61559                assignValue(object, key2, source[key2]);
61560              }
61561            }
61562          });
61563          var assignIn = createAssigner(function(object, source) {
61564            copyObject(source, keysIn(source), object);
61565          });
61566          var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
61567            copyObject(source, keysIn(source), object, customizer);
61568          });
61569          var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
61570            copyObject(source, keys(source), object, customizer);
61571          });
61572          var at = flatRest(baseAt);
61573          function create2(prototype2, properties) {
61574            var result2 = baseCreate(prototype2);
61575            return properties == null ? result2 : baseAssign(result2, properties);
61576          }
61577          var defaults2 = baseRest(function(object, sources) {
61578            object = Object2(object);
61579            var index = -1;
61580            var length = sources.length;
61581            var guard = length > 2 ? sources[2] : undefined$1;
61582            if (guard && isIterateeCall(sources[0], sources[1], guard)) {
61583              length = 1;
61584            }
61585            while (++index < length) {
61586              var source = sources[index];
61587              var props = keysIn(source);
61588              var propsIndex = -1;
61589              var propsLength = props.length;
61590              while (++propsIndex < propsLength) {
61591                var key2 = props[propsIndex];
61592                var value = object[key2];
61593                if (value === undefined$1 || eq(value, objectProto[key2]) && !hasOwnProperty2.call(object, key2)) {
61594                  object[key2] = source[key2];
61595                }
61596              }
61597            }
61598            return object;
61599          });
61600          var defaultsDeep = baseRest(function(args) {
61601            args.push(undefined$1, customDefaultsMerge);
61602            return apply(mergeWith, undefined$1, args);
61603          });
61604          function findKey2(object, predicate) {
61605            return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
61606          }
61607          function findLastKey(object, predicate) {
61608            return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
61609          }
61610          function forIn(object, iteratee2) {
61611            return object == null ? object : baseFor(object, getIteratee(iteratee2, 3), keysIn);
61612          }
61613          function forInRight(object, iteratee2) {
61614            return object == null ? object : baseForRight(object, getIteratee(iteratee2, 3), keysIn);
61615          }
61616          function forOwn(object, iteratee2) {
61617            return object && baseForOwn(object, getIteratee(iteratee2, 3));
61618          }
61619          function forOwnRight(object, iteratee2) {
61620            return object && baseForOwnRight(object, getIteratee(iteratee2, 3));
61621          }
61622          function functions(object) {
61623            return object == null ? [] : baseFunctions(object, keys(object));
61624          }
61625          function functionsIn(object) {
61626            return object == null ? [] : baseFunctions(object, keysIn(object));
61627          }
61628          function get2(object, path, defaultValue) {
61629            var result2 = object == null ? undefined$1 : baseGet(object, path);
61630            return result2 === undefined$1 ? defaultValue : result2;
61631          }
61632          function has(object, path) {
61633            return object != null && hasPath(object, path, baseHas);
61634          }
61635          function hasIn(object, path) {
61636            return object != null && hasPath(object, path, baseHasIn);
61637          }
61638          var invert = createInverter(function(result2, value, key2) {
61639            if (value != null && typeof value.toString != "function") {
61640              value = nativeObjectToString.call(value);
61641            }
61642            result2[value] = key2;
61643          }, constant(identity));
61644          var invertBy = createInverter(function(result2, value, key2) {
61645            if (value != null && typeof value.toString != "function") {
61646              value = nativeObjectToString.call(value);
61647            }
61648            if (hasOwnProperty2.call(result2, value)) {
61649              result2[value].push(key2);
61650            } else {
61651              result2[value] = [key2];
61652            }
61653          }, getIteratee);
61654          var invoke = baseRest(baseInvoke);
61655          function keys(object) {
61656            return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
61657          }
61658          function keysIn(object) {
61659            return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
61660          }
61661          function mapKeys(object, iteratee2) {
61662            var result2 = {};
61663            iteratee2 = getIteratee(iteratee2, 3);
61664            baseForOwn(object, function(value, key2, object2) {
61665              baseAssignValue(result2, iteratee2(value, key2, object2), value);
61666            });
61667            return result2;
61668          }
61669          function mapValues(object, iteratee2) {
61670            var result2 = {};
61671            iteratee2 = getIteratee(iteratee2, 3);
61672            baseForOwn(object, function(value, key2, object2) {
61673              baseAssignValue(result2, key2, iteratee2(value, key2, object2));
61674            });
61675            return result2;
61676          }
61677          var merge2 = createAssigner(function(object, source, srcIndex) {
61678            baseMerge(object, source, srcIndex);
61679          });
61680          var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
61681            baseMerge(object, source, srcIndex, customizer);
61682          });
61683          var omit = flatRest(function(object, paths) {
61684            var result2 = {};
61685            if (object == null) {
61686              return result2;
61687            }
61688            var isDeep = false;
61689            paths = arrayMap(paths, function(path) {
61690              path = castPath(path, object);
61691              isDeep || (isDeep = path.length > 1);
61692              return path;
61693            });
61694            copyObject(object, getAllKeysIn(object), result2);
61695            if (isDeep) {
61696              result2 = baseClone(result2, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
61697            }
61698            var length = paths.length;
61699            while (length--) {
61700              baseUnset(result2, paths[length]);
61701            }
61702            return result2;
61703          });
61704          function omitBy(object, predicate) {
61705            return pickBy(object, negate(getIteratee(predicate)));
61706          }
61707          var pick = flatRest(function(object, paths) {
61708            return object == null ? {} : basePick(object, paths);
61709          });
61710          function pickBy(object, predicate) {
61711            if (object == null) {
61712              return {};
61713            }
61714            var props = arrayMap(getAllKeysIn(object), function(prop) {
61715              return [prop];
61716            });
61717            predicate = getIteratee(predicate);
61718            return basePickBy(object, props, function(value, path) {
61719              return predicate(value, path[0]);
61720            });
61721          }
61722          function result(object, path, defaultValue) {
61723            path = castPath(path, object);
61724            var index = -1, length = path.length;
61725            if (!length) {
61726              length = 1;
61727              object = undefined$1;
61728            }
61729            while (++index < length) {
61730              var value = object == null ? undefined$1 : object[toKey(path[index])];
61731              if (value === undefined$1) {
61732                index = length;
61733                value = defaultValue;
61734              }
61735              object = isFunction2(value) ? value.call(object) : value;
61736            }
61737            return object;
61738          }
61739          function set(object, path, value) {
61740            return object == null ? object : baseSet(object, path, value);
61741          }
61742          function setWith(object, path, value, customizer) {
61743            customizer = typeof customizer == "function" ? customizer : undefined$1;
61744            return object == null ? object : baseSet(object, path, value, customizer);
61745          }
61746          var toPairs = createToPairs(keys);
61747          var toPairsIn = createToPairs(keysIn);
61748          function transform(object, iteratee2, accumulator) {
61749            var isArr = isArray2(object), isArrLike = isArr || isBuffer2(object) || isTypedArray2(object);
61750            iteratee2 = getIteratee(iteratee2, 4);
61751            if (accumulator == null) {
61752              var Ctor = object && object.constructor;
61753              if (isArrLike) {
61754                accumulator = isArr ? new Ctor() : [];
61755              } else if (isObject2(object)) {
61756                accumulator = isFunction2(Ctor) ? baseCreate(getPrototype(object)) : {};
61757              } else {
61758                accumulator = {};
61759              }
61760            }
61761            (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
61762              return iteratee2(accumulator, value, index, object2);
61763            });
61764            return accumulator;
61765          }
61766          function unset(object, path) {
61767            return object == null ? true : baseUnset(object, path);
61768          }
61769          function update(object, path, updater) {
61770            return object == null ? object : baseUpdate(object, path, castFunction(updater));
61771          }
61772          function updateWith(object, path, updater, customizer) {
61773            customizer = typeof customizer == "function" ? customizer : undefined$1;
61774            return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
61775          }
61776          function values(object) {
61777            return object == null ? [] : baseValues(object, keys(object));
61778          }
61779          function valuesIn(object) {
61780            return object == null ? [] : baseValues(object, keysIn(object));
61781          }
61782          function clamp(number, lower, upper) {
61783            if (upper === undefined$1) {
61784              upper = lower;
61785              lower = undefined$1;
61786            }
61787            if (upper !== undefined$1) {
61788              upper = toNumber(upper);
61789              upper = upper === upper ? upper : 0;
61790            }
61791            if (lower !== undefined$1) {
61792              lower = toNumber(lower);
61793              lower = lower === lower ? lower : 0;
61794            }
61795            return baseClamp(toNumber(number), lower, upper);
61796          }
61797          function inRange(number, start, end) {
61798            start = toFinite(start);
61799            if (end === undefined$1) {
61800              end = start;
61801              start = 0;
61802            } else {
61803              end = toFinite(end);
61804            }
61805            number = toNumber(number);
61806            return baseInRange(number, start, end);
61807          }
61808          function random(lower, upper, floating) {
61809            if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
61810              upper = floating = undefined$1;
61811            }
61812            if (floating === undefined$1) {
61813              if (typeof upper == "boolean") {
61814                floating = upper;
61815                upper = undefined$1;
61816              } else if (typeof lower == "boolean") {
61817                floating = lower;
61818                lower = undefined$1;
61819              }
61820            }
61821            if (lower === undefined$1 && upper === undefined$1) {
61822              lower = 0;
61823              upper = 1;
61824            } else {
61825              lower = toFinite(lower);
61826              if (upper === undefined$1) {
61827                upper = lower;
61828                lower = 0;
61829              } else {
61830                upper = toFinite(upper);
61831              }
61832            }
61833            if (lower > upper) {
61834              var temp = lower;
61835              lower = upper;
61836              upper = temp;
61837            }
61838            if (floating || lower % 1 || upper % 1) {
61839              var rand = nativeRandom();
61840              return nativeMin(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
61841            }
61842            return baseRandom(lower, upper);
61843          }
61844          var camelCase = createCompounder(function(result2, word, index) {
61845            word = word.toLowerCase();
61846            return result2 + (index ? capitalize(word) : word);
61847          });
61848          function capitalize(string) {
61849            return upperFirst(toString2(string).toLowerCase());
61850          }
61851          function deburr(string) {
61852            string = toString2(string);
61853            return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
61854          }
61855          function endsWith2(string, target, position) {
61856            string = toString2(string);
61857            target = baseToString(target);
61858            var length = string.length;
61859            position = position === undefined$1 ? length : baseClamp(toInteger(position), 0, length);
61860            var end = position;
61861            position -= target.length;
61862            return position >= 0 && string.slice(position, end) == target;
61863          }
61864          function escape2(string) {
61865            string = toString2(string);
61866            return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
61867          }
61868          function escapeRegExp(string) {
61869            string = toString2(string);
61870            return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
61871          }
61872          var kebabCase = createCompounder(function(result2, word, index) {
61873            return result2 + (index ? "-" : "") + word.toLowerCase();
61874          });
61875          var lowerCase = createCompounder(function(result2, word, index) {
61876            return result2 + (index ? " " : "") + word.toLowerCase();
61877          });
61878          var lowerFirst = createCaseFirst("toLowerCase");
61879          function pad(string, length, chars) {
61880            string = toString2(string);
61881            length = toInteger(length);
61882            var strLength = length ? stringSize(string) : 0;
61883            if (!length || strLength >= length) {
61884              return string;
61885            }
61886            var mid = (length - strLength) / 2;
61887            return createPadding(nativeFloor(mid), chars) + string + createPadding(nativeCeil(mid), chars);
61888          }
61889          function padEnd(string, length, chars) {
61890            string = toString2(string);
61891            length = toInteger(length);
61892            var strLength = length ? stringSize(string) : 0;
61893            return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
61894          }
61895          function padStart(string, length, chars) {
61896            string = toString2(string);
61897            length = toInteger(length);
61898            var strLength = length ? stringSize(string) : 0;
61899            return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
61900          }
61901          function parseInt2(string, radix, guard) {
61902            if (guard || radix == null) {
61903              radix = 0;
61904            } else if (radix) {
61905              radix = +radix;
61906            }
61907            return nativeParseInt(toString2(string).replace(reTrimStart, ""), radix || 0);
61908          }
61909          function repeat(string, n, guard) {
61910            if (guard ? isIterateeCall(string, n, guard) : n === undefined$1) {
61911              n = 1;
61912            } else {
61913              n = toInteger(n);
61914            }
61915            return baseRepeat(toString2(string), n);
61916          }
61917          function replace() {
61918            var args = arguments, string = toString2(args[0]);
61919            return args.length < 3 ? string : string.replace(args[1], args[2]);
61920          }
61921          var snakeCase = createCompounder(function(result2, word, index) {
61922            return result2 + (index ? "_" : "") + word.toLowerCase();
61923          });
61924          function split(string, separator, limit) {
61925            if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
61926              separator = limit = undefined$1;
61927            }
61928            limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;
61929            if (!limit) {
61930              return [];
61931            }
61932            string = toString2(string);
61933            if (string && (typeof separator == "string" || separator != null && !isRegExp2(separator))) {
61934              separator = baseToString(separator);
61935              if (!separator && hasUnicode(string)) {
61936                return castSlice(stringToArray(string), 0, limit);
61937              }
61938            }
61939            return string.split(separator, limit);
61940          }
61941          var startCase = createCompounder(function(result2, word, index) {
61942            return result2 + (index ? " " : "") + upperFirst(word);
61943          });
61944          function startsWith(string, target, position) {

vendor: 4,425 bytes, lines 61945-62021

61945            string = toString2(string);
61946            position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
61947            target = baseToString(target);
61948            return string.slice(position, position + target.length) == target;
61949          }
61950          function template(string, options, guard) {
61951            var settings = lodash2.templateSettings;
61952            if (guard && isIterateeCall(string, options, guard)) {
61953              options = undefined$1;
61954            }
61955            string = toString2(string);
61956            options = assignWith({}, options, settings, customDefaultsAssignIn);
61957            var imports = assignWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
61958            arrayEach(importsKeys, function(key2) {
61959              if (reForbiddenIdentifierChars.test(key2)) {
61960                throw new Error2(INVALID_TEMPL_IMPORTS_ERROR_TEXT);
61961              }
61962            });
61963            var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
61964            var reDelimiters = RegExp2(
61965              (options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$",
61966              "g"
61967            );
61968            var sourceURL = "//# sourceURL=" + (hasOwnProperty2.call(options, "sourceURL") ? (options.sourceURL + "").replace(/\s/g, " ") : "lodash.templateSources[" + ++templateCounter + "]") + "\n";
61969            string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
61970              interpolateValue || (interpolateValue = esTemplateValue);
61971              source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
61972              if (escapeValue) {
61973                isEscaping = true;
61974                source += "' +\n__e(" + escapeValue + ") +\n'";
61975              }
61976              if (evaluateValue) {
61977                isEvaluating = true;
61978                source += "';\n" + evaluateValue + ";\n__p += '";
61979              }
61980              if (interpolateValue) {
61981                source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
61982              }
61983              index = offset + match.length;
61984              return match;
61985            });
61986            source += "';\n";
61987            var variable = hasOwnProperty2.call(options, "variable") && options.variable;
61988            if (!variable) {
61989              source = "with (obj) {\n" + source + "\n}\n";
61990            } else if (reForbiddenIdentifierChars.test(variable)) {
61991              throw new Error2(INVALID_TEMPL_VAR_ERROR_TEXT);
61992            }
61993            source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
61994            source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
61995            var result2 = attempt(function() {
61996              return Function2(importsKeys, sourceURL + "return " + source).apply(undefined$1, importsValues);
61997            });
61998            result2.source = source;
61999            if (isError(result2)) {
62000              throw result2;
62001            }
62002            return result2;
62003          }
62004          function toLower(value) {
62005            return toString2(value).toLowerCase();
62006          }
62007          function toUpper(value) {
62008            return toString2(value).toUpperCase();
62009          }
62010          function trim2(string, chars, guard) {
62011            string = toString2(string);
62012            if (string && (guard || chars === undefined$1)) {
62013              return baseTrim(string);
62014            }
62015            if (!string || !(chars = baseToString(chars))) {
62016              return string;
62017            }
62018            var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
62019            return castSlice(strSymbols, start, end).join("");
62020          }
62021          function trimEnd(string, chars, guard) {

vendor: 13,079 bytes, lines 62022-62345

62022            string = toString2(string);
62023            if (string && (guard || chars === undefined$1)) {
62024              return string.slice(0, trimmedEndIndex(string) + 1);
62025            }
62026            if (!string || !(chars = baseToString(chars))) {
62027              return string;
62028            }
62029            var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
62030            return castSlice(strSymbols, 0, end).join("");
62031          }
62032          function trimStart(string, chars, guard) {
62033            string = toString2(string);
62034            if (string && (guard || chars === undefined$1)) {
62035              return string.replace(reTrimStart, "");
62036            }
62037            if (!string || !(chars = baseToString(chars))) {
62038              return string;
62039            }
62040            var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
62041            return castSlice(strSymbols, start).join("");
62042          }
62043          function truncate(string, options) {
62044            var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
62045            if (isObject2(options)) {
62046              var separator = "separator" in options ? options.separator : separator;
62047              length = "length" in options ? toInteger(options.length) : length;
62048              omission = "omission" in options ? baseToString(options.omission) : omission;
62049            }
62050            string = toString2(string);
62051            var strLength = string.length;
62052            if (hasUnicode(string)) {
62053              var strSymbols = stringToArray(string);
62054              strLength = strSymbols.length;
62055            }
62056            if (length >= strLength) {
62057              return string;
62058            }
62059            var end = length - stringSize(omission);
62060            if (end < 1) {
62061              return omission;
62062            }
62063            var result2 = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
62064            if (separator === undefined$1) {
62065              return result2 + omission;
62066            }
62067            if (strSymbols) {
62068              end += result2.length - end;
62069            }
62070            if (isRegExp2(separator)) {
62071              if (string.slice(end).search(separator)) {
62072                var match, substring = result2;
62073                if (!separator.global) {
62074                  separator = RegExp2(separator.source, toString2(reFlags.exec(separator)) + "g");
62075                }
62076                separator.lastIndex = 0;
62077                while (match = separator.exec(substring)) {
62078                  var newEnd = match.index;
62079                }
62080                result2 = result2.slice(0, newEnd === undefined$1 ? end : newEnd);
62081              }
62082            } else if (string.indexOf(baseToString(separator), end) != end) {
62083              var index = result2.lastIndexOf(separator);
62084              if (index > -1) {
62085                result2 = result2.slice(0, index);
62086              }
62087            }
62088            return result2 + omission;
62089          }
62090          function unescape2(string) {
62091            string = toString2(string);
62092            return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
62093          }
62094          var upperCase = createCompounder(function(result2, word, index) {
62095            return result2 + (index ? " " : "") + word.toUpperCase();
62096          });
62097          var upperFirst = createCaseFirst("toUpperCase");
62098          function words(string, pattern, guard) {
62099            string = toString2(string);
62100            pattern = guard ? undefined$1 : pattern;
62101            if (pattern === undefined$1) {
62102              return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
62103            }
62104            return string.match(pattern) || [];
62105          }
62106          var attempt = baseRest(function(func, args) {
62107            try {
62108              return apply(func, undefined$1, args);
62109            } catch (e) {
62110              return isError(e) ? e : new Error2(e);
62111            }
62112          });
62113          var bindAll = flatRest(function(object, methodNames) {
62114            arrayEach(methodNames, function(key2) {
62115              key2 = toKey(key2);
62116              baseAssignValue(object, key2, bind2(object[key2], object));
62117            });
62118            return object;
62119          });
62120          function cond(pairs) {
62121            var length = pairs == null ? 0 : pairs.length, toIteratee = getIteratee();
62122            pairs = !length ? [] : arrayMap(pairs, function(pair) {
62123              if (typeof pair[1] != "function") {
62124                throw new TypeError2(FUNC_ERROR_TEXT);
62125              }
62126              return [toIteratee(pair[0]), pair[1]];
62127            });
62128            return baseRest(function(args) {
62129              var index = -1;
62130              while (++index < length) {
62131                var pair = pairs[index];
62132                if (apply(pair[0], this, args)) {
62133                  return apply(pair[1], this, args);
62134                }
62135              }
62136            });
62137          }
62138          function conforms(source) {
62139            return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
62140          }
62141          function constant(value) {
62142            return function() {
62143              return value;
62144            };
62145          }
62146          function defaultTo(value, defaultValue) {
62147            return value == null || value !== value ? defaultValue : value;
62148          }
62149          var flow = createFlow();
62150          var flowRight = createFlow(true);
62151          function identity(value) {
62152            return value;
62153          }
62154          function iteratee(func) {
62155            return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG));
62156          }
62157          function matches(source) {
62158            return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
62159          }
62160          function matchesProperty(path, srcValue) {
62161            return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
62162          }
62163          var method = baseRest(function(path, args) {
62164            return function(object) {
62165              return baseInvoke(object, path, args);
62166            };
62167          });
62168          var methodOf = baseRest(function(object, args) {
62169            return function(path) {
62170              return baseInvoke(object, path, args);
62171            };
62172          });
62173          function mixin(object, source, options) {
62174            var props = keys(source), methodNames = baseFunctions(source, props);
62175            if (options == null && !(isObject2(source) && (methodNames.length || !props.length))) {
62176              options = source;
62177              source = object;
62178              object = this;
62179              methodNames = baseFunctions(source, keys(source));
62180            }
62181            var chain2 = !(isObject2(options) && "chain" in options) || !!options.chain, isFunc = isFunction2(object);
62182            arrayEach(methodNames, function(methodName) {
62183              var func = source[methodName];
62184              object[methodName] = func;
62185              if (isFunc) {
62186                object.prototype[methodName] = function() {
62187                  var chainAll = this.__chain__;
62188                  if (chain2 || chainAll) {
62189                    var result2 = object(this.__wrapped__), actions = result2.__actions__ = copyArray(this.__actions__);
62190                    actions.push({ "func": func, "args": arguments, "thisArg": object });
62191                    result2.__chain__ = chainAll;
62192                    return result2;
62193                  }
62194                  return func.apply(object, arrayPush([this.value()], arguments));
62195                };
62196              }
62197            });
62198            return object;
62199          }
62200          function noConflict() {
62201            if (root._ === this) {
62202              root._ = oldDash;
62203            }
62204            return this;
62205          }
62206          function noop2() {
62207          }
62208          function nthArg(n) {
62209            n = toInteger(n);
62210            return baseRest(function(args) {
62211              return baseNth(args, n);
62212            });
62213          }
62214          var over = createOver(arrayMap);
62215          var overEvery = createOver(arrayEvery);
62216          var overSome = createOver(arraySome);
62217          function property(path) {
62218            return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
62219          }
62220          function propertyOf(object) {
62221            return function(path) {
62222              return object == null ? undefined$1 : baseGet(object, path);
62223            };
62224          }
62225          var range2 = createRange();
62226          var rangeRight = createRange(true);
62227          function stubArray() {
62228            return [];
62229          }
62230          function stubFalse() {
62231            return false;
62232          }
62233          function stubObject() {
62234            return {};
62235          }
62236          function stubString() {
62237            return "";
62238          }
62239          function stubTrue() {
62240            return true;
62241          }
62242          function times(n, iteratee2) {
62243            n = toInteger(n);
62244            if (n < 1 || n > MAX_SAFE_INTEGER) {
62245              return [];
62246            }
62247            var index = MAX_ARRAY_LENGTH, length = nativeMin(n, MAX_ARRAY_LENGTH);
62248            iteratee2 = getIteratee(iteratee2);
62249            n -= MAX_ARRAY_LENGTH;
62250            var result2 = baseTimes(length, iteratee2);
62251            while (++index < n) {
62252              iteratee2(index);
62253            }
62254            return result2;
62255          }
62256          function toPath(value) {
62257            if (isArray2(value)) {
62258              return arrayMap(value, toKey);
62259            }
62260            return isSymbol(value) ? [value] : copyArray(stringToPath(toString2(value)));
62261          }
62262          function uniqueId2(prefix) {
62263            var id = ++idCounter2;
62264            return toString2(prefix) + id;
62265          }
62266          var add = createMathOperation(function(augend, addend) {
62267            return augend + addend;
62268          }, 0);
62269          var ceil = createRound("ceil");
62270          var divide = createMathOperation(function(dividend, divisor) {
62271            return dividend / divisor;
62272          }, 1);
62273          var floor2 = createRound("floor");
62274          function max2(array) {
62275            return array && array.length ? baseExtremum(array, identity, baseGt) : undefined$1;
62276          }
62277          function maxBy(array, iteratee2) {
62278            return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseGt) : undefined$1;
62279          }
62280          function mean(array) {
62281            return baseMean(array, identity);
62282          }
62283          function meanBy(array, iteratee2) {
62284            return baseMean(array, getIteratee(iteratee2, 2));
62285          }
62286          function min2(array) {
62287            return array && array.length ? baseExtremum(array, identity, baseLt) : undefined$1;
62288          }
62289          function minBy(array, iteratee2) {
62290            return array && array.length ? baseExtremum(array, getIteratee(iteratee2, 2), baseLt) : undefined$1;
62291          }
62292          var multiply = createMathOperation(function(multiplier, multiplicand) {
62293            return multiplier * multiplicand;
62294          }, 1);
62295          var round2 = createRound("round");
62296          var subtract = createMathOperation(function(minuend, subtrahend) {
62297            return minuend - subtrahend;
62298          }, 0);
62299          function sum(array) {
62300            return array && array.length ? baseSum(array, identity) : 0;
62301          }
62302          function sumBy(array, iteratee2) {
62303            return array && array.length ? baseSum(array, getIteratee(iteratee2, 2)) : 0;
62304          }
62305          lodash2.after = after;
62306          lodash2.ary = ary;
62307          lodash2.assign = assign;
62308          lodash2.assignIn = assignIn;
62309          lodash2.assignInWith = assignInWith;
62310          lodash2.assignWith = assignWith;
62311          lodash2.at = at;
62312          lodash2.before = before;
62313          lodash2.bind = bind2;
62314          lodash2.bindAll = bindAll;
62315          lodash2.bindKey = bindKey;
62316          lodash2.castArray = castArray;
62317          lodash2.chain = chain;
62318          lodash2.chunk = chunk;
62319          lodash2.compact = compact;
62320          lodash2.concat = concat;
62321          lodash2.cond = cond;
62322          lodash2.conforms = conforms;
62323          lodash2.constant = constant;
62324          lodash2.countBy = countBy;
62325          lodash2.create = create2;
62326          lodash2.curry = curry;
62327          lodash2.curryRight = curryRight;
62328          lodash2.debounce = debounce;
62329          lodash2.defaults = defaults2;
62330          lodash2.defaultsDeep = defaultsDeep;
62331          lodash2.defer = defer;
62332          lodash2.delay = delay;
62333          lodash2.difference = difference;
62334          lodash2.differenceBy = differenceBy;
62335          lodash2.differenceWith = differenceWith;
62336          lodash2.drop = drop;
62337          lodash2.dropRight = dropRight;
62338          lodash2.dropRightWhile = dropRightWhile;
62339          lodash2.dropWhile = dropWhile;
62340          lodash2.fill = fill;
62341          lodash2.filter = filter;
62342          lodash2.flatMap = flatMap;
62343          lodash2.flatMapDeep = flatMapDeep;
62344          lodash2.flatMapDepth = flatMapDepth;
62345          lodash2.flatten = flatten;

62346          lodash2.flattenDeep = flattenDeep;
62347          lodash2.flattenDepth = flattenDepth;
62348          lodash2.flip = flip;
62349          lodash2.flow = flow;
62350          lodash2.flowRight = flowRight;
62351          lodash2.fromPairs = fromPairs;
62352          lodash2.functions = functions;
62353          lodash2.functionsIn = functionsIn;
62354          lodash2.groupBy = groupBy;
62355          lodash2.initial = initial;
62356          lodash2.intersection = intersection;
62357          lodash2.intersectionBy = intersectionBy;
62358          lodash2.intersectionWith = intersectionWith;
62359          lodash2.invert = invert;
62360          lodash2.invertBy = invertBy;
62361          lodash2.invokeMap = invokeMap;
62362          lodash2.iteratee = iteratee;
62363          lodash2.keyBy = keyBy;
62364          lodash2.keys = keys;
62365          lodash2.keysIn = keysIn;
62366          lodash2.map = map;
62367          lodash2.mapKeys = mapKeys;
62368          lodash2.mapValues = mapValues;
62369          lodash2.matches = matches;
62370          lodash2.matchesProperty = matchesProperty;
62371          lodash2.memoize = memoize;
62372          lodash2.merge = merge2;
62373          lodash2.mergeWith = mergeWith;
62374          lodash2.method = method;
62375          lodash2.methodOf = methodOf;
62376          lodash2.mixin = mixin;
62377          lodash2.negate = negate;
62378          lodash2.nthArg = nthArg;
62379          lodash2.omit = omit;
62380          lodash2.omitBy = omitBy;
62381          lodash2.once = once;
62382          lodash2.orderBy = orderBy;
62383          lodash2.over = over;
62384          lodash2.overArgs = overArgs;
62385          lodash2.overEvery = overEvery;
62386          lodash2.overSome = overSome;
62387          lodash2.partial = partial;
62388          lodash2.partialRight = partialRight;
62389          lodash2.partition = partition;
62390          lodash2.pick = pick;
62391          lodash2.pickBy = pickBy;
62392          lodash2.property = property;
62393          lodash2.propertyOf = propertyOf;
62394          lodash2.pull = pull;
62395          lodash2.pullAll = pullAll;
62396          lodash2.pullAllBy = pullAllBy;
62397          lodash2.pullAllWith = pullAllWith;
62398          lodash2.pullAt = pullAt;
62399          lodash2.range = range2;
62400          lodash2.rangeRight = rangeRight;
62401          lodash2.rearg = rearg;
62402          lodash2.reject = reject;
62403          lodash2.remove = remove;
62404          lodash2.rest = rest;
62405          lodash2.reverse = reverse;
62406          lodash2.sampleSize = sampleSize;
62407          lodash2.set = set;
62408          lodash2.setWith = setWith;
62409          lodash2.shuffle = shuffle;
62410          lodash2.slice = slice;
62411          lodash2.sortBy = sortBy;
62412          lodash2.sortedUniq = sortedUniq;
62413          lodash2.sortedUniqBy = sortedUniqBy;
62414          lodash2.split = split;
62415          lodash2.spread = spread2;
62416          lodash2.tail = tail;
62417          lodash2.take = take;
62418          lodash2.takeRight = takeRight;
62419          lodash2.takeRightWhile = takeRightWhile;
62420          lodash2.takeWhile = takeWhile;
62421          lodash2.tap = tap;
62422          lodash2.throttle = throttle2;
62423          lodash2.thru = thru;
62424          lodash2.toArray = toArray2;
62425          lodash2.toPairs = toPairs;
62426          lodash2.toPairsIn = toPairsIn;
62427          lodash2.toPath = toPath;
62428          lodash2.toPlainObject = toPlainObject;
62429          lodash2.transform = transform;
62430          lodash2.unary = unary;
62431          lodash2.union = union;
62432          lodash2.unionBy = unionBy;
62433          lodash2.unionWith = unionWith;
62434          lodash2.uniq = uniq;
62435          lodash2.uniqBy = uniqBy;
62436          lodash2.uniqWith = uniqWith;
62437          lodash2.unset = unset;
62438          lodash2.unzip = unzip;
62439          lodash2.unzipWith = unzipWith;
62440          lodash2.update = update;
62441          lodash2.updateWith = updateWith;
62442          lodash2.values = values;
62443          lodash2.valuesIn = valuesIn;
62444          lodash2.without = without;
62445          lodash2.words = words;
62446          lodash2.wrap = wrap;
62447          lodash2.xor = xor2;
62448          lodash2.xorBy = xorBy;
62449          lodash2.xorWith = xorWith;
62450          lodash2.zip = zip;
62451          lodash2.zipObject = zipObject;
62452          lodash2.zipObjectDeep = zipObjectDeep;
62453          lodash2.zipWith = zipWith;
62454          lodash2.entries = toPairs;
62455          lodash2.entriesIn = toPairsIn;
62456          lodash2.extend = assignIn;
62457          lodash2.extendWith = assignInWith;
62458          mixin(lodash2, lodash2);
62459          lodash2.add = add;
62460          lodash2.attempt = attempt;
62461          lodash2.camelCase = camelCase;
62462          lodash2.capitalize = capitalize;
62463          lodash2.ceil = ceil;
62464          lodash2.clamp = clamp;
62465          lodash2.clone = clone;
62466          lodash2.cloneDeep = cloneDeep;
62467          lodash2.cloneDeepWith = cloneDeepWith;
62468          lodash2.cloneWith = cloneWith;
62469          lodash2.conformsTo = conformsTo;
62470          lodash2.deburr = deburr;
62471          lodash2.defaultTo = defaultTo;
62472          lodash2.divide = divide;
62473          lodash2.endsWith = endsWith2;
62474          lodash2.eq = eq;
62475          lodash2.escape = escape2;
62476          lodash2.escapeRegExp = escapeRegExp;
62477          lodash2.every = every;
62478          lodash2.find = find;
62479          lodash2.findIndex = findIndex;
62480          lodash2.findKey = findKey2;
62481          lodash2.findLast = findLast;
62482          lodash2.findLastIndex = findLastIndex;
62483          lodash2.findLastKey = findLastKey;
62484          lodash2.floor = floor2;
62485          lodash2.forEach = forEach2;
62486          lodash2.forEachRight = forEachRight;
62487          lodash2.forIn = forIn;
62488          lodash2.forInRight = forInRight;
62489          lodash2.forOwn = forOwn;
62490          lodash2.forOwnRight = forOwnRight;
62491          lodash2.get = get2;
62492          lodash2.gt = gt;
62493          lodash2.gte = gte;
62494          lodash2.has = has;
62495          lodash2.hasIn = hasIn;
62496          lodash2.head = head;
62497          lodash2.identity = identity;
62498          lodash2.includes = includes;
62499          lodash2.indexOf = indexOf2;
62500          lodash2.inRange = inRange;
62501          lodash2.invoke = invoke;
62502          lodash2.isArguments = isArguments2;
62503          lodash2.isArray = isArray2;
62504          lodash2.isArrayBuffer = isArrayBuffer2;
62505          lodash2.isArrayLike = isArrayLike;
62506          lodash2.isArrayLikeObject = isArrayLikeObject;
62507          lodash2.isBoolean = isBoolean2;
62508          lodash2.isBuffer = isBuffer2;
62509          lodash2.isDate = isDate2;
62510          lodash2.isElement = isElement;
62511          lodash2.isEmpty = isEmpty;
62512          lodash2.isEqual = isEqual;
62513          lodash2.isEqualWith = isEqualWith;
62514          lodash2.isError = isError;
62515          lodash2.isFinite = isFinite2;
62516          lodash2.isFunction = isFunction2;
62517          lodash2.isInteger = isInteger;
62518          lodash2.isLength = isLength;
62519          lodash2.isMap = isMap;
62520          lodash2.isMatch = isMatch;
62521          lodash2.isMatchWith = isMatchWith;
62522          lodash2.isNaN = isNaN2;
62523          lodash2.isNative = isNative;
62524          lodash2.isNil = isNil;
62525          lodash2.isNull = isNull;
62526          lodash2.isNumber = isNumber2;
62527          lodash2.isObject = isObject2;
62528          lodash2.isObjectLike = isObjectLike;
62529          lodash2.isPlainObject = isPlainObject2;
62530          lodash2.isRegExp = isRegExp2;
62531          lodash2.isSafeInteger = isSafeInteger;
62532          lodash2.isSet = isSet;
62533          lodash2.isString = isString2;
62534          lodash2.isSymbol = isSymbol;
62535          lodash2.isTypedArray = isTypedArray2;
62536          lodash2.isUndefined = isUndefined2;
62537          lodash2.isWeakMap = isWeakMap;
62538          lodash2.isWeakSet = isWeakSet;
62539          lodash2.join = join;
62540          lodash2.kebabCase = kebabCase;
62541          lodash2.last = last;
62542          lodash2.lastIndexOf = lastIndexOf;
62543          lodash2.lowerCase = lowerCase;
62544          lodash2.lowerFirst = lowerFirst;
62545          lodash2.lt = lt;
62546          lodash2.lte = lte;
62547          lodash2.max = max2;
62548          lodash2.maxBy = maxBy;
62549          lodash2.mean = mean;
62550          lodash2.meanBy = meanBy;
62551          lodash2.min = min2;
62552          lodash2.minBy = minBy;
62553          lodash2.stubArray = stubArray;
62554          lodash2.stubFalse = stubFalse;
62555          lodash2.stubObject = stubObject;
62556          lodash2.stubString = stubString;
62557          lodash2.stubTrue = stubTrue;
62558          lodash2.multiply = multiply;
62559          lodash2.nth = nth;
62560          lodash2.noConflict = noConflict;
62561          lodash2.noop = noop2;
62562          lodash2.now = now;
62563          lodash2.pad = pad;
62564          lodash2.padEnd = padEnd;
62565          lodash2.padStart = padStart;
62566          lodash2.parseInt = parseInt2;
62567          lodash2.random = random;
62568          lodash2.reduce = reduce;
62569          lodash2.reduceRight = reduceRight;
62570          lodash2.repeat = repeat;
62571          lodash2.replace = replace;
62572          lodash2.result = result;
62573          lodash2.round = round2;
62574          lodash2.runInContext = runInContext2;
62575          lodash2.sample = sample;
62576          lodash2.size = size;
62577          lodash2.snakeCase = snakeCase;
62578          lodash2.some = some;
62579          lodash2.sortedIndex = sortedIndex;
62580          lodash2.sortedIndexBy = sortedIndexBy;
62581          lodash2.sortedIndexOf = sortedIndexOf;
62582          lodash2.sortedLastIndex = sortedLastIndex;
62583          lodash2.sortedLastIndexBy = sortedLastIndexBy;
62584          lodash2.sortedLastIndexOf = sortedLastIndexOf;
62585          lodash2.startCase = startCase;
62586          lodash2.startsWith = startsWith;
62587          lodash2.subtract = subtract;
62588          lodash2.sum = sum;
62589          lodash2.sumBy = sumBy;
62590          lodash2.template = template;
62591          lodash2.times = times;
62592          lodash2.toFinite = toFinite;
62593          lodash2.toInteger = toInteger;
62594          lodash2.toLength = toLength;
62595          lodash2.toLower = toLower;
62596          lodash2.toNumber = toNumber;
62597          lodash2.toSafeInteger = toSafeInteger;
62598          lodash2.toString = toString2;
62599          lodash2.toUpper = toUpper;
62600          lodash2.trim = trim2;
62601          lodash2.trimEnd = trimEnd;
62602          lodash2.trimStart = trimStart;
62603          lodash2.truncate = truncate;
62604          lodash2.unescape = unescape2;
62605          lodash2.uniqueId = uniqueId2;
62606          lodash2.upperCase = upperCase;
62607          lodash2.upperFirst = upperFirst;
62608          lodash2.each = forEach2;
62609          lodash2.eachRight = forEachRight;
62610          lodash2.first = head;
62611          mixin(lodash2, (function() {
62612            var source = {};
62613            baseForOwn(lodash2, function(func, methodName) {
62614              if (!hasOwnProperty2.call(lodash2.prototype, methodName)) {
62615                source[methodName] = func;
62616              }
62617            });
62618            return source;
62619          })(), { "chain": false });
62620          lodash2.VERSION = VERSION2;
62621          arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
62622            lodash2[methodName].placeholder = lodash2;
62623          });
62624          arrayEach(["drop", "take"], function(methodName, index) {
62625            LazyWrapper.prototype[methodName] = function(n) {

vendor: 6,447 bytes, lines 62626-62756

62626              n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0);
62627              var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
62628              if (result2.__filtered__) {
62629                result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
62630              } else {
62631                result2.__views__.push({
62632                  "size": nativeMin(n, MAX_ARRAY_LENGTH),
62633                  "type": methodName + (result2.__dir__ < 0 ? "Right" : "")
62634                });
62635              }
62636              return result2;
62637            };
62638            LazyWrapper.prototype[methodName + "Right"] = function(n) {
62639              return this.reverse()[methodName](n).reverse();
62640            };
62641          });
62642          arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
62643            var type2 = index + 1, isFilter = type2 == LAZY_FILTER_FLAG || type2 == LAZY_WHILE_FLAG;
62644            LazyWrapper.prototype[methodName] = function(iteratee2) {
62645              var result2 = this.clone();
62646              result2.__iteratees__.push({
62647                "iteratee": getIteratee(iteratee2, 3),
62648                "type": type2
62649              });
62650              result2.__filtered__ = result2.__filtered__ || isFilter;
62651              return result2;
62652            };
62653          });
62654          arrayEach(["head", "last"], function(methodName, index) {
62655            var takeName = "take" + (index ? "Right" : "");
62656            LazyWrapper.prototype[methodName] = function() {
62657              return this[takeName](1).value()[0];
62658            };
62659          });
62660          arrayEach(["initial", "tail"], function(methodName, index) {
62661            var dropName = "drop" + (index ? "" : "Right");
62662            LazyWrapper.prototype[methodName] = function() {
62663              return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
62664            };
62665          });
62666          LazyWrapper.prototype.compact = function() {
62667            return this.filter(identity);
62668          };
62669          LazyWrapper.prototype.find = function(predicate) {
62670            return this.filter(predicate).head();
62671          };
62672          LazyWrapper.prototype.findLast = function(predicate) {
62673            return this.reverse().find(predicate);
62674          };
62675          LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
62676            if (typeof path == "function") {
62677              return new LazyWrapper(this);
62678            }
62679            return this.map(function(value) {
62680              return baseInvoke(value, path, args);
62681            });
62682          });
62683          LazyWrapper.prototype.reject = function(predicate) {
62684            return this.filter(negate(getIteratee(predicate)));
62685          };
62686          LazyWrapper.prototype.slice = function(start, end) {
62687            start = toInteger(start);
62688            var result2 = this;
62689            if (result2.__filtered__ && (start > 0 || end < 0)) {
62690              return new LazyWrapper(result2);
62691            }
62692            if (start < 0) {
62693              result2 = result2.takeRight(-start);
62694            } else if (start) {
62695              result2 = result2.drop(start);
62696            }
62697            if (end !== undefined$1) {
62698              end = toInteger(end);
62699              result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
62700            }
62701            return result2;
62702          };
62703          LazyWrapper.prototype.takeRightWhile = function(predicate) {
62704            return this.reverse().takeWhile(predicate).reverse();
62705          };
62706          LazyWrapper.prototype.toArray = function() {
62707            return this.take(MAX_ARRAY_LENGTH);
62708          };
62709          baseForOwn(LazyWrapper.prototype, function(func, methodName) {
62710            var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash2[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
62711            if (!lodashFunc) {
62712              return;
62713            }
62714            lodash2.prototype[methodName] = function() {
62715              var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray2(value);
62716              var interceptor = function(value2) {
62717                var result3 = lodashFunc.apply(lodash2, arrayPush([value2], args));
62718                return isTaker && chainAll ? result3[0] : result3;
62719              };
62720              if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
62721                isLazy = useLazy = false;
62722              }
62723              var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
62724              if (!retUnwrapped && useLazy) {
62725                value = onlyLazy ? value : new LazyWrapper(this);
62726                var result2 = func.apply(value, args);
62727                result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined$1 });
62728                return new LodashWrapper(result2, chainAll);
62729              }
62730              if (isUnwrapped && onlyLazy) {
62731                return func.apply(this, args);
62732              }
62733              result2 = this.thru(interceptor);
62734              return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
62735            };
62736          });
62737          arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
62738            var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
62739            lodash2.prototype[methodName] = function() {
62740              var args = arguments;
62741              if (retUnwrapped && !this.__chain__) {
62742                var value = this.value();
62743                return func.apply(isArray2(value) ? value : [], args);
62744              }
62745              return this[chainName](function(value2) {
62746                return func.apply(isArray2(value2) ? value2 : [], args);
62747              });
62748            };
62749          });
62750          baseForOwn(LazyWrapper.prototype, function(func, methodName) {
62751            var lodashFunc = lodash2[methodName];
62752            if (lodashFunc) {
62753              var key2 = lodashFunc.name + "";
62754              if (!hasOwnProperty2.call(realNames, key2)) {
62755                realNames[key2] = [];
62756              }

62757              realNames[key2].push({ "name": methodName, "func": lodashFunc });
62758            }
62759          });
62760          realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [{
62761            "name": "wrapper",
62762            "func": undefined$1
62763          }];
62764          LazyWrapper.prototype.clone = lazyClone;
62765          LazyWrapper.prototype.reverse = lazyReverse;
62766          LazyWrapper.prototype.value = lazyValue;
62767          lodash2.prototype.at = wrapperAt;
62768          lodash2.prototype.chain = wrapperChain;
62769          lodash2.prototype.commit = wrapperCommit;
62770          lodash2.prototype.next = wrapperNext;
62771          lodash2.prototype.plant = wrapperPlant;
62772          lodash2.prototype.reverse = wrapperReverse;
62773          lodash2.prototype.toJSON = lodash2.prototype.valueOf = lodash2.prototype.value = wrapperValue;
62774          lodash2.prototype.first = lodash2.prototype.head;
62775          if (symIterator) {
62776            lodash2.prototype[symIterator] = wrapperToIterator;
62777          }
62778          return lodash2;
62779        });
62780        var _2 = runInContext();
62781        if (freeModule) {
62782          (freeModule.exports = _2)._ = _2;
62783          freeExports._ = _2;
62784        } else {
62785          root._ = _2;
62786        }
62787      }).call(lodash);
62788    })(lodash$1, lodash$1.exports);
62789    return lodash$1.exports;
62790  }
62791  var lodashExports = requireLodash();
62792  const _ = /* @__PURE__ */ getDefaultExportFromCjs$1(lodashExports);
62793  const MEMBER_LEVELS = {
62794    0: "SILVER",
62795    1: "GOLD",
62796    2: "PLATINUM",
62797    3: "BLACK"
62798  };
62799  window.EVT_Stays_Membership.env;
62800  const COOKIE_EVT_STAYS_PLUGIN = "evt_stays_plugin";
62801  const COOKIE_EVT_STAYS_USER_NAME = "evt_stays_user_name";
62802  const EVENT_EVT_STAYS_AUTH_CHECK = "evt_stays_authCheck";
62803  const EVENT_EVT_STAYS_START_LOGOUT = "evt_stays_startLogout";
62804  const EVENT_EVT_STAYS_SUCCESS_LOGIN = "evt_stays_successLogin";
62805  const EVENT_EVT_STAYS_JOIN = "evt_stays_successJoin";
62806  const EVENT_EVT_STAYS_SUCCESS_LOGOUT = "evt_stays_successLogout";
62807  const EVENT_EVT_STAYS_UPDATE_PROFILE = "evt_stays_updateProfile";
62808  const EVENT_EVT_STAYS_UPDATE_POINTS = "evt_stays_updatePoints";
62809  const SESSION_KEY_IS_LOGGED_IN = "rsd_ba_is_logged_in";
62810  const SESSION_KEY_LOGOUT_START = "rsd_ba_logout_start";
62811  const helpers = {
62812    docCookies: {
62813      getItem: function(sKey) {
62814        if (!sKey) {
62815          return null;
62816        }
62817        try {
62818          return decodeURIComponent(document.cookie.replace(new RegExp("(?:(?:^|.*;)\\s*" + encodeURIComponent(sKey).replace(/[-.+*]/g, "\\$&") + "\\s*\\=\\s*([^;]*).*$)|^.*$"), "$1")) || null;
62819        } catch {
62820          return null;
62821        }
62822      },
62823      setItem: function(sKey, sValue, vEnd, sPath, sDomain, bSecure = true) {
62824        if (!sKey || /^(?:expires|max-age|path|domain|secure)$/i.test(sKey)) {
62825          return false;
62826        }
62827        let sExpires = "";
62828        if (vEnd) {
62829          switch (vEnd.constructor) {
62830            case Number:
62831              sExpires = vEnd === Infinity ? "; expires=Fri, 31 Dec 9999 23:59:59 GMT" : "; max-age=" + vEnd;
62832              break;
62833            case String:
62834              sExpires = "; expires=" + vEnd;
62835              break;
62836            case Date:
62837              sExpires = "; expires=" + vEnd.toUTCString();
62838              break;
62839          }
62840        }
62841        document.cookie = encodeURIComponent(sKey) + "=" + encodeURIComponent(sValue) + sExpires + (sDomain ? "; domain=" + sDomain : "") + (sPath ? "; path=" + sPath : "") + (bSecure ? "; secure" : "");
62842        return true;
62843      },
62844      removeItem: function(sKey, sPath, sDomain) {
62845        if (!this.hasItem(sKey)) {
62846          return false;
62847        }
62848        document.cookie = encodeURIComponent(sKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC;" + (sDomain ? " domain=" + sDomain + ";" : "") + (sPath ? " path=" + sPath + ";" : "");
62849        return true;
62850      },
62851      hasItem: function(sKey) {
62852        if (!sKey || /^(?:expires|max-age|path|domain|secure)$/i.test(sKey)) {
62853          return false;
62854        }
62855        return new RegExp("(?:^|;\\s*)" + encodeURIComponent(sKey).replace(/[-.+*]/g, "\\$&") + "\\s*\\=").test(document.cookie);
62856      },
62857      keys: function() {
62858        const aKeys = document.cookie.replace(/((?:^|\s*;)[^=]+)(?=;|$)|^\s*|\s*(?:=[^;]*)?(?:\1|$)/g, "").split(/\s*(?:=[^;]*)?;\s*/);
62859        for (let nLen = aKeys.length, nIdx = 0; nIdx < nLen; nIdx++) {
62860          aKeys[nIdx] = decodeURIComponent(aKeys[nIdx]);
62861        }
62862        return aKeys;
62863      }
62864    },
62865    getParameterByName: (name, url2) => {
62866      if (!url2) {
62867        url2 = window.location.href;
62868      }
62869      name = name.replace(/[[\]]/g, "\\$&");
62870      const regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"), results = regex.exec(url2);
62871      if (!results) {
62872        return null;
62873      }
62874      if (!results[2]) {
62875        return "";
62876      }
62877      return decodeURIComponent(results[2].replace(/\+/g, " "));
62878    },
62879    isMobile: function() {
62880      let check = false;

62881      (function(a) {
62882        if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(
62883          a.substr(0, 4)
62884        )) {
62885          check = true;
62886        }
62887      })(navigator.userAgent || navigator.vendor || window.opera);
62888      return check;
62889    },
62890    getSearchParam: function(sParam, sString = "") {
62891      const sPageURL = "" === sString ? window.location.search.substring(1) : sString.substring(1);
62892      const sURLVariables = sPageURL.split("&");
62893      for (let i2 = 0; i2 < sURLVariables.length; i2++) {
62894        const sParameterName = sURLVariables[i2].split("=");
62895        if (sParameterName[0].toLowerCase() === sParam.toLowerCase()) {
62896          return sParameterName[1];
62897        }
62898      }
62899      return "";
62900    },
62901    pushStateHistory: function(subfix = "") {
62902      let path = location.protocol + "//" + location.host + location.pathname;
62903      path += subfix;
62904      history.pushState({ path }, "", path);
62905    },
62906    getCurrentDomain: function(hostName = "") {
62907      if ("" === hostName) {
62908        hostName = window.location.host;
62909      }
62910      let domain = hostName;
62911      if (hostName != null) {
62912        const parts = hostName.split(".").reverse();
62913        if (parts != null && parts.length > 1) {
62914          domain = parts[1] + "." + parts[0];
62915          if (hostName.toLowerCase().indexOf(".com.au") !== -1 && parts.length > 2) {
62916            domain = parts[2] + "." + domain;
62917          }
62918        }
62919      }
62920      return domain;
62921    },
62922    getSimulatedGUID: function() {
62923      function s4() {
62924        return Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
62925      }
62926      return s4() + s4() + "-" + s4() + "-" + s4() + "-" + s4() + "-" + s4() + s4() + s4();
62927    },
62928    initNewEvent: function(eventName, bubble = false) {
62929      if ("function" === typeof Event) {
62930        return new Event(eventName, { bubbles: bubble });
62931      } else {
62932        const event = document.createEvent("Event");
62933        event.initEvent(eventName, true, true);
62934        return event;
62935      }
62936    },
62937    stopBodyScrolling: function(toStop) {
62938      if (toStop === true) {
62939        document.body.addEventListener("touchmove", helpers.freezeDefault, false);
62940      } else {
62941        document.body.removeEventListener("touchmove", helpers.freezeDefault, false);
62942      }
62943    },
62944    isValidEmail: function(emailAddress) {
62945      let validEmail = false;

62946      if (emailAddress.length) {
62947        const regex = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z-0-9]+\.)+[a-zA-Z]{2,}))$/;
62948        if (regex.test(emailAddress)) {
62949          validEmail = true;
62950        }
62951      }
62952      return validEmail;
62953    },
62954    parseObject: function(string, defaultObject = {}) {
62955      try {
62956        const obj = JSON.parse(string);
62957        if (null !== obj && "object" === typeof obj) {
62958          return Object.assign(defaultObject, obj);
62959        }
62960      } catch {
62961      }
62962      return defaultObject;
62963    },
62964    obj: {
62965      getProp: function(obj, prop) {
62966        let val = null;
62967        Object.keys(obj).forEach(function(key2) {
62968          if (key2.toLowerCase() === prop.toLowerCase()) {
62969            val = obj[key2];
62970          }
62971        });
62972        return val;
62973      },
62974      removeProp: function(obj, prop) {
62975        Object.keys(obj).forEach(function(key2) {
62976          if (key2.toLowerCase() === prop.toLowerCase()) {
62977            delete obj[key2];
62978          }
62979        });
62980        return obj;
62981      }
62982    },
62983    isPasswordStrong: function(password) {
62984      return /(?=.*\d)(?=.*[A-Z])(?=.*[\W_]).{8,8}/gm.test(password);
62985    },
62986    setAuthCookieData: function(key2, value, expiry = null) {
62987      helpers.docCookies.setItem(key2, value, expiry, "/", `.${window.location.hostname}`);
62988    },
62989    removeAuthCookieData: function(key2) {
62990      helpers.docCookies.removeItem(key2, "/", `.${window.location.hostname}`);
62991    },
62992    isSessionStorageSupported() {
62993      const test2 = "rsd_ba_local_storage_test";
62994      try {
62995        sessionStorage.setItem(test2, test2);
62996        sessionStorage.removeItem(test2);
62997        return true;
62998      } catch {
62999        return false;
63000      }
63001    },
63002    removeSessionValue: (key2) => {
63003      if (helpers.isSessionStorageSupported()) {
63004        sessionStorage.removeItem(key2);
63005      } else if (window._rsdSessionValues) {
63006        delete window._rsdSessionValues[key2];
63007      }
63008    },
63009    getSessionValue: (key2) => {
63010      if (helpers.isSessionStorageSupported()) {
63011        return sessionStorage.getItem(key2);
63012      } else if (window._rsdSessionValues) {
63013        return window._rsdSessionValues[key2];
63014      }
63015      return null;
63016    },
63017    isHigherThanGold: (membershipLevel) => {
63018      const level = Number(membershipLevel);
63019      return level > 1;
63020    },
63021    displayNumber: (num) => {
63022      return isNaN(num) ? num : Number(num).toLocaleString();
63023    }
63024  };
63025  helpers.removeSessionCookies = function() {
63026    helpers.docCookies.removeItem(COOKIE_EVT_STAYS_PLUGIN, "/");
63027    helpers.removeSessionValue(SESSION_KEY_IS_LOGGED_IN);
63028  };
63029  const assetsPath = window.EVT_Stays_Membership.assetsPath;
63030  const UserErrorDisplayCard = () => {
63031    const [isVisible, setIsVisible] = React.useState(() => {
63032      return localStorage.getItem("membership-card-close") !== "true";
63033    });
63034    const closeMessageBox = () => {
63035      setIsVisible(false);
63036      localStorage.setItem("membership-card-close", "true");
63037    };
63038    if (!isVisible || window.location.pathname !== "/") return null;
63039    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "error-card-container", children: [

63040      /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath}images/icons/yellow-info-icon.svg` }),
63041      /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { className: "error-description", children: [
63042        "We're having trouble logging you in. This has been logged with our support team and they will be in touch once your account is ready. If it's urgent, please also log a ticket ",
63043        /* @__PURE__ */ jsxRuntimeExports.jsx("a", { className: "error-description-link underline", target: "_blank", rel: "noopener noreferrer", href: "https://support.evtstays.com/support/tickets/new?ticket_form=evt_stays", children: "here" }),
63044        ". We apologise for any inconvenience and thank you for your patience."
63045      ] }),
63046      /* @__PURE__ */ jsxRuntimeExports.jsx(
63047        ReactSVG,
63048        {
63049          className: "close-container-icon",
63050          onClick: closeMessageBox,
63051          src: `${assetsPath}images/icons/close-black.svg`
63052        }
63053      )
63054    ] });
63055  };
63056  const UserErrorDropdown = ({
63057    isDropdownOpen,
63058    handleDropdownClicked,
63059    handleLogoutClicked
63060  }) => {
63061    if (!isDropdownOpen) {
63062      return null;
63063    }
63064    return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "dropdown-menu dropdown-menu-right error-dropdown", children: [

63065      /* @__PURE__ */ jsxRuntimeExports.jsx(
63066        ReactSVG,
63067        {
63068          className: "close-icon",
63069          onClick: handleDropdownClicked,
63070          src: `${assetsPath}images/icons/close.svg`
63071        }
63072      ),
63073      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "error-section", children: [
63074        /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath}images/icons/white-info-icon.svg` }),
63075        /* @__PURE__ */ jsxRuntimeExports.jsxs("p", { className: "error-description", children: [
63076          " ",
63077          "We're having trouble logging you in. This has been logged with our support team and they will be in touch once your account is ready. If it's urgent, please also log a ticket ",
63078          /* @__PURE__ */ jsxRuntimeExports.jsx("a", { className: "error-description-link underline", target: "_blank", rel: "noopener noreferrer", href: "https://support.evtstays.com/support/tickets/new?ticket_form=evt_stays", children: "here" }),
63079          ". We apologise for any inconvenience and thank you for your patience."
63080        ] })
63081      ] }),

63082      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-divider error-divider" }),
63083      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "logout-section", onClick: handleLogoutClicked, children: [
63084        /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath}images/icons/logout.svg` }),
63085        " Logout"
63086      ] })
63087    ] });
63088  };
63089  function getParams$1() {
63090    return {
63091      headers: {}
63092    };
63093  }
63094  const fetchRewards = async () => {
63095    const { headers } = getParams$1();
63096    const params = {};
63097    try {
63098      const response2 = await axios.get("/rewards", {
63099        params,
63100        headers,
63101        withCredentials: true
63102      });
63103      return response2.data;
63104    } catch (error) {
63105      console.error("Error fetching rewards:", error);
63106      throw error;
63107    }
63108  };
63109  class MyAccountButton extends reactExports.Component {
63110    constructor(props) {
63111      super(props);
63112      __publicField(this, "isUseDropdown", () => {
63113        const {
63114          useDropdown
63115        } = this.props;
63116        return useDropdown.toLowerCase() === "true";
63117      });
63118      __publicField(this, "handleMouseOver", () => {
63119        const {
63120          version: version2,
63121          currentElement
63122        } = this.props;
63123        if (this.isUseDropdown() && version2 === "4" && currentElement) {
63124          currentElement.classList.add("dropdown-active");
63125        }
63126      });
63127      __publicField(this, "handleMouseOut", () => {
63128        const {
63129          version: version2,
63130          currentElement
63131        } = this.props;
63132        if (this.isUseDropdown() && version2 === "4" && currentElement) {
63133          currentElement.classList.remove("dropdown-active");
63134        }
63135      });
63136      __publicField(this, "handleExternalLogout", () => {
63137        this.setState({
63138          loggedIn: false,
63139          name: ""
63140        });
63141      });
63142      __publicField(this, "handleProfileUpdate", (event) => {
63143        const membershipData = _.get(event, "detail.data.data");
63144        const membershipGivenName = _.get(membershipData, "profilePerson.givenName", null);
63145        const membershipFamilyName = _.get(membershipData, "profilePerson.familyName", null);
63146        let name = membershipGivenName;
63147        const fullName = `${membershipGivenName} ${membershipFamilyName}`;
63148        if (membershipFamilyName) {
63149          name += ` ${membershipFamilyName.charAt(0)}`;
63150        }
63151        this.setState({ membershipData, name, fullName });
63152      });
63153      __publicField(this, "handleClickOutside", (e) => {
63154        const {
63155          loggedIn,
63156          isDropdownOpen
63157        } = this.state;
63158        if (loggedIn && isDropdownOpen && this.evtStaysMemberDropdownRef && !this.evtStaysMemberDropdownRef.current.contains(e.target)) {
63159          this.setState({ isDropdownOpen: false });
63160        }
63161      });
63162      __publicField(this, "handleDropdownClicked", () => {
63163        this.setState({ isDropdownOpen: !this.state.isDropdownOpen });
63164      });
63165      __publicField(this, "handleVerifyEmail", async (e) => {
63166        e.preventDefault();
63167        e.stopPropagation();
63168        this.setState({
63169          isSendingEmailVerification: true
63170        });
63171        await window.EVT_Stays_Membership.auth0Settings.verifyEmail();
63172        this.setState({
63173          isSendingEmailVerification: false
63174        });
63175      });
63176      __publicField(this, "handleLogoutClicked", async (e) => {
63177        e.preventDefault();
63178        await this.handleLogout();
63179      });
63180      __publicField(this, "handleLogin", (details) => {
63181        const data = _.get(details, "data");
63182        if (!data) {
63183          return;
63184        }
63185        let userData = data.evtStaysData;
63186        if (!userData) {
63187          userData = helpers.docCookies.getItem(COOKIE_EVT_STAYS_PLUGIN);
63188        }
63189        if (userData !== null) {
63190          const resultArr = userData.split(",");
63191          const membershipTier = resultArr[3].toLowerCase();
63192          const userId = resultArr[1];
63193          document.body.classList.add("evt-stays-logged-in");
63194          if (membershipTier) {
63195            document.body.classList.add(`tier-${membershipTier}`);
63196          }
63197          helpers.docCookies.setItem(COOKIE_EVT_STAYS_PLUGIN, userData, null, "/");
63198          this.setState({
63199            loggedIn: true,
63200            userId,
63201            membershipTier,
63202            membershipData: data.data,
63203            isVerified: data.isVerified
63204          });
63205        }
63206      });
63207      __publicField(this, "handleLogout", async (noApiCall) => {
63208        localStorage.removeItem(COOKIE_EVT_STAYS_USER_NAME);
63209        this.setState({
63210          isDropdownOpen: false,
63211          loading: true
63212        });
63213        const { success, errorMessage } = await this.props.onLogout({ noApiCall });
63214        if (!success) {
63215          console.error(errorMessage);
63216        }
63217        this.setState({
63218          loggedIn: false,
63219          name: "",
63220          loading: false
63221        });
63222      });
63223      __publicField(this, "handleAuthCheck", async (event) => {
63224        const userData = helpers.docCookies.getItem(COOKIE_EVT_STAYS_PLUGIN);
63225        const data = event.detail.data;
63226        let error = false;

63227        this.removeAuthenticatingClass();
63228        try {
63229          if (!data.success) {
63230            error = true;
63231          } else {
63232            this.handleLogin(event.detail);
63233            this.handleProfileUpdate(event);
63234            this.getRewards();
63235          }
63236        } catch (err) {
63237          console.error(err);
63238          error = true;
63239        }
63240        if (error && !!userData) {
63241          await this.handleLogout(true);
63242        }
63243      });
63244      __publicField(this, "updatePoints", (event) => {
63245        const data = event.detail.data;
63246        const points = data.points;
63247        const membershipData = _.cloneDeep(this.state.membershipData);
63248        _.set(membershipData, "profileMembership.accountPoints", _.get(membershipData, "profileMembership.accountPoints", 0) - points);
63249        const updateEvent = new CustomEvent(EVENT_EVT_STAYS_UPDATE_PROFILE, {
63250          detail: {
63251            data: {
63252              data: membershipData
63253            }
63254          }
63255        });
63256        document.dispatchEvent(updateEvent);
63257      });
63258      __publicField(this, "getRoute", (key2) => {
63259        return window.EVT_Stays_Membership.bases["home"]["evt_stays"] + "/account/#" + window.EVT_Stays_Membership.portalRoutes[key2];
63260      });
63261      __publicField(this, "getInitials", (name) => {
63262        const names = name.split(" ");
63263        let initials = names[0].substring(0, 1).toUpperCase();
63264        if (names.length > 1) {
63265          initials += names[names.length - 1].substring(0, 1).toUpperCase();
63266        }
63267        return initials;
63268      });
63269      __publicField(this, "removeAuthenticatingClass", () => {
63270        const myAccountButton = document.getElementsByClassName("evtstays-authenticating");
63271        for (let i2 = 0; i2 < myAccountButton.length; i2++) {
63272          if (myAccountButton[i2]) {
63273            myAccountButton[i2].classList.remove("evtstays-authenticating");
63274          }
63275        }
63276      });
63277      __publicField(this, "getRewards", async () => {
63278        const { rewards } = await fetchRewards();
63279        if (!_.isEmpty(rewards)) {
63280          this.setState({ showRewards: true });
63281        }
63282      });
63283      __publicField(this, "renderResendEmailVerification", (classNames = []) => {
63284        const {
63285          isVerified,
63286          isSendingEmailVerification,
63287          membershipData
63288        } = this.state;
63289        const emailAddress = _.get(membershipData, "profilePerson.emailAddress");
63290        let loginUrl = "#";
63291        if (window.EVT_Stays_Membership.auth0Settings) {
63292          loginUrl = window.EVT_Stays_Membership.auth0Settings.loginUrl;
63293        }
63294        const assetsPath2 = window.EVT_Stays_Membership.assetsPath;
63295        return /* @__PURE__ */ jsxRuntimeExports.jsx(React.Fragment, { children: !isVerified && /* @__P

63295URE__ */ jsxRuntimeExports.jsx("div", { className: ["email-verify-menu", ...classNames].join(" "), children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "content", children: [
63296          /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "message", children: [
63297            /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath2}images/icons/info-warning.svg` }),
63298            "Please verify your email: ",
63299            /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "email-address", children: emailAddress })
63300          ] }),
63301          /* @__PURE__ */ jsxRuntimeExports.jsx("button", { className: "btn btn-outline", onClick: this.handleVerifyEmail, disabled: isSendingEmailVerification, children: isSendingEmailVerification ? "Sending..." : "Resend Verify Email" }),
63302          /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "footnotes", children: [
63303            /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "message footnote", children: [
63304              "Already verified?",

63305              /* @__PURE__ */ jsxRuntimeExports.jsx("br", {}),
63306              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: loginUrl, children: "Refresh your session" })
63307            ] }),
63308            /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "message footnote contact", children: [
63309              "Need help? ",
63310              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "https://support.evtstays.com/support/home", children: "Contact us" })
63311            ] })
63312          ] })
63313        ] }) }) });
63314      });
63315      __publicField(this, "renderDropdownAccount", () => {
63316        const {
63317          version: version2,
63318          forceHideMemberPoints
63319        } = this.props;
63320        const {
63321          name,
63322          fullName,
63323          membershipData,
63324          membershipTier,
63325          isDropdownOpen,
63326          loading,
63327          showRewards,
63328          isVerified
63329        } = this.state;
63330        const profileMembership = _.get(membershipData, "profileMembership", {});
63331        const points = _.get(profileMembership, "accountPoints", 0);
63332        const isForceHideMemberPoints = !!forceHideMemberPoints && forceHideMemberPoints.toLowerCase() === "true";
63333        const isErrorOnMembershipData = _.isNil(_.get(profileMembership, "memberId", null)) || _.isNil(_.get(profileMembership, "membershipLevel", null));
63334        const isHigherThanGold = helpers.isHigherThanGold(profileMembership.membershipLevel);
63335        const assetsPath2 = window.EVT_Stays_Membership.assetsPath;
63336        let userImg;
63337        let evtStaysImg;
63338        if (!window.EVT_Stays_Membership.apiUrl.startsWith(location.protocol + "//" + location.host)) {
63339          const userSvg = encodeURIComponent(`
63340        <svg xmlns="http://www.w3.org/2000/svg" width="44" height="44" viewBox="0 0 44 44" fill="none">
63341          <path d="M27.2276 23.0404C28.6611 21.9097 29.7075 20.3593 30.221 18.6047C30.7346 16.8502 30.6899 14.9787 30.0932 13.2508C29.4964 11.5229 28.3773 10.0245 26.8915 8.96388C25.4056 7.90331 23.627 7.33337 21.803 7.33337C19.979 7.33337 18.2004 7.90331 16.7146 8.96388C15.2288 10.0245 14.1096 11.5229 13.5129 13.2508C12.9161 14.9787 12.8714 16.8502 13.385 18.6047C13.8986 20.3593 14.9449 21.9097 16.3784 23.0404C13.9221 24.0269 11.7788 25.6632 10.1772 27.7749C8.57554 29.8865 7.57552 32.3942 7.28372 35.0308C7.2626 35.2233 7.27951 35.4181 7.33347 35.604C7.38744 35.79 7.47741 35.9634 7.59825 36.1145C7.8423 36.4197 8.19726 36.6151 8.58505 36.6579C8.97284 36.7006 9.36169 36.5872 9.66606 36.3425C9.97044 36.0979 10.1654 35.742 10.2081 35.3533C10.5291 32.4879 11.892 29.8415 14.0363 27.9198C16.1806 25.9981 18.956 24.9357 21.8323 24.9357C24.7085 24.9357 27.4839 25.9981 29.6282 27.9198C31.7725 29.8415 33.1354 32.4879 33.4565 35.3533C33.4962 35.7135 33.6677 36.0461 33.9377 36.287C34.2077 36.5279 34.5572 36.6601 34.9186 36.6579H35.0795C35.4628 36.6136 35.8131 36.4194 36.0541 36.1173C36.2951 35.8153 36.4073 35.43 36.3662 35.0455C36.073 32.4014 35.0676 29.8872 33.4577 27.7723C31.8478 25.6575 29.6942 24.0217 27.2276 23.0404ZM21.803 21.9996C20.6463 21.9996 19.5155 21.6558 18.5537 21.0115C17.5919 20.3672 16.8422 19.4515 16.3996 18.3801C15.9569 17.3088 15.8411 16.1299 16.0667 14.9925C16.2924 13.8551 16.8494 12.8104 17.6674 11.9904C18.4853 11.1704 19.5275 10.612 20.662 10.3857C21.7965 10.1595 22.9725 10.2756 24.0412 10.7194C25.1099 11.1632 26.0233 11.9147 26.666 12.8789C27.3087 13.8431 27.6517 14.9767 27.6517 16.1364C27.6517 17.6914 27.0355 19.1827 25.9386 20.2823C24.8418 21.3819 23.3542 21.9996 21.803 21.9996Z" fill="white"/>
63342        </svg>
63343      `);
63344          const evtStaysSvg = encodeURIComponent(`
63345        <svg xmlns="http://www.w3.org/2000/svg" width="54" height="30" viewBox="0 0 54 30" fill="none">
63346          <path d="M53.8776 9.33274V0H0V1.72414V9.33274V10.3359V18.9431V19.6686H44.3823V20.6673H0V30H53.8776V29.2745V20.6673V19.6686V12.06V10.3359H9.49521V9.33274H53.8776Z" fill="white"/>
63347        </svg>
63348      `);
63349          userImg = /* @__PURE__ */ jsxRuntimeExports.jsx("img", { src: `data:image/svg+xml;utf8,${userSvg}` });
63350          evtStaysImg = /* @__PURE__ */ jsxRuntimeExports.jsx("img", { src: `data:image/svg+xml;utf8,${evtStaysSvg}` });
63351        } else {
63352          userImg = /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath2}images/icons/user.svg` });
63353          evtStaysImg = /* @__PURE__ */ jsxRuntimeExports.jsx(ReactSVG, { src: `${assetsPath2}images/evt-stays-white.svg` });
63354        }
63355        let mainContainerClasses = [];
63356        if (isVerified) {
63357          mainContainerClasses.push("verified");
63358        } else {
63359          mainContainerClasses.push("unverified");
63360        }
63361        if (version2 === "4") {
63362          const memberDetailName = fullName;
63363          mainContainerClasses = mainContainerClasses.concat([
63364            "evt-stays-membership-logged-in"
63365          ]);
63366          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: mainContainerClasses.join(" "), onMouseOver: this.handleMouseOver, onMouseOut: this.handleMouseOut, children: [

63367            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "top", children: [
63368              loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper d-inline-block mr-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) }),
63369              isErrorOnMembershipData && /* @__PURE__ */ jsxRuntimeExports.jsx(UserErrorDisplayCard, {}),
63370              /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "username", children: [
63371                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "initials", children: this.getInitials(fullName) }),
63372                /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "greetings", children: [
63373                  "Hi, ",
63374                  name
63375                ] })
63376              ] }),
63377              /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid caret-icon", src: `${assetsPath2}images/icons/caret-down.svg`, alt: "caret" }),
63378              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-close", onClick: this.handleMouseOut })
63379            ] }),

63380            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "bottom", children: [
63381              /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "member-details block", children: [
63382                /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "logo-wrapper", children: evtStaysImg }),
63383                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "member-name", children: memberDetailName }),
63384                /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "membership-tier", children: [
63385                  /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "tier", children: membershipTier }),
63386                  /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "member-points", children: [
63387                    " - ",
63388                    helpers.displayNumber(points),
63389                    " points"
63390                  ] })
63391                ] })
63392              ] }),
63393              this.renderResendEmailVerification(),
63394              isErrorOnMembershipData ? /* @__PURE__ */ jsxRuntimeExports.jsx(
63395                UserErrorDropdown,
63396                {
63397                  isDropdownOpen: true,
63398                  handleDropdownClicked: this.handleDropdownClicked,
63399                  handleLogoutClicked: this.handleLogoutClicked
63400                }
63401              ) : /* @__PURE__ */ jsxRuntimeExports.jsxs(React.Fragment, { children: [

63402                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("dashboard"), className: "dropdown-item", children: "My Account" }),
63403                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("booking"), className: "dropdown-item", children: "Bookings & Activities" }),
63404                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("profile"), className: "dropdown-item", children: "Profile & Preferences " }),
63405                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("redeem"), className: "dropdown-item", children: "Redeem Points" }),
63406                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vouchers"), className: "dropdown-item", children: "My Vouchers" }),
63407                isHigherThanGold && /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vip-support"), className: "dropdown-item", children: "VIP Support" }),
63408                /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "https://support.evtstays.com/", target: "_blank", rel: "noopener noreferrer", className: "dropdown-item", children: "FAQ" }),

63409                /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "#", className: "logout-link", onClick: this.handleLogoutClicked, disabled: loading, children: [
63410                  /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/logout.svg`, alt: "logout" }),
63411                  " Logout"
63412                ] })
63413              ] })
63414            ] })
63415          ] });
63416        } else if (version2 === "2") {
63417          const memberDetailName = fullName;
63418          mainContainerClasses = mainContainerClasses.concat([
63419            "dropdown",
63420            "evt-stays-member-dropdown",
63421            "flex",
63422            "items-center"
63423          ]);
63424          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ref: this.evtStaysMemberDropdownRef, className: mainContainerClasses.join(" "), children: [
63425            loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper inline-block mr-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) }),

63426            isErrorOnMembershipData && /* @__PURE__ */ jsxRuntimeExports.jsx(UserErrorDisplayCard, {}),
63427            /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: `dropdown-toggle ${loading ? "running-loader" : ""} ${isDropdownOpen ? "dropdown-active" : ""}`, onClick: this.handleDropdownClicked, children: [
63428              /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "dropdown-caret-holder", children: [
63429                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "hidden lg:inline-block user-image", children: userImg }),
63430                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "lg:hidden user-initials", children: this.getInitials(fullName) }),
63431                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "hidden lg:inline-block user-name", children: name })
63432              ] }),
63433              isErrorOnMembershipData ? /* @__PURE__ */ jsxRuntimeExports.jsx(
63434                UserErrorDropdown,
63435                {
63436                  isDropdownOpen,
63437                  handleDropdownClicked: this.handleDropdownClicked,
63438                  handleLogoutClicked: this.handleLogoutClicked
63439                }
63440              ) : /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `dropdown-menu dropdown-menu-right ${isDropdownOpen ? "show" : ""}`, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "dropdown-menu-wrapper", children: [

63441                /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-close", onClick: this.handleDropdownClicked }),
63442                /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "member-details block", children: [
63443                  /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "logo-wrapper", children: evtStaysImg }),
63444                  /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "member-name", children: memberDetailName }),
63445                  /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "membership-tier", children: [
63446                    /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "tier", children: membershipTier }),
63447                    !isForceHideMemberPoints && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "member-points", children: [
63448                      " - ",
63449                      helpers.displayNumber(points),
63450                      " points"
63451                    ] })
63452                  ] })
63453                ] }),

63454                /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "nav-container", children: [
63455                  this.renderResendEmailVerification(["dropdown-item"]),
63456                  /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("dashboard"), className: "dropdown-item", target: "_blank", rel: "noreferrer", children: "My Account" }),
63457                  /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("booking"), className: "dropdown-item", children: "Bookings & Activities" }),
63458                  /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("profile"), className: "dropdown-item", children: "Profile & Preferences " }),
63459                  showRewards && /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("redeem"), className: "dropdown-item", children: "Redeem Points" }),
63460                  /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vouchers"), className: "dropdown-item", children: "My Vouchers" }),
63461                  isHigherThanGold && /* @__P

63461URE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vip-support"), className: "dropdown-item", children: "VIP Support" }),
63462                  /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "https://support.evtstays.com/", target: "_blank", rel: "noopener noreferrer", className: "dropdown-item", children: "FAQ" }),
63463                  /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-divider" }),
63464                  /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { className: "dropdown-item logout-link", href: "#", onClick: this.handleLogoutClicked, children: [
63465                    /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/logout.svg`, alt: "logout" }),
63466                    " Logout"
63467                  ] })
63468                ] })
63469              ] }) })
63470            ] })
63471          ] });
63472        } else if (version2 === "5") {
63473          mainContainerClasses = mainContainerClasses.concat([
63474            "dropdown",
63475            "evt-stays-member-dropdown",
63476            "d-flex",
63477            "align-items-center"
63478          ]);
63479          const memberDetailName = fullName;
63480          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: mainContainerClasses.join(" "), children: [
63481            loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper d-inline-block mr-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) }),

63482            /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: `btn btn-white dropdown-toggle ${isDropdownOpen ? "dropdown-active" : ""}`, type: "button", "data-toggle": "dropdown", onClick: this.handleDropdownClicked, children: [
63483              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "user-initials lg:hidden", children: this.getInitials(fullName) }),
63484              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "user-name hidden lg:inline-block", children: name })
63485            ] }),
63486            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `dropdown-menu dropdown-menu-right ${isDropdownOpen ? "show" : ""}`, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "dropdown-menu-wrapper", children: [
63487              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-close", onClick: this.handleDropdownClicked }),
63488              /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "member-details block", children: [
63489                /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "logo-wrapper", children: evtStaysImg }),

63490                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "member-name", children: memberDetailName }),
63491                /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "membership-tier", children: [
63492                  /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "tier", children: membershipTier }),
63493                  /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "member-points", children: [
63494                    " - ",
63495                    helpers.displayNumber(points),
63496                    " points"
63497                  ] })
63498                ] })
63499              ] }),
63500              this.renderResendEmailVerification(),
63501              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("dashboard"), className: "dropdown-item", children: "My Account" }),
63502              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("booking"), className: "dropdown-item", children: "Bookings & Activities" }),
63503              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("profile"), className: "dropdown-item", children: "Profile & Preferences " }),

63504              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("redeem"), className: "dropdown-item", children: "Redeem Points" }),
63505              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vouchers"), className: "dropdown-item", children: "My Vouchers" }),
63506              isHigherThanGold && /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vip-support"), className: "dropdown-item", children: "VIP Support" }),
63507              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "https://support.evtstays.com/", target: "_blank", rel: "noopener noreferrer", className: "dropdown-item", children: "FAQ" }),
63508              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "#", className: "logout-link", onClick: this.handleLogoutClicked, disabled: loading, children: [
63509                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/logout.svg`, alt: "logout" }),
63510                " Logout"
63511              ] })
63512            ] }) })
63513          ] });
63514        } else {
63515          mainContainerClasses = mainContainerClasses.concat([
63516            "dropdown",
63517            "evt-stays-member-dropdown",
63518            "d-flex",
63519            "align-items-center"
63520          ]);
63521          const memberDetailName = fullName;
63522          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: mainContainerClasses.join(" "), children: [
63523            loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper d-inline-block mr-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) }),

63524            /* @__PURE__ */ jsxRuntimeExports.jsxs("button", { className: `btn btn-white dropdown-toggle ${isDropdownOpen ? "dropdown-active" : ""}`, type: "button", "data-toggle": "dropdown", onClick: this.handleDropdownClicked, children: [
63525              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "user-initials lg:hidden", children: this.getInitials(fullName) }),
63526              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "user-name hidden lg:inline-block", children: name })
63527            ] }),
63528            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: `dropdown-menu dropdown-menu-right ${isDropdownOpen ? "show" : ""}`, children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "dropdown-menu-wrapper", children: [
63529              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-close", onClick: this.handleDropdownClicked }),
63530              /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "member-details block", children: [
63531                /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "logo-wrapper", children: evtStaysImg }),

63532                /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "member-name", children: memberDetailName }),
63533                /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "membership-tier", children: [
63534                  /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "tier", children: membershipTier }),
63535                  !isForceHideMemberPoints && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "member-points", children: [
63536                    " - ",
63537                    helpers.displayNumber(points),
63538                    " points"
63539                  ] })
63540                ] })
63541              ] }),
63542              this.renderResendEmailVerification(),
63543              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("dashboard"), className: "dropdown-item", target: "_blank", rel: "noreferrer", children: "My Account" }),
63544              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("booking"), className: "dropdown-item", children: "Bookings & Activities" }),

63545              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("profile"), className: "dropdown-item", children: "Profile & Preferences " }),
63546              showRewards && /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("redeem"), className: "dropdown-item", children: "Redeem Points" }),
63547              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vouchers"), className: "dropdown-item", children: "My Vouchers" }),
63548              isHigherThanGold && /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: this.getRoute("vip-support"), className: "dropdown-item", children: "VIP Support" }),
63549              /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "https://support.evtstays.com/", target: "_blank", rel: "noopener noreferrer", className: "dropdown-item", children: "FAQ" }),
63550              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "dropdown-divider" }),
63551              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { className: "dropdown-item logout-link", href: "#", onClick: this.handleLogoutClicked, children: [

63552                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/logout.svg`, alt: "logout" }),
63553                " Logout"
63554              ] })
63555            ] }) })
63556          ] });
63557        }
63558      });
63559      __publicField(this, "renderInlineAccount", () => {
63560        const {
63561          version: version2
63562        } = this.props;
63563        const {
63564          name,
63565          fullName,
63566          loading,
63567          userId,
63568          membershipData
63569        } = this.state;
63570        const profileMembership = _.get(membershipData, "profileMembership", {});
63571        const isErrorOnMembershipData = _.isNil(_.get(profileMembership, "memberId", null)) || _.isNil(_.get(profileMembership, "membershipLevel", null));
63572        const assetsPath2 = window.EVT_Stays_Membership.assetsPath;
63573        if (version2 === "4") {
63574          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "container", children: [
63575            /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "my-account-close", children: /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", src: `${assetsPath2}images/icons/x-bold.svg`, className: "img-fluid" }) }),

63576            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "account-name", children: [
63577              /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "initials", children: this.getInitials(fullName) }),
63578              name
63579            ] }),
63580            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "list", children: [
63581              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: window.EVT_Stays_Membership.bases["home"]["evt_stays"] + "/account", className: "myaccount-btn", children: [
63582                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon myaccount-icon", src: `${assetsPath2}images/icons/account-circle-outline.svg`, alt: "account" }),
63583                "My account"
63584              ] }),
63585              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "#", className: "logout-btn", onClick: this.handleLogoutClicked, disabled: loading, children: [
63586                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/log-out.svg`, alt: "logout" }),
63587                "Log out",
63588                loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper d-inline-block mr-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) })
63589              ] })
63590            ] })
63591          ] });
63592        } else if (version2 === "3") {
63593          return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "initials evt-stays-membership-account-trigger", children: this.getInitials(fullName) });
63594        } else if (version2 === "2") {
63595          return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "evt

63595-stays-member-links", children: [
63596            /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: window.EVT_Stays_Membership.bases["home"]["evt_stays"] + "/account", className: "account-link inline-block ml-2", children: name }),
63597            ",",
63598            /* @__PURE__ */ jsxRuntimeExports.jsx("a", { href: "#", className: "logout-link inline-block ml-4", onClick: this.handleLogoutClicked, children: "(Logout)" }),
63599            loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper inline-block ml-4", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) })
63600          ] });
63601        } else {
63602          return /* @__PURE__ */ jsxRuntimeExports.jsx(React.Fragment, { children: isErrorOnMembershipData ? /* @__PURE__ */ jsxRuntimeExports.jsxs(React.Fragment, { children: [
63603            /* @__PURE__ */ jsxRuntimeExports.jsx(UserErrorDisplayCard, {}),
63604            /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "#", className: "logout-link", onClick: this.handleLogoutClicked, disabled: loading, children: [

63605              /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/log-out-black.svg`, alt: "logout" }),
63606              " ",
63607              /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "Log out" })
63608            ] })
63609          ] }) : /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "evt-stays-member-wrapper", children: [
63610            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "account-name", children: [
63611              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "initials", children: this.getInitials(fullName) }),
63612              fullName,
63613              " - ",
63614              userId
63615            ] }),
63616            this.renderResendEmailVerification(),
63617            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "evt-stays-member-links", children: [
63618              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: window.EVT_Stays_Membership.bases["home"]["evt_stays"] + "/account", className: "account-link d-inline-block", children: [

63619                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon myaccount-icon", src: `${assetsPath2}images/icons/account-circle-black.svg`, alt: "account" }),
63620                "My Account"
63621              ] }),
63622              /* @__PURE__ */ jsxRuntimeExports.jsxs("a", { href: "#", className: "logout-link d-inline-block", onClick: this.handleLogoutClicked, children: [
63623                /* @__PURE__ */ jsxRuntimeExports.jsx("img", { loading: "lazy", className: "img-fluid icon logout-icon", src: `${assetsPath2}images/icons/log-out-black.svg`, alt: "logout" }),
63624                "Log out"
63625              ] }),
63626              loading && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "loader-wrapper d-inline-block", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "spinner-loader" }) })
63627            ] })
63628          ] }) });
63629        }
63630      });
63631      this.state = {
63632        loggedIn: false,
63633        fullName: "",
63634        name: "",
63635        membershipTier: "",
63636        isDropdownOpen: false,
63637        loading: false,
63638        membershipData: null,
63639        showRewards: false,
63640        isSendingEmailVerification: false
63641      };
63642      this.evtStaysMemberDropdownRef = React.createRef();
63643    }
63644    componentDidMount() {
63645      document.addEventListener("mousedown", this.handleClickOutside);
63646      document.addEventListener(EVENT_EVT_STAYS_AUTH_CHECK, this.handleAuthCheck);
63647      document.addEventListener(EVENT_EVT_STAYS_UPDATE_PROFILE, this.handleProfileUpdate);
63648      document.addEventListener(EVENT_EVT_STAYS_SUCCESS_LOGOUT, this.handleExternalLogout);
63649      document.addEventListener(EVENT_EVT_STAYS_UPDATE_POINTS, this.updatePoints);
63650    }
63651    componentWillUnmount() {
63652      document.removeEventListener("mousedown", this.handleClickOutside);
63653      document.removeEventListener(EVENT_EVT_STAYS_AUTH_CHECK, this.handleAuthCheck);
63654      document.removeEventListener(EVENT_EVT_STAYS_UPDATE_PROFILE, this.handleProfileUpdate);
63655      document.removeEventListener(EVENT_EVT_STAYS_SUCCESS_LOGOUT, this.handleExternalLogout);
63656      document.removeEventListener(EVENT_EVT_STAYS_UPDATE_POINTS, this.updatePoints);
63657    }
63658    render() {
63659      const {
63660        loggedIn
63661      } = this.state;
63662      if (loggedIn) {
63663        if (this.isUseDropdown()) {
63664          return this.renderDropdownAccount();
63665        } else {
63666          return this.renderInlineAccount();
63667        }
63668      }
63669      return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { dangerouslySetInnerHTML: { __html: this.props.currentHtml }, onMouseOver: this.handleMouseOver, onMouseOut: this.handleMouseOut });
63670    }
63671  }
63672  __publicField(MyAccountButton, "defaultProps", {
63673    version: "1",
63674    useDropdown: "true",
63675    currentHtml: ""
63676  });
63677  MyAccountButton.propTypes = {
63678    version: PropTypes.string,
63679    useDropdown: PropTypes.string,
63680    currentHtml: PropTypes.string,
63681    currentElement: PropTypes.element,
63682    onLogout: PropTypes.func
63683  };
63684  const braze = window.braze;
63685  const startSession = (brazeId) => {
63686    braze.changeUser(brazeId);
63687    braze.openSession();
63688  };
63689  function getParams() {
63690    return {
63691      headers: {}
63692    };
63693  }
63694  const createServerLogs = async (messages2 = [], logType = "server", eventType = "", event = {}) => {
63695    try {
63696      const { headers } = getParams();
63697      return await axios.post(
63698        "/logs",
63699        { logType, messages: messages2, eventType, event },
63700        { headers }
63701      );
63702    } catch {
63703    }
63704    return null;
63705  };
63706  const returnTo = () => {
63707    const currentPage = new URL(window.location.href);
63708    return encodeURIComponent(window.btoa(currentPage.toString()));
63709  };
63710  const verifyEmail = async () => {
63711    let success = false;
63712    try {
63713      await axios.post(window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restVerifyEmail}`, { withCredentials: true });
63714      success = true;
63715    } catch (error) {
63716      console.error("Error verifying email:", error);
63717    }
63718    return success;
63719  };
63720  const processUserInfo = (callback) => {
63721    axios.get(window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restGetuser}`, { withCredentials: true }).then(function(response2) {
63722      const userInfo = response2;
63723      const isVerified = userInfo.data.isVerified;
63724      const userData = userInfo.data.metadata || {};
63725      userData.id = userInfo.data.sub;
63726      const isSignup = userInfo.data.signup;
63727      const isAfterAuth = userInfo.data.initialReq;
63728      const membership = userData.membership;
63729      const { profilePerson, profileMembership } = membership;
63730      const emailAddress = profilePerson.emailAddress;
63731      const memberFirstName = profilePerson.givenName;
63732      const memberLastName = profilePerson.familyName;
63733      const userFullName = `${memberFirstName} ${memberLastName},${profileMembership.memberId}`;
63734      const evtStaysData = `${userFullName},${emailAddress},${MEMBER_LEVELS[profileMembership.membershipLevel]}`;
63735      helpers.docCookies.setItem(COOKIE_EVT_STAYS_PLUGIN, evtStaysData, null, "/");
63736      const contactUsLink = document.querySelector(".contact-us-menu-item a");
63737      if (contactUsLink && helpers.isHigherThanGold(profileMembership.membershipLevel)) {
63738        contactUsLink.href = window.EVT_Stays_Membership.evtStaysDetails.homeUrl + "/account/#/vip-support";
63739      }
63740      if (memberFirstName) {
63741        localStorage.setItem(COOKIE_EVT_STAYS_USER_NAME, memberFirstName);
63742      }
63743      if (isAfterAuth) {
63744        const eventName = isSignup ? EVENT_EVT_STAYS_JOIN : EVENT_EVT_STAYS_SUCCESS_LOGIN;
63745        if (window.braze && userInfo.data.brazeId) {
63746          startSession(userInfo.data.brazeId);
63747        }
63748        if (window.dataLayer) {
63749          const gtmMemberMetricPayload = {
63750            firstName: memberFirstName,
63751            lastName: memberLastName,
63752            emailAddress,
63753            memberId: profileMembership.memberId
63754          };
63755          if (isSignup) {
63756            window.dataLayer.push({
63757              "event": "member_join",
63758              "error": null
63759            });
63760            createServerLogs([], "new_relic", "gtm", { ...gtmMemberMetricPayload, event: "member_join" });
63761          }
63762          window.dataLayer.push({
63763            "event": "member_login",
63764            "error": null
63765          });
63766          createServerLogs([], "new_relic", "gtm", { ...gtmMemberMetricPayload, event: "member_login" });
63767        }
63768        const event2 = new CustomEvent(eventName, {
63769          "detail": {
63770            "type": window.EVT_Stays_Membership.membershipApiMethod,
63771            "raw": evtStaysData,
63772            "data": {
63773              success: true,
63774              ...{
63775                evtStaysData,
63776                data: userData.membership,
63777                isVerified
63778              }
63779            }
63780          }
63781        });
63782        document.dispatchEvent(event2);
63783      }
63784      window.EVT_Stays_Membership.authChecked = true;
63785      const event = new CustomEvent(EVENT_EVT_STAYS_AUTH_CHECK, {
63786        "detail": {
63787          "type": window.EVT_Stays_Membership.membershipApiMethod,
63788          "raw": evtStaysData,
63789          "data": {
63790            success: true,
63791            ...{
63792              evtStaysData,
63793              data: userData.membership,
63794              isVerified
63795            }
63796          }
63797        }
63798      });
63799      if (callback) {
63800        callback(event);
63801      }
63802      document.dispatchEvent(event);
63803    }).catch(function(error) {
63804      var _a, _b, _c;
63805      console.error("Error fetching data:", error);
63806      window.EVT_Stays_Membership.authChecked = false;

63807      document.body.classList.add("evt-not-logged-in");
63808      const wasLoggedIn = helpers.getSessionValue(SESSION_KEY_IS_LOGGED_IN);
63809      helpers.removeSessionValue(SESSION_KEY_IS_LOGGED_IN);
63810      if (wasLoggedIn && window.dataLayer) {
63811        const errorInfo = {
63812          message: ((_b = (_a = error == null ? void 0 : error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || (error == null ? void 0 : error.message) || "Authentication failed",
63813          status: ((_c = error == null ? void 0 : error.response) == null ? void 0 : _c.status) || null
63814        };
63815        window.dataLayer.push({
63816          "event": "member_login",
63817          "error": errorInfo
63818        });
63819      }
63820      if (localStorage.getItem(SESSION_KEY_LOGOUT_START)) {
63821        document.dispatchEvent(new CustomEvent(EVENT_EVT_STAYS_SUCCESS_LOGOUT, {
63822          "detail": {}
63823        }));
63824      }
63825    }).finally(() => {
63826      localStorage.removeItem(SESSION_KEY_LOGOUT_START);
63827    });
63828  };
63829  const apiVersion = window.EVT_Stays_Membership.version;
63830  const displayLastLoggedInUser = () => {
63831    const username = localStorage.getItem(COOKIE_EVT_STAYS_USER_NAME);
63832    const placeholderBtn = document.querySelector(".header-user-name-placeholder");
63833    if (username && placeholderBtn) {
63834      const span = placeholderBtn.querySelector("span");
63835      if (span) {
63836        span.textContent = `Â Sign in, ${username}`;
63837      }
63838      placeholderBtn.classList.remove("btn-outline", "btn-inverse");
63839      placeholderBtn.classList.add("header-user-name");
63840    }
63841  };
63842  const getLoginUrl = () => window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restLogin}?v=${apiVersion}&returnTo=${returnTo()}`;
63843  window.EVT_Stays_Membership.auth0Settings = {
63844    ...window.EVT_Stays_Membership.auth0Settings,
63845    loginUrl: getLoginUrl(),
63846    login: (isForceSameTab = false) => {
63847      if (window.EVT_Stays_Membership.auth0Settings.areLinksForceNewTab && !isForceSameTab) {
63848        window.open(getLoginUrl());
63849        return;
63850      }
63851      window.location.href = getLoginUrl();
63852    },
63853    join: (isForceSameTab = false) => {
63854      if (window.EVT_Stays_Membership.auth0Settings.areLinksForceNewTab && !isForceSameTab) {
63855        window.open(window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restJoin}?v=${apiVersion}&returnTo=${returnTo()}`);
63856        return;
63857      }
63858      window.location.href = window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restJoin}?v=${apiVersion}&returnTo=${returnTo()}`;
63859    },
63860    logout: () => {
63861      window.location.href = window.EVT_Stays_Membership.apiUrl + `/${window.EVT_Stays_Membership.slugs.restLogout}?v=${apiVersion}&returnTo=${returnTo()}`;
63862    },
63863    processUserInfo,
63864    verifyEmail
63865  };
63866  window.EVT_Stays_Membership = Object.assign({
63867    ajaxUrl: "",
63868    apiUrl: "",
63869    assetsPath: "",
63870    distPath: "",
63871    siteName: "",
63872    bases: {},
63873    slugs: {},
63874    source: axios.CancelToken.source()
63875  }, window.EVT_Stays_Membership || {});
63876  axios.defaults.baseURL = window.EVT_Stays_Membership.apiUrl;
63877  const handleLogout = async () => {
63878    helpers.removeSessionCookies();
63879    if (window.EVT_Stays_Membership.auth0Settings.logout) {
63880      window.EVT_Stays_Membership.auth0Settings.logout();
63881    }
63882    localStorage.setItem(SESSION_KEY_LOGOUT_START, true);
63883    document.body.classList.remove("evt-stays-logged-in");
63884    const success = true;
63885    return {
63886      success,
63887      errorMessage: void 0
63888    };
63889  };
63890  (() => {
63891    const myAccountButton = document.getElementsByClassName("evtstays-membership-login-account-button");
63892    for (let i2 = 0; i2 < myAccountButton.length; i2++) {
63893      if (myAccountButton[i2]) {
63894        const myAccountButtonProps = { ...myAccountButton[i2].dataset };
63895        myAccountButton[i2].classList.add("evtstays-authenticating");
63896        const root = ReactDOM.createRoot(myAccountButton[i2]);
63897        root.render(

63898          /* @__PURE__ */ jsxRuntimeExports.jsx(
63899            MyAccountButton,
63900            {
63901              ...myAccountButtonProps,
63902              currentHtml: myAccountButton[i2].innerHTML,
63903              currentElement: myAccountButton[i2],
63904              onLogout: handleLogout
63905            }
63906          )
63907        );
63908      }
63909    }
63910    displayLastLoggedInUser();
63911    processUserInfo();
63912  })();
63913  document.addEventListener(EVENT_EVT_STAYS_START_LOGOUT, async (event) => {
63914    const { onLogout, extraEventArgs } = event.detail;
63915    const result = await handleLogout();
63916    if (onLogout) {
63917      onLogout(result);
63918    }
63919  });
63920})();

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.