☰

🔥🔥网易音乐，支持歌词和歌曲下载🔥🔥

网易音乐支持当前页歌词下载，同时支持歌曲mp3下载

目前為 2024-02-17 提交的版本，檢視 最新版本。

// ==UserScript==
// @name         🔥🔥网易音乐，支持歌词和歌曲下载🔥🔥
// @namespace    https://www.softrr.cn/
// @version      1.0.1
// @author       hackhase
// @description  网易音乐支持当前页歌词下载，同时支持歌曲mp3下载
// @license      MIT
// @icon         http://s1.music.126.net/style/favicon.ico?v20180823
// @match        *://music.163.com/*
// @require      https://cdn.jsdelivr.net/npm/[email protected]/dist/vue.global.prod.js
// @require      data:application/javascript,%3Bwindow.Vue%3DVue%3B
// @require      https://cdn.jsdelivr.net/npm/[email protected]/dist/index.full.min.js
// @resource     element-plus/dist/index.css  https://cdn.jsdelivr.net/npm/[email protected]/dist/index.css
// @connect      www.softrr.cn
// @connect      music.163.com
// @connect      music.163.com
// @grant        GM_addStyle
// @grant        GM_download
// @grant        GM_getResourceText
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @noframes
// ==/UserScript==

(t=>{if(typeof GM_addStyle=="function"){GM_addStyle(t);return}const e=document.createElement("style");e.textContent=t,document.head.append(e)})(" :root{font-family:Inter,Avenir,Helvetica,Arial,sans-serif;font-size:16px;line-height:24px;font-weight:400;color-scheme:light dark;color:#ffffffde;background-color:#242424;font-synthesis:none;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;-webkit-text-size-adjust:100%}a{font-weight:500;color:#646cff;text-decoration:inherit}a:hover{color:#535bf2}body{margin:0;place-items:center;min-width:320px;min-height:100vh}h1{font-size:3.2em;line-height:1.1}button{border-radius:8px;border:1px solid transparent;padding:.6em 1.2em;font-size:1em;font-weight:500;font-family:inherit;background-color:#1a1a1a;cursor:pointer;transition:border-color .25s}button:hover{border-color:#646cff}button:focus,button:focus-visible{outline:4px auto -webkit-focus-ring-color}.card{padding:2em}@media (prefers-color-scheme: light){:root{color:#213547;background-color:#fff}a:hover{color:#747bff}button{background-color:#f9f9f9}}.modal-wrapper[data-v-eb552d62]{position:fixed;top:0;left:0;width:100%;height:100%;background-color:#00000080;margin-top:0;display:flex;justify-content:center;align-items:center;z-index:999}.modal[data-v-eb552d62]{background-color:#fff;padding:20px;border-radius:5px}.header[data-v-eb552d62]{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px}.header h2[data-v-eb552d62]{margin:0;font-size:20px;font-weight:700}.header button[data-v-eb552d62]{border:none;background-color:transparent;font-size:20px;cursor:pointer}.content[data-v-eb552d62]{max-height:400px;overflow:auto;font-size:16px;display:flex;justify-content:space-between}.content .produce[data-v-eb552d62]{flex:60%}.content .produce p[data-v-eb552d62]{margin-top:15px}.content .produce .ipt[data-v-eb552d62]{margin-top:15px;height:30px;border-radius:5px;padding-left:10px}.content .img[data-v-eb552d62]{flex:35%;height:180px;display:flex;align-items:center;justify-content:center}.content .img img[data-v-eb552d62]{width:180px}input[data-v-eb552d62]::-webkit-input-placeholder{color:#aab2bd;font-size:14px;padding-left:5px}.copy[data-v-3070dc36]{width:200px;height:200px;position:fixed;right:10px;top:120px}.copy .btngroup[data-v-3070dc36]{display:flex;flex-direction:column;justify-content:center;align-items:center}.copy .btngroup .lyric[data-v-3070dc36]{display:flex;align-items:center;justify-content:center;flex-wrap:wrap;width:80px;height:40px;border-radius:10%;font-size:14px;color:#fff;background-color:#07031c;cursor:pointer;margin-bottom:10px}.copy .btngroup .down[data-v-3070dc36]{display:flex;align-items:center;justify-content:center;width:80px;height:40px;border-radius:10%;font-size:14px;color:#fff;background-color:red;cursor:pointer}.copy .btngroup .down[data-v-3070dc36]:hover{background-color:#00ff48}.copy .btngroup .lyric[data-v-3070dc36]:hover{background-color:#933814!important} ");

(function (vue, elementPlus) {
  'use strict';

  var _GM_download = /* @__PURE__ */ (() => typeof GM_download != "undefined" ? GM_download : void 0)();
  var _GM_xmlhttpRequest = /* @__PURE__ */ (() => typeof GM_xmlhttpRequest != "undefined" ? GM_xmlhttpRequest : void 0)();
  const _export_sfc = (sfc, props) => {
    const target = sfc.__vccOpts || sfc;
    for (const [key2, val] of props) {
      target[key2] = val;
    }
    return target;
  };
  const _withScopeId = (n) => (vue.pushScopeId("data-v-eb552d62"), n = n(), vue.popScopeId(), n);
  const _hoisted_1$1 = { class: "modal" };
  const _hoisted_2 = { class: "header" };
  const _hoisted_3 = { class: "content" };
  const _hoisted_4 = { class: "produce" };
  const _hoisted_5 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("p", null, "1、扫描右侧公众号，点击关注！", -1));
  const _hoisted_6 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("p", null, "2、在软件爬取者后台回复：验证码", -1));
  const _hoisted_7 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("p", null, "3、在下方输入框输入获取的验证码后回车", -1));
  const _hoisted_8 = /* @__PURE__ */ _withScopeId(() => /* @__PURE__ */ vue.createElementVNode("div", { class: "img" }, [
    /* @__PURE__ */ vue.createElementVNode("img", {
      src: "https://www.softrr.cn/assets/pqz-daa4b840.jpg",
      alt: ""
    })
  ], -1));
  const _sfc_main$1 = {
    __name: "Model",
    props: {
      title: {
        type: String,
        required: true
      },
      code: {
        type: Number
      }
    },
    setup(__props, { expose: __expose }) {
      const props = __props;
      const visible = vue.ref(false);
      const openModal = () => {
        visible.value = true;
      };
      const closeModal = () => {
        visible.value = false;
      };
      __expose({
        visible,
        openModal,
        closeModal
      });
      const codeValue = vue.ref();
      const enterCode = () => {
        if (codeValue.value == props.code) {
          localStorage.setItem("code", codeValue.value);
          visible.value = false;
          alert("验证成功，请再次点击解析！");
          codeValue.value = "";
        } else {
          alert("验证码错误，请重新输入！");
          codeValue.value = "";
        }
      };
      return (_ctx, _cache) => {
        return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
          class: "modal-wrapper",
          onClick: vue.withModifiers(closeModal, ["self"])
        }, [
          vue.createElementVNode("div", _hoisted_1$1, [
            vue.createElementVNode("div", _hoisted_2, [
              vue.createElementVNode("h2", null, vue.toDisplayString(__props.title), 1),
              vue.createElementVNode("button", { onClick: closeModal }, "X")
            ]),
            vue.createElementVNode("div", _hoisted_3, [
              vue.createElementVNode("div", _hoisted_4, [
                _hoisted_5,
                _hoisted_6,
                _hoisted_7,
                vue.withDirectives(vue.createElementVNode("input", {
                  class: "ipt",
                  type: "text",
                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => codeValue.value = $event),
                  onKeydown: vue.withKeys(enterCode, ["enter"]),
                  placeholder: "请输入验证码后按回车"
                }, null, 544), [
                  [vue.vModelText, codeValue.value]
                ])
              ]),
              _hoisted_8
            ])
          ])
        ], 512)), [
          [vue.vShow, visible.value]
        ]);
      };
    }
  };
  const Model = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-eb552d62"]]);
  var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
  function getDefaultExportFromCjs(x) {
    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
  }
  function getAugmentedNamespace(n) {
    if (n.__esModule)
      return n;
    var f = n.default;
    if (typeof f == "function") {
      var a2 = function a3() {
        if (this instanceof a3) {
          return Reflect.construct(f, arguments, this.constructor);
        }
        return f.apply(this, arguments);
      };
      a2.prototype = f.prototype;
    } else
      a2 = {};
    Object.defineProperty(a2, "__esModule", { value: true });
    Object.keys(n).forEach(function(k) {
      var d2 = Object.getOwnPropertyDescriptor(n, k);
      Object.defineProperty(a2, k, d2.get ? d2 : {
        enumerable: true,
        get: function() {
          return n[k];
        }
      });
    });
    return a2;
  }
  var hasOwn = Object.prototype.hasOwnProperty;
  var toStr = Object.prototype.toString;
  var defineProperty = Object.defineProperty;
  var gOPD = Object.getOwnPropertyDescriptor;
  var isArray = function isArray2(arr) {
    if (typeof Array.isArray === "function") {
      return Array.isArray(arr);
    }
    return toStr.call(arr) === "[object Array]";
  };
  var isPlainObject = function isPlainObject2(obj) {
    if (!obj || toStr.call(obj) !== "[object Object]") {
      return false;
    }
    var hasOwnConstructor = hasOwn.call(obj, "constructor");
    var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, "isPrototypeOf");
    if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
      return false;
    }
    var key2;
    for (key2 in obj) {
    }
    return typeof key2 === "undefined" || hasOwn.call(obj, key2);
  };
  var setProperty = function setProperty2(target, options) {
    if (defineProperty && options.name === "__proto__") {
      defineProperty(target, options.name, {
        enumerable: true,
        configurable: true,
        value: options.newValue,
        writable: true
      });
    } else {
      target[options.name] = options.newValue;
    }
  };
  var getProperty = function getProperty2(obj, name) {
    if (name === "__proto__") {
      if (!hasOwn.call(obj, name)) {
        return void 0;
      } else if (gOPD) {
        return gOPD(obj, name).value;
      }
    }
    return obj[name];
  };
  var extend$1 = function extend() {
    var options, name, src, copy2, copyIsArray, clone;
    var target = arguments[0];
    var i2 = 1;
    var length = arguments.length;
    var deep = false;
    if (typeof target === "boolean") {
      deep = target;
      target = arguments[1] || {};
      i2 = 2;
    }
    if (target == null || typeof target !== "object" && typeof target !== "function") {
      target = {};
    }
    for (; i2 < length; ++i2) {
      options = arguments[i2];
      if (options != null) {
        for (name in options) {
          src = getProperty(target, name);
          copy2 = getProperty(options, name);
          if (target !== copy2) {
            if (deep && copy2 && (isPlainObject(copy2) || (copyIsArray = isArray(copy2)))) {
              if (copyIsArray) {
                copyIsArray = false;
                clone = src && isArray(src) ? src : [];
              } else {
                clone = src && isPlainObject(src) ? src : {};
              }
              setProperty(target, { name, newValue: extend(deep, clone, copy2) });
            } else if (typeof copy2 !== "undefined") {
              setProperty(target, { name, newValue: copy2 });
            }
          }
        }
      }
    }
    return target;
  };
  var cookies$1 = {};
  var cookie = {};
  const __viteBrowserExternal = {};
  const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    default: __viteBrowserExternal
  }, Symbol.toStringTag, { value: "Module" }));
  const require$$0$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
  var pubsuffixPsl = {};
  var psl$1 = {};
  const maxInt = 2147483647;
  const base = 36;
  const tMin = 1;
  const tMax = 26;
  const skew = 38;
  const damp = 700;
  const initialBias = 72;
  const initialN = 128;
  const delimiter = "-";
  const regexPunycode = /^xn--/;
  const regexNonASCII = /[^\0-\x7F]/;
  const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
  const errors$2 = {
    "overflow": "Overflow: input needs wider integers to process",
    "not-basic": "Illegal input >= 0x80 (not a basic code point)",
    "invalid-input": "Invalid input"
  };
  const baseMinusTMin = base - tMin;
  const floor = Math.floor;
  const stringFromCharCode = String.fromCharCode;
  function error$1(type2) {
    throw new RangeError(errors$2[type2]);
  }
  function map(array, callback) {
    const result2 = [];
    let length = array.length;
    while (length--) {
      result2[length] = callback(array[length]);
    }
    return result2;
  }
  function mapDomain(domain, callback) {
    const parts = domain.split("@");
    let result2 = "";
    if (parts.length > 1) {
      result2 = parts[0] + "@";
      domain = parts[1];
    }
    domain = domain.replace(regexSeparators, ".");
    const labels = domain.split(".");
    const encoded = map(labels, callback).join(".");
    return result2 + encoded;
  }
  function ucs2decode(string) {
    const output = [];
    let counter = 0;
    const length = string.length;
    while (counter < length) {
      const value = string.charCodeAt(counter++);
      if (value >= 55296 && value <= 56319 && counter < length) {
        const extra = string.charCodeAt(counter++);
        if ((extra & 64512) == 56320) {
          output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
        } else {
          output.push(value);
          counter--;
        }
      } else {
        output.push(value);
      }
    }
    return output;
  }
  const ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
  const basicToDigit = function(codePoint) {
    if (codePoint >= 48 && codePoint < 58) {
      return 26 + (codePoint - 48);
    }
    if (codePoint >= 65 && codePoint < 91) {
      return codePoint - 65;
    }
    if (codePoint >= 97 && codePoint < 123) {
      return codePoint - 97;
    }
    return base;
  };
  const digitToBasic = function(digit2, flag) {
    return digit2 + 22 + 75 * (digit2 < 26) - ((flag != 0) << 5);
  };
  const adapt = function(delta, numPoints, firstTime) {
    let k = 0;
    delta = firstTime ? floor(delta / damp) : delta >> 1;
    delta += floor(delta / numPoints);
    for (; delta > baseMinusTMin * tMax >> 1; k += base) {
      delta = floor(delta / baseMinusTMin);
    }
    return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
  };
  const decode = function(input) {
    const output = [];
    const inputLength = input.length;
    let i2 = 0;
    let n = initialN;
    let bias = initialBias;
    let basic = input.lastIndexOf(delimiter);
    if (basic < 0) {
      basic = 0;
    }
    for (let j2 = 0; j2 < basic; ++j2) {
      if (input.charCodeAt(j2) >= 128) {
        error$1("not-basic");
      }
      output.push(input.charCodeAt(j2));
    }
    for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
      const oldi = i2;
      for (let w = 1, k = base; ; k += base) {
        if (index >= inputLength) {
          error$1("invalid-input");
        }
        const digit2 = basicToDigit(input.charCodeAt(index++));
        if (digit2 >= base) {
          error$1("invalid-input");
        }
        if (digit2 > floor((maxInt - i2) / w)) {
          error$1("overflow");
        }
        i2 += digit2 * w;
        const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
        if (digit2 < t) {
          break;
        }
        const baseMinusT = base - t;
        if (w > floor(maxInt / baseMinusT)) {
          error$1("overflow");
        }
        w *= baseMinusT;
      }
      const out = output.length + 1;
      bias = adapt(i2 - oldi, out, oldi == 0);
      if (floor(i2 / out) > maxInt - n) {
        error$1("overflow");
      }
      n += floor(i2 / out);
      i2 %= out;
      output.splice(i2++, 0, n);
    }
    return String.fromCodePoint(...output);
  };
  const encode = function(input) {
    const output = [];
    input = ucs2decode(input);
    const inputLength = input.length;
    let n = initialN;
    let delta = 0;
    let bias = initialBias;
    for (const currentValue of input) {
      if (currentValue < 128) {
        output.push(stringFromCharCode(currentValue));
      }
    }
    const basicLength = output.length;
    let handledCPCount = basicLength;
    if (basicLength) {
      output.push(delimiter);
    }
    while (handledCPCount < inputLength) {
      let m = maxInt;
      for (const currentValue of input) {
        if (currentValue >= n && currentValue < m) {
          m = currentValue;
        }
      }
      const handledCPCountPlusOne = handledCPCount + 1;
      if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
        error$1("overflow");
      }
      delta += (m - n) * handledCPCountPlusOne;
      n = m;
      for (const currentValue of input) {
        if (currentValue < n && ++delta > maxInt) {
          error$1("overflow");
        }
        if (currentValue === n) {
          let q2 = delta;
          for (let k = base; ; k += base) {
            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
            if (q2 < t) {
              break;
            }
            const qMinusT = q2 - t;
            const baseMinusT = base - t;
            output.push(
              stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
            );
            q2 = floor(qMinusT / baseMinusT);
          }
          output.push(stringFromCharCode(digitToBasic(q2, 0)));
          bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
          delta = 0;
          ++handledCPCount;
        }
      }
      ++delta;
      ++n;
    }
    return output.join("");
  };
  const toUnicode = function(input) {
    return mapDomain(input, function(string) {
      return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
    });
  };
  const toASCII = function(input) {
    return mapDomain(input, function(string) {
      return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
    });
  };
  const punycode$1 = {
    /**
     * A string representing the current Punycode.js version number.
     * @memberOf punycode
     * @type String
     */
    "version": "2.3.1",
    /**
     * An object of methods to convert from JavaScript's internal character
     * representation (UCS-2) to Unicode code points, and back.
     * @see <https://mathiasbynens.be/notes/javascript-encoding>
     * @memberOf punycode
     * @type Object
     */
    "ucs2": {
      "decode": ucs2decode,
      "encode": ucs2encode
    },
    "decode": decode,
    "encode": encode,
    "toASCII": toASCII,
    "toUnicode": toUnicode
  };
  const punycode_es6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
    __proto__: null,
    decode,
    default: punycode$1,
    encode,
    toASCII,
    toUnicode,
    ucs2decode,
    ucs2encode
  }, Symbol.toStringTag, { value: "Module" }));
  const require$$8$1 = /* @__PURE__ */ getAugmentedNamespace(punycode_es6);
  const require$$1$1 = [
    "ac",
    "com.ac",
    "edu.ac",
    "gov.ac",
    "net.ac",
    "mil.ac",
    "org.ac",
    "ad",
    "nom.ad",
    "ae",
    "co.ae",
    "net.ae",
    "org.ae",
    "sch.ae",
    "ac.ae",
    "gov.ae",
    "mil.ae",
    "aero",
    "accident-investigation.aero",
    "accident-prevention.aero",
    "aerobatic.aero",
    "aeroclub.aero",
    "aerodrome.aero",
    "agents.aero",
    "aircraft.aero",
    "airline.aero",
    "airport.aero",
    "air-surveillance.aero",
    "airtraffic.aero",
    "air-traffic-control.aero",
    "ambulance.aero",
    "amusement.aero",
    "association.aero",
    "author.aero",
    "ballooning.aero",
    "broker.aero",
    "caa.aero",
    "cargo.aero",
    "catering.aero",
    "certification.aero",
    "championship.aero",
    "charter.aero",
    "civilaviation.aero",
    "club.aero",
    "conference.aero",
    "consultant.aero",
    "consulting.aero",
    "control.aero",
    "council.aero",
    "crew.aero",
    "design.aero",
    "dgca.aero",
    "educator.aero",
    "emergency.aero",
    "engine.aero",
    "engineer.aero",
    "entertainment.aero",
    "equipment.aero",
    "exchange.aero",
    "express.aero",
    "federation.aero",
    "flight.aero",
    "fuel.aero",
    "gliding.aero",
    "government.aero",
    "groundhandling.aero",
    "group.aero",
    "hanggliding.aero",
    "homebuilt.aero",
    "insurance.aero",
    "journal.aero",
    "journalist.aero",
    "leasing.aero",
    "logistics.aero",
    "magazine.aero",
    "maintenance.aero",
    "media.aero",
    "microlight.aero",
    "modelling.aero",
    "navigation.aero",
    "parachuting.aero",
    "paragliding.aero",
    "passenger-association.aero",
    "pilot.aero",
    "press.aero",
    "production.aero",
    "recreation.aero",
    "repbody.aero",
    "res.aero",
    "research.aero",
    "rotorcraft.aero",
    "safety.aero",
    "scientist.aero",
    "services.aero",
    "show.aero",
    "skydiving.aero",
    "software.aero",
    "student.aero",
    "trader.aero",
    "trading.aero",
    "trainer.aero",
    "union.aero",
    "workinggroup.aero",
    "works.aero",
    "af",
    "gov.af",
    "com.af",
    "org.af",
    "net.af",
    "edu.af",
    "ag",
    "com.ag",
    "org.ag",
    "net.ag",
    "co.ag",
    "nom.ag",
    "ai",
    "off.ai",
    "com.ai",
    "net.ai",
    "org.ai",
    "al",
    "com.al",
    "edu.al",
    "gov.al",
    "mil.al",
    "net.al",
    "org.al",
    "am",
    "co.am",
    "com.am",
    "commune.am",
    "net.am",
    "org.am",
    "ao",
    "ed.ao",
    "gv.ao",
    "og.ao",
    "co.ao",
    "pb.ao",
    "it.ao",
    "aq",
    "ar",
    "bet.ar",
    "com.ar",
    "coop.ar",
    "edu.ar",
    "gob.ar",
    "gov.ar",
    "int.ar",
    "mil.ar",
    "musica.ar",
    "mutual.ar",
    "net.ar",
    "org.ar",
    "senasa.ar",
    "tur.ar",
    "arpa",
    "e164.arpa",
    "in-addr.arpa",
    "ip6.arpa",
    "iris.arpa",
    "uri.arpa",
    "urn.arpa",
    "as",
    "gov.as",
    "asia",
    "at",
    "ac.at",
    "co.at",
    "gv.at",
    "or.at",
    "sth.ac.at",
    "au",
    "com.au",
    "net.au",
    "org.au",
    "edu.au",
    "gov.au",
    "asn.au",
    "id.au",
    "info.au",
    "conf.au",
    "oz.au",
    "act.au",
    "nsw.au",
    "nt.au",
    "qld.au",
    "sa.au",
    "tas.au",
    "vic.au",
    "wa.au",
    "act.edu.au",
    "catholic.edu.au",
    "nsw.edu.au",
    "nt.edu.au",
    "qld.edu.au",
    "sa.edu.au",
    "tas.edu.au",
    "vic.edu.au",
    "wa.edu.au",
    "qld.gov.au",
    "sa.gov.au",
    "tas.gov.au",
    "vic.gov.au",
    "wa.gov.au",
    "schools.nsw.edu.au",
    "aw",
    "com.aw",
    "ax",
    "az",
    "com.az",
    "net.az",
    "int.az",
    "gov.az",
    "org.az",
    "edu.az",
    "info.az",
    "pp.az",
    "mil.az",
    "name.az",
    "pro.az",
    "biz.az",
    "ba",
    "com.ba",
    "edu.ba",
    "gov.ba",
    "mil.ba",
    "net.ba",
    "org.ba",
    "bb",
    "biz.bb",
    "co.bb",
    "com.bb",
    "edu.bb",
    "gov.bb",
    "info.bb",
    "net.bb",
    "org.bb",
    "store.bb",
    "tv.bb",
    "*.bd",
    "be",
    "ac.be",
    "bf",
    "gov.bf",
    "bg",
    "a.bg",
    "b.bg",
    "c.bg",
    "d.bg",
    "e.bg",
    "f.bg",
    "g.bg",
    "h.bg",
    "i.bg",
    "j.bg",
    "k.bg",
    "l.bg",
    "m.bg",
    "n.bg",
    "o.bg",
    "p.bg",
    "q.bg",
    "r.bg",
    "s.bg",
    "t.bg",
    "u.bg",
    "v.bg",
    "w.bg",
    "x.bg",
    "y.bg",
    "z.bg",
    "0.bg",
    "1.bg",
    "2.bg",
    "3.bg",
    "4.bg",
    "5.bg",
    "6.bg",
    "7.bg",
    "8.bg",
    "9.bg",
    "bh",
    "com.bh",
    "edu.bh",
    "net.bh",
    "org.bh",
    "gov.bh",
    "bi",
    "co.bi",
    "com.bi",
    "edu.bi",
    "or.bi",
    "org.bi",
    "biz",
    "bj",
    "asso.bj",
    "barreau.bj",
    "gouv.bj",
    "bm",
    "com.bm",
    "edu.bm",
    "gov.bm",
    "net.bm",
    "org.bm",
    "bn",
    "com.bn",
    "edu.bn",
    "gov.bn",
    "net.bn",
    "org.bn",
    "bo",
    "com.bo",
    "edu.bo",
    "gob.bo",
    "int.bo",
    "org.bo",
    "net.bo",
    "mil.bo",
    "tv.bo",
    "web.bo",
    "academia.bo",
    "agro.bo",
    "arte.bo",
    "blog.bo",
    "bolivia.bo",
    "ciencia.bo",
    "cooperativa.bo",
    "democracia.bo",
    "deporte.bo",
    "ecologia.bo",
    "economia.bo",
    "empresa.bo",
    "indigena.bo",
    "industria.bo",
    "info.bo",
    "medicina.bo",
    "movimiento.bo",
    "musica.bo",
    "natural.bo",
    "nombre.bo",
    "noticias.bo",
    "patria.bo",
    "politica.bo",
    "profesional.bo",
    "plurinacional.bo",
    "pueblo.bo",
    "revista.bo",
    "salud.bo",
    "tecnologia.bo",
    "tksat.bo",
    "transporte.bo",
    "wiki.bo",
    "br",
    "9guacu.br",
    "abc.br",
    "adm.br",
    "adv.br",
    "agr.br",
    "aju.br",
    "am.br",
    "anani.br",
    "aparecida.br",
    "app.br",
    "arq.br",
    "art.br",
    "ato.br",
    "b.br",
    "barueri.br",
    "belem.br",
    "bhz.br",
    "bib.br",
    "bio.br",
    "blog.br",
    "bmd.br",
    "boavista.br",
    "bsb.br",
    "campinagrande.br",
    "campinas.br",
    "caxias.br",
    "cim.br",
    "cng.br",
    "cnt.br",
    "com.br",
    "contagem.br",
    "coop.br",
    "coz.br",
    "cri.br",
    "cuiaba.br",
    "curitiba.br",
    "def.br",
    "des.br",
    "det.br",
    "dev.br",
    "ecn.br",
    "eco.br",
    "edu.br",
    "emp.br",
    "enf.br",
    "eng.br",
    "esp.br",
    "etc.br",
    "eti.br",
    "far.br",
    "feira.br",
    "flog.br",
    "floripa.br",
    "fm.br",
    "fnd.br",
    "fortal.br",
    "fot.br",
    "foz.br",
    "fst.br",
    "g12.br",
    "geo.br",
    "ggf.br",
    "goiania.br",
    "gov.br",
    "ac.gov.br",
    "al.gov.br",
    "am.gov.br",
    "ap.gov.br",
    "ba.gov.br",
    "ce.gov.br",
    "df.gov.br",
    "es.gov.br",
    "go.gov.br",
    "ma.gov.br",
    "mg.gov.br",
    "ms.gov.br",
    "mt.gov.br",
    "pa.gov.br",
    "pb.gov.br",
    "pe.gov.br",
    "pi.gov.br",
    "pr.gov.br",
    "rj.gov.br",
    "rn.gov.br",
    "ro.gov.br",
    "rr.gov.br",
    "rs.gov.br",
    "sc.gov.br",
    "se.gov.br",
    "sp.gov.br",
    "to.gov.br",
    "gru.br",
    "imb.br",
    "ind.br",
    "inf.br",
    "jab.br",
    "jampa.br",
    "jdf.br",
    "joinville.br",
    "jor.br",
    "jus.br",
    "leg.br",
    "lel.br",
    "log.br",
    "londrina.br",
    "macapa.br",
    "maceio.br",
    "manaus.br",
    "maringa.br",
    "mat.br",
    "med.br",
    "mil.br",
    "morena.br",
    "mp.br",
    "mus.br",
    "natal.br",
    "net.br",
    "niteroi.br",
    "*.nom.br",
    "not.br",
    "ntr.br",
    "odo.br",
    "ong.br",
    "org.br",
    "osasco.br",
    "palmas.br",
    "poa.br",
    "ppg.br",
    "pro.br",
    "psc.br",
    "psi.br",
    "pvh.br",
    "qsl.br",
    "radio.br",
    "rec.br",
    "recife.br",
    "rep.br",
    "ribeirao.br",
    "rio.br",
    "riobranco.br",
    "riopreto.br",
    "salvador.br",
    "sampa.br",
    "santamaria.br",
    "santoandre.br",
    "saobernardo.br",
    "saogonca.br",
    "seg.br",
    "sjc.br",
    "slg.br",
    "slz.br",
    "sorocaba.br",
    "srv.br",
    "taxi.br",
    "tc.br",
    "tec.br",
    "teo.br",
    "the.br",
    "tmp.br",
    "trd.br",
    "tur.br",
    "tv.br",
    "udi.br",
    "vet.br",
    "vix.br",
    "vlog.br",
    "wiki.br",
    "zlg.br",
    "bs",
    "com.bs",
    "net.bs",
    "org.bs",
    "edu.bs",
    "gov.bs",
    "bt",
    "com.bt",
    "edu.bt",
    "gov.bt",
    "net.bt",
    "org.bt",
    "bv",
    "bw",
    "co.bw",
    "org.bw",
    "by",
    "gov.by",
    "mil.by",
    "com.by",
    "of.by",
    "bz",
    "com.bz",
    "net.bz",
    "org.bz",
    "edu.bz",
    "gov.bz",
    "ca",
    "ab.ca",
    "bc.ca",
    "mb.ca",
    "nb.ca",
    "nf.ca",
    "nl.ca",
    "ns.ca",
    "nt.ca",
    "nu.ca",
    "on.ca",
    "pe.ca",
    "qc.ca",
    "sk.ca",
    "yk.ca",
    "gc.ca",
    "cat",
    "cc",
    "cd",
    "gov.cd",
    "cf",
    "cg",
    "ch",
    "ci",
    "org.ci",
    "or.ci",
    "com.ci",
    "co.ci",
    "edu.ci",
    "ed.ci",
    "ac.ci",
    "net.ci",
    "go.ci",
    "asso.ci",
    "aéroport.ci",
    "int.ci",
    "presse.ci",
    "md.ci",
    "gouv.ci",
    "*.ck",
    "!www.ck",
    "cl",
    "co.cl",
    "gob.cl",
    "gov.cl",
    "mil.cl",
    "cm",
    "co.cm",
    "com.cm",
    "gov.cm",
    "net.cm",
    "cn",
    "ac.cn",
    "com.cn",
    "edu.cn",
    "gov.cn",
    "net.cn",
    "org.cn",
    "mil.cn",
    "公司.cn",
    "网络.cn",
    "網絡.cn",
    "ah.cn",
    "bj.cn",
    "cq.cn",
    "fj.cn",
    "gd.cn",
    "gs.cn",
    "gz.cn",
    "gx.cn",
    "ha.cn",
    "hb.cn",
    "he.cn",
    "hi.cn",
    "hl.cn",
    "hn.cn",
    "jl.cn",
    "js.cn",
    "jx.cn",
    "ln.cn",
    "nm.cn",
    "nx.cn",
    "qh.cn",
    "sc.cn",
    "sd.cn",
    "sh.cn",
    "sn.cn",
    "sx.cn",
    "tj.cn",
    "xj.cn",
    "xz.cn",
    "yn.cn",
    "zj.cn",
    "hk.cn",
    "mo.cn",
    "tw.cn",
    "co",
    "arts.co",
    "com.co",
    "edu.co",
    "firm.co",
    "gov.co",
    "info.co",
    "int.co",
    "mil.co",
    "net.co",
    "nom.co",
    "org.co",
    "rec.co",
    "web.co",
    "com",
    "coop",
    "cr",
    "ac.cr",
    "co.cr",
    "ed.cr",
    "fi.cr",
    "go.cr",
    "or.cr",
    "sa.cr",
    "cu",
    "com.cu",
    "edu.cu",
    "org.cu",
    "net.cu",
    "gov.cu",
    "inf.cu",
    "cv",
    "com.cv",
    "edu.cv",
    "int.cv",
    "nome.cv",
    "org.cv",
    "cw",
    "com.cw",
    "edu.cw",
    "net.cw",
    "org.cw",
    "cx",
    "gov.cx",
    "cy",
    "ac.cy",
    "biz.cy",
    "com.cy",
    "ekloges.cy",
    "gov.cy",
    "ltd.cy",
    "mil.cy",
    "net.cy",
    "org.cy",
    "press.cy",
    "pro.cy",
    "tm.cy",
    "cz",
    "de",
    "dj",
    "dk",
    "dm",
    "com.dm",
    "net.dm",
    "org.dm",
    "edu.dm",
    "gov.dm",
    "do",
    "art.do",
    "com.do",
    "edu.do",
    "gob.do",
    "gov.do",
    "mil.do",
    "net.do",
    "org.do",
    "sld.do",
    "web.do",
    "dz",
    "art.dz",
    "asso.dz",
    "com.dz",
    "edu.dz",
    "gov.dz",
    "org.dz",
    "net.dz",
    "pol.dz",
    "soc.dz",
    "tm.dz",
    "ec",
    "com.ec",
    "info.ec",
    "net.ec",
    "fin.ec",
    "k12.ec",
    "med.ec",
    "pro.ec",
    "org.ec",
    "edu.ec",
    "gov.ec",
    "gob.ec",
    "mil.ec",
    "edu",
    "ee",
    "edu.ee",
    "gov.ee",
    "riik.ee",
    "lib.ee",
    "med.ee",
    "com.ee",
    "pri.ee",
    "aip.ee",
    "org.ee",
    "fie.ee",
    "eg",
    "com.eg",
    "edu.eg",
    "eun.eg",
    "gov.eg",
    "mil.eg",
    "name.eg",
    "net.eg",
    "org.eg",
    "sci.eg",
    "*.er",
    "es",
    "com.es",
    "nom.es",
    "org.es",
    "gob.es",
    "edu.es",
    "et",
    "com.et",
    "gov.et",
    "org.et",
    "edu.et",
    "biz.et",
    "name.et",
    "info.et",
    "net.et",
    "eu",
    "fi",
    "aland.fi",
    "fj",
    "ac.fj",
    "biz.fj",
    "com.fj",
    "gov.fj",
    "info.fj",
    "mil.fj",
    "name.fj",
    "net.fj",
    "org.fj",
    "pro.fj",
    "*.fk",
    "com.fm",
    "edu.fm",
    "net.fm",
    "org.fm",
    "fm",
    "fo",
    "fr",
    "asso.fr",
    "com.fr",
    "gouv.fr",
    "nom.fr",
    "prd.fr",
    "tm.fr",
    "aeroport.fr",
    "avocat.fr",
    "avoues.fr",
    "cci.fr",
    "chambagri.fr",
    "chirurgiens-dentistes.fr",
    "experts-comptables.fr",
    "geometre-expert.fr",
    "greta.fr",
    "huissier-justice.fr",
    "medecin.fr",
    "notaires.fr",
    "pharmacien.fr",
    "port.fr",
    "veterinaire.fr",
    "ga",
    "gb",
    "edu.gd",
    "gov.gd",
    "gd",
    "ge",
    "com.ge",
    "edu.ge",
    "gov.ge",
    "org.ge",
    "mil.ge",
    "net.ge",
    "pvt.ge",
    "gf",
    "gg",
    "co.gg",
    "net.gg",
    "org.gg",
    "gh",
    "com.gh",
    "edu.gh",
    "gov.gh",
    "org.gh",
    "mil.gh",
    "gi",
    "com.gi",
    "ltd.gi",
    "gov.gi",
    "mod.gi",
    "edu.gi",
    "org.gi",
    "gl",
    "co.gl",
    "com.gl",
    "edu.gl",
    "net.gl",
    "org.gl",
    "gm",
    "gn",
    "ac.gn",
    "com.gn",
    "edu.gn",
    "gov.gn",
    "org.gn",
    "net.gn",
    "gov",
    "gp",
    "com.gp",
    "net.gp",
    "mobi.gp",
    "edu.gp",
    "org.gp",
    "asso.gp",
    "gq",
    "gr",
    "com.gr",
    "edu.gr",
    "net.gr",
    "org.gr",
    "gov.gr",
    "gs",
    "gt",
    "com.gt",
    "edu.gt",
    "gob.gt",
    "ind.gt",
    "mil.gt",
    "net.gt",
    "org.gt",
    "gu",
    "com.gu",
    "edu.gu",
    "gov.gu",
    "guam.gu",
    "info.gu",
    "net.gu",
    "org.gu",
    "web.gu",
    "gw",
    "gy",
    "co.gy",
    "com.gy",
    "edu.gy",
    "gov.gy",
    "net.gy",
    "org.gy",
    "hk",
    "com.hk",
    "edu.hk",
    "gov.hk",
    "idv.hk",
    "net.hk",
    "org.hk",
    "公司.hk",
    "教育.hk",
    "敎育.hk",
    "政府.hk",
    "個人.hk",
    "个��.hk",
    "箇人.hk",
    "網络.hk",
    "网络.hk",
    "组織.hk",
    "網絡.hk",
    "网絡.hk",
    "组织.hk",
    "組織.hk",
    "組织.hk",
    "hm",
    "hn",
    "com.hn",
    "edu.hn",
    "org.hn",
    "net.hn",
    "mil.hn",
    "gob.hn",
    "hr",
    "iz.hr",
    "from.hr",
    "name.hr",
    "com.hr",
    "ht",
    "com.ht",
    "shop.ht",
    "firm.ht",
    "info.ht",
    "adult.ht",
    "net.ht",
    "pro.ht",
    "org.ht",
    "med.ht",
    "art.ht",
    "coop.ht",
    "pol.ht",
    "asso.ht",
    "edu.ht",
    "rel.ht",
    "gouv.ht",
    "perso.ht",
    "hu",
    "co.hu",
    "info.hu",
    "org.hu",
    "priv.hu",
    "sport.hu",
    "tm.hu",
    "2000.hu",
    "agrar.hu",
    "bolt.hu",
    "casino.hu",
    "city.hu",
    "erotica.hu",
    "erotika.hu",
    "film.hu",
    "forum.hu",
    "games.hu",
    "hotel.hu",
    "ingatlan.hu",
    "jogasz.hu",
    "konyvelo.hu",
    "lakas.hu",
    "media.hu",
    "news.hu",
    "reklam.hu",
    "sex.hu",
    "shop.hu",
    "suli.hu",
    "szex.hu",
    "tozsde.hu",
    "utazas.hu",
    "video.hu",
    "id",
    "ac.id",
    "biz.id",
    "co.id",
    "desa.id",
    "go.id",
    "mil.id",
    "my.id",
    "net.id",
    "or.id",
    "ponpes.id",
    "sch.id",
    "web.id",
    "ie",
    "gov.ie",
    "il",
    "ac.il",
    "co.il",
    "gov.il",
    "idf.il",
    "k12.il",
    "muni.il",
    "net.il",
    "org.il",
    "im",
    "ac.im",
    "co.im",
    "com.im",
    "ltd.co.im",
    "net.im",
    "org.im",
    "plc.co.im",
    "tt.im",
    "tv.im",
    "in",
    "co.in",
    "firm.in",
    "net.in",
    "org.in",
    "gen.in",
    "ind.in",
    "nic.in",
    "ac.in",
    "edu.in",
    "res.in",
    "gov.in",
    "mil.in",
    "info",
    "int",
    "eu.int",
    "io",
    "com.io",
    "iq",
    "gov.iq",
    "edu.iq",
    "mil.iq",
    "com.iq",
    "org.iq",
    "net.iq",
    "ir",
    "ac.ir",
    "co.ir",
    "gov.ir",
    "id.ir",
    "net.ir",
    "org.ir",
    "sch.ir",
    "ایران.ir",
    "ايران.ir",
    "is",
    "net.is",
    "com.is",
    "edu.is",
    "gov.is",
    "org.is",
    "int.is",
    "it",
    "gov.it",
    "edu.it",
    "abr.it",
    "abruzzo.it",
    "aosta-valley.it",
    "aostavalley.it",
    "bas.it",
    "basilicata.it",
    "cal.it",
    "calabria.it",
    "cam.it",
    "campania.it",
    "emilia-romagna.it",
    "emiliaromagna.it",
    "emr.it",
    "friuli-v-giulia.it",
    "friuli-ve-giulia.it",
    "friuli-vegiulia.it",
    "friuli-venezia-giulia.it",
    "friuli-veneziagiulia.it",
    "friuli-vgiulia.it",
    "friuliv-giulia.it",
    "friulive-giulia.it",
    "friulivegiulia.it",
    "friulivenezia-giulia.it",
    "friuliveneziagiulia.it",
    "friulivgiulia.it",
    "fvg.it",
    "laz.it",
    "lazio.it",
    "lig.it",
    "liguria.it",
    "lom.it",
    "lombardia.it",
    "lombardy.it",
    "lucania.it",
    "mar.it",
    "marche.it",
    "mol.it",
    "molise.it",
    "piedmont.it",
    "piemonte.it",
    "pmn.it",
    "pug.it",
    "puglia.it",
    "sar.it",
    "sardegna.it",
    "sardinia.it",
    "sic.it",
    "sicilia.it",
    "sicily.it",
    "taa.it",
    "tos.it",
    "toscana.it",
    "trentin-sud-tirol.it",
    "trentin-süd-tirol.it",
    "trentin-sudtirol.it",
    "trentin-südtirol.it",
    "trentin-sued-tirol.it",
    "trentin-suedtirol.it",
    "trentino-a-adige.it",
    "trentino-aadige.it",
    "trentino-alto-adige.it",
    "trentino-altoadige.it",
    "trentino-s-tirol.it",
    "trentino-stirol.it",
    "trentino-sud-tirol.it",
    "trentino-süd-tirol.it",
    "trentino-sudtirol.it",
    "trentino-südtirol.it",
    "trentino-sued-tirol.it",
    "trentino-suedtirol.it",
    "trentino.it",
    "trentinoa-adige.it",
    "trentinoaadige.it",
    "trentinoalto-adige.it",
    "trentinoaltoadige.it",
    "trentinos-tirol.it",
    "trentinostirol.it",
    "trentinosud-tirol.it",
    "trentinosüd-tirol.it",
    "trentinosudtirol.it",
    "trentinosüdtirol.it",
    "trentinosued-tirol.it",
    "trentinosuedtirol.it",
    "trentinsud-tirol.it",
    "trentinsüd-tirol.it",
    "trentinsudtirol.it",
    "trentinsüdtirol.it",
    "trentinsued-tirol.it",
    "trentinsuedtirol.it",
    "tuscany.it",
    "umb.it",
    "umbria.it",
    "val-d-aosta.it",
    "val-daosta.it",
    "vald-aosta.it",
    "valdaosta.it",
    "valle-aosta.it",
    "valle-d-aosta.it",
    "valle-daosta.it",
    "valleaosta.it",
    "valled-aosta.it",
    "valledaosta.it",
    "vallee-aoste.it",
    "vallée-aoste.it",
    "vallee-d-aoste.it",
    "vallée-d-aoste.it",
    "valleeaoste.it",
    "valléeaoste.it",
    "valleedaoste.it",
    "valléedaoste.it",
    "vao.it",
    "vda.it",
    "ven.it",
    "veneto.it",
    "ag.it",
    "agrigento.it",
    "al.it",
    "alessandria.it",
    "alto-adige.it",
    "altoadige.it",
    "an.it",
    "ancona.it",
    "andria-barletta-trani.it",
    "andria-trani-barletta.it",
    "andriabarlettatrani.it",
    "andriatranibarletta.it",
    "ao.it",
    "aosta.it",
    "aoste.it",
    "ap.it",
    "aq.it",
    "aquila.it",
    "ar.it",
    "arezzo.it",
    "ascoli-piceno.it",
    "ascolipiceno.it",
    "asti.it",
    "at.it",
    "av.it",
    "avellino.it",
    "ba.it",
    "balsan-sudtirol.it",
    "balsan-südtirol.it",
    "balsan-suedtirol.it",
    "balsan.it",
    "bari.it",
    "barletta-trani-andria.it",
    "barlettatraniandria.it",
    "belluno.it",
    "benevento.it",
    "bergamo.it",
    "bg.it",
    "bi.it",
    "biella.it",
    "bl.it",
    "bn.it",
    "bo.it",
    "bologna.it",
    "bolzano-altoadige.it",
    "bolzano.it",
    "bozen-sudtirol.it",
    "bozen-südtirol.it",
    "bozen-suedtirol.it",
    "bozen.it",
    "br.it",
    "brescia.it",
    "brindisi.it",
    "bs.it",
    "bt.it",
    "bulsan-sudtirol.it",
    "bulsan-südtirol.it",
    "bulsan-suedtirol.it",
    "bulsan.it",
    "bz.it",
    "ca.it",
    "cagliari.it",
    "caltanissetta.it",
    "campidano-medio.it",
    "campidanomedio.it",
    "campobasso.it",
    "carbonia-iglesias.it",
    "carboniaiglesias.it",
    "carrara-massa.it",
    "carraramassa.it",
    "caserta.it",
    "catania.it",
    "catanzaro.it",
    "cb.it",
    "ce.it",
    "cesena-forli.it",
    "cesena-forlì.it",
    "cesenaforli.it",
    "cesenaforlì.it",
    "ch.it",
    "chieti.it",
    "ci.it",
    "cl.it",
    "cn.it",
    "co.it",
    "como.it",
    "cosenza.it",
    "cr.it",
    "cremona.it",
    "crotone.it",
    "cs.it",
    "ct.it",
    "cuneo.it",
    "cz.it",
    "dell-ogliastra.it",
    "dellogliastra.it",
    "en.it",
    "enna.it",
    "fc.it",
    "fe.it",
    "fermo.it",
    "ferrara.it",
    "fg.it",
    "fi.it",
    "firenze.it",
    "florence.it",
    "fm.it",
    "foggia.it",
    "forli-cesena.it",
    "forlì-cesena.it",
    "forlicesena.it",
    "forlìcesena.it",
    "fr.it",
    "frosinone.it",
    "ge.it",
    "genoa.it",
    "genova.it",
    "go.it",
    "gorizia.it",
    "gr.it",
    "grosseto.it",
    "iglesias-carbonia.it",
    "iglesiascarbonia.it",
    "im.it",
    "imperia.it",
    "is.it",
    "isernia.it",
    "kr.it",
    "la-spezia.it",
    "laquila.it",
    "laspezia.it",
    "latina.it",
    "lc.it",
    "le.it",
    "lecce.it",
    "lecco.it",
    "li.it",
    "livorno.it",
    "lo.it",
    "lodi.it",
    "lt.it",
    "lu.it",
    "lucca.it",
    "macerata.it",
    "mantova.it",
    "massa-carrara.it",
    "massacarrara.it",
    "matera.it",
    "mb.it",
    "mc.it",
    "me.it",
    "medio-campidano.it",
    "mediocampidano.it",
    "messina.it",
    "mi.it",
    "milan.it",
    "milano.it",
    "mn.it",
    "mo.it",
    "modena.it",
    "monza-brianza.it",
    "monza-e-della-brianza.it",
    "monza.it",
    "monzabrianza.it",
    "monzaebrianza.it",
    "monzaedellabrianza.it",
    "ms.it",
    "mt.it",
    "na.it",
    "naples.it",
    "napoli.it",
    "no.it",
    "novara.it",
    "nu.it",
    "nuoro.it",
    "og.it",
    "ogliastra.it",
    "olbia-tempio.it",
    "olbiatempio.it",
    "or.it",
    "oristano.it",
    "ot.it",
    "pa.it",
    "padova.it",
    "padua.it",
    "palermo.it",
    "parma.it",
    "pavia.it",
    "pc.it",
    "pd.it",
    "pe.it",
    "perugia.it",
    "pesaro-urbino.it",
    "pesarourbino.it",
    "pescara.it",
    "pg.it",
    "pi.it",
    "piacenza.it",
    "pisa.it",
    "pistoia.it",
    "pn.it",
    "po.it",
    "pordenone.it",
    "potenza.it",
    "pr.it",
    "prato.it",
    "pt.it",
    "pu.it",
    "pv.it",
    "pz.it",
    "ra.it",
    "ragusa.it",
    "ravenna.it",
    "rc.it",
    "re.it",
    "reggio-calabria.it",
    "reggio-emilia.it",
    "reggiocalabria.it",
    "reggioemilia.it",
    "rg.it",
    "ri.it",
    "rieti.it",
    "rimini.it",
    "rm.it",
    "rn.it",
    "ro.it",
    "roma.it",
    "rome.it",
    "rovigo.it",
    "sa.it",
    "salerno.it",
    "sassari.it",
    "savona.it",
    "si.it",
    "siena.it",
    "siracusa.it",
    "so.it",
    "sondrio.it",
    "sp.it",
    "sr.it",
    "ss.it",
    "suedtirol.it",
    "südtirol.it",
    "sv.it",
    "ta.it",
    "taranto.it",
    "te.it",
    "tempio-olbia.it",
    "tempioolbia.it",
    "teramo.it",
    "terni.it",
    "tn.it",
    "to.it",
    "torino.it",
    "tp.it",
    "tr.it",
    "trani-andria-barletta.it",
    "trani-barletta-andria.it",
    "traniandriabarletta.it",
    "tranibarlettaandria.it",
    "trapani.it",
    "trento.it",
    "treviso.it",
    "trieste.it",
    "ts.it",
    "turin.it",
    "tv.it",
    "ud.it",
    "udine.it",
    "urbino-pesaro.it",
    "urbinopesaro.it",
    "va.it",
    "varese.it",
    "vb.it",
    "vc.it",
    "ve.it",
    "venezia.it",
    "venice.it",
    "verbania.it",
    "vercelli.it",
    "verona.it",
    "vi.it",
    "vibo-valentia.it",
    "vibovalentia.it",
    "vicenza.it",
    "viterbo.it",
    "vr.it",
    "vs.it",
    "vt.it",
    "vv.it",
    "je",
    "co.je",
    "net.je",
    "org.je",
    "*.jm",
    "jo",
    "com.jo",
    "org.jo",
    "net.jo",
    "edu.jo",
    "sch.jo",
    "gov.jo",
    "mil.jo",
    "name.jo",
    "jobs",
    "jp",
    "ac.jp",
    "ad.jp",
    "co.jp",
    "ed.jp",
    "go.jp",
    "gr.jp",
    "lg.jp",
    "ne.jp",
    "or.jp",
    "aichi.jp",
    "akita.jp",
    "aomori.jp",
    "chiba.jp",
    "ehime.jp",
    "fukui.jp",
    "fukuoka.jp",
    "fukushima.jp",
    "gifu.jp",
    "gunma.jp",
    "hiroshima.jp",
    "hokkaido.jp",
    "hyogo.jp",
    "ibaraki.jp",
    "ishikawa.jp",
    "iwate.jp",
    "kagawa.jp",
    "kagoshima.jp",
    "kanagawa.jp",
    "kochi.jp",
    "kumamoto.jp",
    "kyoto.jp",
    "mie.jp",
    "miyagi.jp",
    "miyazaki.jp",
    "nagano.jp",
    "nagasaki.jp",
    "nara.jp",
    "niigata.jp",
    "oita.jp",
    "okayama.jp",
    "okinawa.jp",
    "osaka.jp",
    "saga.jp",
    "saitama.jp",
    "shiga.jp",
    "shimane.jp",
    "shizuoka.jp",
    "tochigi.jp",
    "tokushima.jp",
    "tokyo.jp",
    "tottori.jp",
    "toyama.jp",
    "wakayama.jp",
    "yamagata.jp",
    "yamaguchi.jp",
    "yamanashi.jp",
    "栃木.jp",
    "愛知.jp",
    "愛媛.jp",
    "兵庫.jp",
    "熊本.jp",
    "茨城.jp",
    "北海道.jp",
    "千葉.jp",
    "和歌山.jp",
    "長崎.jp",
    "長野.jp",
    "新潟.jp",
    "青森.jp",
    "静岡.jp",
    "東京.jp",
    "石川.jp",
    "埼玉.jp",
    "三重.jp",
    "京都.jp",
    "佐賀.jp",
    "大分.jp",
    "大阪.jp",
    "奈良.jp",
    "宮城.jp",
    "宮崎.jp",
    "富山.jp",
    "山口.jp",
    "山形.jp",
    "山梨.jp",
    "岩手.jp",
    "岐阜.jp",
    "岡山.jp",
    "島根.jp",
    "広島.jp",
    "徳島.jp",
    "沖縄.jp",
    "滋賀.jp",
    "神奈川.jp",
    "福井.jp",
    "福岡.jp",
    "福島.jp",
    "秋田.jp",
    "群馬.jp",
    "香川.jp",
    "高知.jp",
    "鳥取.jp",
    "鹿児島.jp",
    "*.kawasaki.jp",
    "*.kitakyushu.jp",
    "*.kobe.jp",
    "*.nagoya.jp",
    "*.sapporo.jp",
    "*.sendai.jp",
    "*.yokohama.jp",
    "!city.kawasaki.jp",
    "!city.kitakyushu.jp",
    "!city.kobe.jp",
    "!city.nagoya.jp",
    "!city.sapporo.jp",
    "!city.sendai.jp",
    "!city.yokohama.jp",
    "aisai.aichi.jp",
    "ama.aichi.jp",
    "anjo.aichi.jp",
    "asuke.aichi.jp",
    "chiryu.aichi.jp",
    "chita.aichi.jp",
    "fuso.aichi.jp",
    "gamagori.aichi.jp",
    "handa.aichi.jp",
    "hazu.aichi.jp",
    "hekinan.aichi.jp",
    "higashiura.aichi.jp",
    "ichinomiya.aichi.jp",
    "inazawa.aichi.jp",
    "inuyama.aichi.jp",
    "isshiki.aichi.jp",
    "iwakura.aichi.jp",
    "kanie.aichi.jp",
    "kariya.aichi.jp",
    "kasugai.aichi.jp",
    "kira.aichi.jp",
    "kiyosu.aichi.jp",
    "komaki.aichi.jp",
    "konan.aichi.jp",
    "kota.aichi.jp",
    "mihama.aichi.jp",
    "miyoshi.aichi.jp",
    "nishio.aichi.jp",
    "nisshin.aichi.jp",
    "obu.aichi.jp",
    "oguchi.aichi.jp",
    "oharu.aichi.jp",
    "okazaki.aichi.jp",
    "owariasahi.aichi.jp",
    "seto.aichi.jp",
    "shikatsu.aichi.jp",
    "shinshiro.aichi.jp",
    "shitara.aichi.jp",
    "tahara.aichi.jp",
    "takahama.aichi.jp",
    "tobishima.aichi.jp",
    "toei.aichi.jp",
    "togo.aichi.jp",
    "tokai.aichi.jp",
    "tokoname.aichi.jp",
    "toyoake.aichi.jp",
    "toyohashi.aichi.jp",
    "toyokawa.aichi.jp",
    "toyone.aichi.jp",
    "toyota.aichi.jp",
    "tsushima.aichi.jp",
    "yatomi.aichi.jp",
    "akita.akita.jp",
    "daisen.akita.jp",
    "fujisato.akita.jp",
    "gojome.akita.jp",
    "hachirogata.akita.jp",
    "happou.akita.jp",
    "higashinaruse.akita.jp",
    "honjo.akita.jp",
    "honjyo.akita.jp",
    "ikawa.akita.jp",
    "kamikoani.akita.jp",
    "kamioka.akita.jp",
    "katagami.akita.jp",
    "kazuno.akita.jp",
    "kitaakita.akita.jp",
    "kosaka.akita.jp",
    "kyowa.akita.jp",
    "misato.akita.jp",
    "mitane.akita.jp",
    "moriyoshi.akita.jp",
    "nikaho.akita.jp",
    "noshiro.akita.jp",
    "odate.akita.jp",
    "oga.akita.jp",
    "ogata.akita.jp",
    "semboku.akita.jp",
    "yokote.akita.jp",
    "yurihonjo.akita.jp",
    "aomori.aomori.jp",
    "gonohe.aomori.jp",
    "hachinohe.aomori.jp",
    "hashikami.aomori.jp",
    "hiranai.aomori.jp",
    "hirosaki.aomori.jp",
    "itayanagi.aomori.jp",
    "kuroishi.aomori.jp",
    "misawa.aomori.jp",
    "mutsu.aomori.jp",
    "nakadomari.aomori.jp",
    "noheji.aomori.jp",
    "oirase.aomori.jp",
    "owani.aomori.jp",
    "rokunohe.aomori.jp",
    "sannohe.aomori.jp",
    "shichinohe.aomori.jp",
    "shingo.aomori.jp",
    "takko.aomori.jp",
    "towada.aomori.jp",
    "tsugaru.aomori.jp",
    "tsuruta.aomori.jp",
    "abiko.chiba.jp",
    "asahi.chiba.jp",
    "chonan.chiba.jp",
    "chosei.chiba.jp",
    "choshi.chiba.jp",
    "chuo.chiba.jp",
    "funabashi.chiba.jp",
    "futtsu.chiba.jp",
    "hanamigawa.chiba.jp",
    "ichihara.chiba.jp",
    "ichikawa.chiba.jp",
    "ichinomiya.chiba.jp",
    "inzai.chiba.jp",
    "isumi.chiba.jp",
    "kamagaya.chiba.jp",
    "kamogawa.chiba.jp",
    "kashiwa.chiba.jp",
    "katori.chiba.jp",
    "katsuura.chiba.jp",
    "kimitsu.chiba.jp",
    "kisarazu.chiba.jp",
    "kozaki.chiba.jp",
    "kujukuri.chiba.jp",
    "kyonan.chiba.jp",
    "matsudo.chiba.jp",
    "midori.chiba.jp",
    "mihama.chiba.jp",
    "minamiboso.chiba.jp",
    "mobara.chiba.jp",
    "mutsuzawa.chiba.jp",
    "nagara.chiba.jp",
    "nagareyama.chiba.jp",
    "narashino.chiba.jp",
    "narita.chiba.jp",
    "noda.chiba.jp",
    "oamishirasato.chiba.jp",
    "omigawa.chiba.jp",
    "onjuku.chiba.jp",
    "otaki.chiba.jp",
    "sakae.chiba.jp",
    "sakura.chiba.jp",
    "shimofusa.chiba.jp",
    "shirako.chiba.jp",
    "shiroi.chiba.jp",
    "shisui.chiba.jp",
    "sodegaura.chiba.jp",
    "sosa.chiba.jp",
    "tako.chiba.jp",
    "tateyama.chiba.jp",
    "togane.chiba.jp",
    "tohnosho.chiba.jp",
    "tomisato.chiba.jp",
    "urayasu.chiba.jp",
    "yachimata.chiba.jp",
    "yachiyo.chiba.jp",
    "yokaichiba.chiba.jp",
    "yokoshibahikari.chiba.jp",
    "yotsukaido.chiba.jp",
    "ainan.ehime.jp",
    "honai.ehime.jp",
    "ikata.ehime.jp",
    "imabari.ehime.jp",
    "iyo.ehime.jp",
    "kamijima.ehime.jp",
    "kihoku.ehime.jp",
    "kumakogen.ehime.jp",
    "masaki.ehime.jp",
    "matsuno.ehime.jp",
    "matsuyama.ehime.jp",
    "namikata.ehime.jp",
    "niihama.ehime.jp",
    "ozu.ehime.jp",
    "saijo.ehime.jp",
    "seiyo.ehime.jp",
    "shikokuchuo.ehime.jp",
    "tobe.ehime.jp",
    "toon.ehime.jp",
    "uchiko.ehime.jp",
    "uwajima.ehime.jp",
    "yawatahama.ehime.jp",
    "echizen.fukui.jp",
    "eiheiji.fukui.jp",
    "fukui.fukui.jp",
    "ikeda.fukui.jp",
    "katsuyama.fukui.jp",
    "mihama.fukui.jp",
    "minamiechizen.fukui.jp",
    "obama.fukui.jp",
    "ohi.fukui.jp",
    "ono.fukui.jp",
    "sabae.fukui.jp",
    "sakai.fukui.jp",
    "takahama.fukui.jp",
    "tsuruga.fukui.jp",
    "wakasa.fukui.jp",
    "ashiya.fukuoka.jp",
    "buzen.fukuoka.jp",
    "chikugo.fukuoka.jp",
    "chikuho.fukuoka.jp",
    "chikujo.fukuoka.jp",
    "chikushino.fukuoka.jp",
    "chikuzen.fukuoka.jp",
    "chuo.fukuoka.jp",
    "dazaifu.fukuoka.jp",
    "fukuchi.fukuoka.jp",
    "hakata.fukuoka.jp",
    "higashi.fukuoka.jp",
    "hirokawa.fukuoka.jp",
    "hisayama.fukuoka.jp",
    "iizuka.fukuoka.jp",
    "inatsuki.fukuoka.jp",
    "kaho.fukuoka.jp",
    "kasuga.fukuoka.jp",
    "kasuya.fukuoka.jp",
    "kawara.fukuoka.jp",
    "keisen.fukuoka.jp",
    "koga.fukuoka.jp",
    "kurate.fukuoka.jp",
    "kurogi.fukuoka.jp",
    "kurume.fukuoka.jp",
    "minami.fukuoka.jp",
    "miyako.fukuoka.jp",
    "miyama.fukuoka.jp",
    "miyawaka.fukuoka.jp",
    "mizumaki.fukuoka.jp",
    "munakata.fukuoka.jp",
    "nakagawa.fukuoka.jp",
    "nakama.fukuoka.jp",
    "nishi.fukuoka.jp",
    "nogata.fukuoka.jp",
    "ogori.fukuoka.jp",
    "okagaki.fukuoka.jp",
    "okawa.fukuoka.jp",
    "oki.fukuoka.jp",
    "omuta.fukuoka.jp",
    "onga.fukuoka.jp",
    "onojo.fukuoka.jp",
    "oto.fukuoka.jp",
    "saigawa.fukuoka.jp",
    "sasaguri.fukuoka.jp",
    "shingu.fukuoka.jp",
    "shinyoshitomi.fukuoka.jp",
    "shonai.fukuoka.jp",
    "soeda.fukuoka.jp",
    "sue.fukuoka.jp",
    "tachiarai.fukuoka.jp",
    "tagawa.fukuoka.jp",
    "takata.fukuoka.jp",
    "toho.fukuoka.jp",
    "toyotsu.fukuoka.jp",
    "tsuiki.fukuoka.jp",
    "ukiha.fukuoka.jp",
    "umi.fukuoka.jp",
    "usui.fukuoka.jp",
    "yamada.fukuoka.jp",
    "yame.fukuoka.jp",
    "yanagawa.fukuoka.jp",
    "yukuhashi.fukuoka.jp",
    "aizubange.fukushima.jp",
    "aizumisato.fukushima.jp",
    "aizuwakamatsu.fukushima.jp",
    "asakawa.fukushima.jp",
    "bandai.fukushima.jp",
    "date.fukushima.jp",
    "fukushima.fukushima.jp",
    "furudono.fukushima.jp",
    "futaba.fukushima.jp",
    "hanawa.fukushima.jp",
    "higashi.fukushima.jp",
    "hirata.fukushima.jp",
    "hirono.fukushima.jp",
    "iitate.fukushima.jp",
    "inawashiro.fukushima.jp",
    "ishikawa.fukushima.jp",
    "iwaki.fukushima.jp",
    "izumizaki.fukushima.jp",
    "kagamiishi.fukushima.jp",
    "kaneyama.fukushima.jp",
    "kawamata.fukushima.jp",
    "kitakata.fukushima.jp",
    "kitashiobara.fukushima.jp",
    "koori.fukushima.jp",
    "koriyama.fukushima.jp",
    "kunimi.fukushima.jp",
    "miharu.fukushima.jp",
    "mishima.fukushima.jp",
    "namie.fukushima.jp",
    "nango.fukushima.jp",
    "nishiaizu.fukushima.jp",
    "nishigo.fukushima.jp",
    "okuma.fukushima.jp",
    "omotego.fukushima.jp",
    "ono.fukushima.jp",
    "otama.fukushima.jp",
    "samegawa.fukushima.jp",
    "shimogo.fukushima.jp",
    "shirakawa.fukushima.jp",
    "showa.fukushima.jp",
    "soma.fukushima.jp",
    "sukagawa.fukushima.jp",
    "taishin.fukushima.jp",
    "tamakawa.fukushima.jp",
    "tanagura.fukushima.jp",
    "tenei.fukushima.jp",
    "yabuki.fukushima.jp",
    "yamato.fukushima.jp",
    "yamatsuri.fukushima.jp",
    "yanaizu.fukushima.jp",
    "yugawa.fukushima.jp",
    "anpachi.gifu.jp",
    "ena.gifu.jp",
    "gifu.gifu.jp",
    "ginan.gifu.jp",
    "godo.gifu.jp",
    "gujo.gifu.jp",
    "hashima.gifu.jp",
    "hichiso.gifu.jp",
    "hida.gifu.jp",
    "higashishirakawa.gifu.jp",
    "ibigawa.gifu.jp",
    "ikeda.gifu.jp",
    "kakamigahara.gifu.jp",
    "kani.gifu.jp",
    "kasahara.gifu.jp",
    "kasamatsu.gifu.jp",
    "kawaue.gifu.jp",
    "kitagata.gifu.jp",
    "mino.gifu.jp",
    "minokamo.gifu.jp",
    "mitake.gifu.jp",
    "mizunami.gifu.jp",
    "motosu.gifu.jp",
    "nakatsugawa.gifu.jp",
    "ogaki.gifu.jp",
    "sakahogi.gifu.jp",
    "seki.gifu.jp",
    "sekigahara.gifu.jp",
    "shirakawa.gifu.jp",
    "tajimi.gifu.jp",
    "takayama.gifu.jp",
    "tarui.gifu.jp",
    "toki.gifu.jp",
    "tomika.gifu.jp",
    "wanouchi.gifu.jp",
    "yamagata.gifu.jp",
    "yaotsu.gifu.jp",
    "yoro.gifu.jp",
    "annaka.gunma.jp",
    "chiyoda.gunma.jp",
    "fujioka.gunma.jp",
    "higashiagatsuma.gunma.jp",
    "isesaki.gunma.jp",
    "itakura.gunma.jp",
    "kanna.gunma.jp",
    "kanra.gunma.jp",
    "katashina.gunma.jp",
    "kawaba.gunma.jp",
    "kiryu.gunma.jp",
    "kusatsu.gunma.jp",
    "maebashi.gunma.jp",
    "meiwa.gunma.jp",
    "midori.gunma.jp",
    "minakami.gunma.jp",
    "naganohara.gunma.jp",
    "nakanojo.gunma.jp",
    "nanmoku.gunma.jp",
    "numata.gunma.jp",
    "oizumi.gunma.jp",
    "ora.gunma.jp",
    "ota.gunma.jp",
    "shibukawa.gunma.jp",
    "shimonita.gunma.jp",
    "shinto.gunma.jp",
    "showa.gunma.jp",
    "takasaki.gunma.jp",
    "takayama.gunma.jp",
    "tamamura.gunma.jp",
    "tatebayashi.gunma.jp",
    "tomioka.gunma.jp",
    "tsukiyono.gunma.jp",
    "tsumagoi.gunma.jp",
    "ueno.gunma.jp",
    "yoshioka.gunma.jp",
    "asaminami.hiroshima.jp",
    "daiwa.hiroshima.jp",
    "etajima.hiroshima.jp",
    "fuchu.hiroshima.jp",
    "fukuyama.hiroshima.jp",
    "hatsukaichi.hiroshima.jp",
    "higashihiroshima.hiroshima.jp",
    "hongo.hiroshima.jp",
    "jinsekikogen.hiroshima.jp",
    "kaita.hiroshima.jp",
    "kui.hiroshima.jp",
    "kumano.hiroshima.jp",
    "kure.hiroshima.jp",
    "mihara.hiroshima.jp",
    "miyoshi.hiroshima.jp",
    "naka.hiroshima.jp",
    "onomichi.hiroshima.jp",
    "osakikamijima.hiroshima.jp",
    "otake.hiroshima.jp",
    "saka.hiroshima.jp",
    "sera.hiroshima.jp",
    "seranishi.hiroshima.jp",
    "shinichi.hiroshima.jp",
    "shobara.hiroshima.jp",
    "takehara.hiroshima.jp",
    "abashiri.hokkaido.jp",
    "abira.hokkaido.jp",
    "aibetsu.hokkaido.jp",
    "akabira.hokkaido.jp",
    "akkeshi.hokkaido.jp",
    "asahikawa.hokkaido.jp",
    "ashibetsu.hokkaido.jp",
    "ashoro.hokkaido.jp",
    "assabu.hokkaido.jp",
    "atsuma.hokkaido.jp",
    "bibai.hokkaido.jp",
    "biei.hokkaido.jp",
    "bifuka.hokkaido.jp",
    "bihoro.hokkaido.jp",
    "biratori.hokkaido.jp",
    "chippubetsu.hokkaido.jp",
    "chitose.hokkaido.jp",
    "date.hokkaido.jp",
    "ebetsu.hokkaido.jp",
    "embetsu.hokkaido.jp",
    "eniwa.hokkaido.jp",
    "erimo.hokkaido.jp",
    "esan.hokkaido.jp",
    "esashi.hokkaido.jp",
    "fukagawa.hokkaido.jp",
    "fukushima.hokkaido.jp",
    "furano.hokkaido.jp",
    "furubira.hokkaido.jp",
    "haboro.hokkaido.jp",
    "hakodate.hokkaido.jp",
    "hamatonbetsu.hokkaido.jp",
    "hidaka.hokkaido.jp",
    "higashikagura.hokkaido.jp",
    "higashikawa.hokkaido.jp",
    "hiroo.hokkaido.jp",
    "hokuryu.hokkaido.jp",
    "hokuto.hokkaido.jp",
    "honbetsu.hokkaido.jp",
    "horokanai.hokkaido.jp",
    "horonobe.hokkaido.jp",
    "ikeda.hokkaido.jp",
    "imakane.hokkaido.jp",
    "ishikari.hokkaido.jp",
    "iwamizawa.hokkaido.jp",
    "iwanai.hokkaido.jp",
    "kamifurano.hokkaido.jp",
    "kamikawa.hokkaido.jp",
    "kamishihoro.hokkaido.jp",
    "kamisunagawa.hokkaido.jp",
    "kamoenai.hokkaido.jp",
    "kayabe.hokkaido.jp",
    "kembuchi.hokkaido.jp",
    "kikonai.hokkaido.jp",
    "kimobetsu.hokkaido.jp",
    "kitahiroshima.hokkaido.jp",
    "kitami.hokkaido.jp",
    "kiyosato.hokkaido.jp",
    "koshimizu.hokkaido.jp",
    "kunneppu.hokkaido.jp",
    "kuriyama.hokkaido.jp",
    "kuromatsunai.hokkaido.jp",
    "kushiro.hokkaido.jp",
    "kutchan.hokkaido.jp",
    "kyowa.hokkaido.jp",
    "mashike.hokkaido.jp",
    "matsumae.hokkaido.jp",
    "mikasa.hokkaido.jp",
    "minamifurano.hokkaido.jp",
    "mombetsu.hokkaido.jp",
    "moseushi.hokkaido.jp",
    "mukawa.hokkaido.jp",
    "muroran.hokkaido.jp",
    "naie.hokkaido.jp",
    "nakagawa.hokkaido.jp",
    "nakasatsunai.hokkaido.jp",
    "nakatombetsu.hokkaido.jp",
    "nanae.hokkaido.jp",
    "nanporo.hokkaido.jp",
    "nayoro.hokkaido.jp",
    "nemuro.hokkaido.jp",
    "niikappu.hokkaido.jp",
    "niki.hokkaido.jp",
    "nishiokoppe.hokkaido.jp",
    "noboribetsu.hokkaido.jp",
    "numata.hokkaido.jp",
    "obihiro.hokkaido.jp",
    "obira.hokkaido.jp",
    "oketo.hokkaido.jp",
    "okoppe.hokkaido.jp",
    "otaru.hokkaido.jp",
    "otobe.hokkaido.jp",
    "otofuke.hokkaido.jp",
    "otoineppu.hokkaido.jp",
    "oumu.hokkaido.jp",
    "ozora.hokkaido.jp",
    "pippu.hokkaido.jp",
    "rankoshi.hokkaido.jp",
    "rebun.hokkaido.jp",
    "rikubetsu.hokkaido.jp",
    "rishiri.hokkaido.jp",
    "rishirifuji.hokkaido.jp",
    "saroma.hokkaido.jp",
    "sarufutsu.hokkaido.jp",
    "shakotan.hokkaido.jp",
    "shari.hokkaido.jp",
    "shibecha.hokkaido.jp",
    "shibetsu.hokkaido.jp",
    "shikabe.hokkaido.jp",
    "shikaoi.hokkaido.jp",
    "shimamaki.hokkaido.jp",
    "shimizu.hokkaido.jp",
    "shimokawa.hokkaido.jp",
    "shinshinotsu.hokkaido.jp",
    "shintoku.hokkaido.jp",
    "shiranuka.hokkaido.jp",
    "shiraoi.hokkaido.jp",
    "shiriuchi.hokkaido.jp",
    "sobetsu.hokkaido.jp",
    "sunagawa.hokkaido.jp",
    "taiki.hokkaido.jp",
    "takasu.hokkaido.jp",
    "takikawa.hokkaido.jp",
    "takinoue.hokkaido.jp",
    "teshikaga.hokkaido.jp",
    "tobetsu.hokkaido.jp",
    "tohma.hokkaido.jp",
    "tomakomai.hokkaido.jp",
    "tomari.hokkaido.jp",
    "toya.hokkaido.jp",
    "toyako.hokkaido.jp",
    "toyotomi.hokkaido.jp",
    "toyoura.hokkaido.jp",
    "tsubetsu.hokkaido.jp",
    "tsukigata.hokkaido.jp",
    "urakawa.hokkaido.jp",
    "urausu.hokkaido.jp",
    "uryu.hokkaido.jp",
    "utashinai.hokkaido.jp",
    "wakkanai.hokkaido.jp",
    "wassamu.hokkaido.jp",
    "yakumo.hokkaido.jp",
    "yoichi.hokkaido.jp",
    "aioi.hyogo.jp",
    "akashi.hyogo.jp",
    "ako.hyogo.jp",
    "amagasaki.hyogo.jp",
    "aogaki.hyogo.jp",
    "asago.hyogo.jp",
    "ashiya.hyogo.jp",
    "awaji.hyogo.jp",
    "fukusaki.hyogo.jp",
    "goshiki.hyogo.jp",
    "harima.hyogo.jp",
    "himeji.hyogo.jp",
    "ichikawa.hyogo.jp",
    "inagawa.hyogo.jp",
    "itami.hyogo.jp",
    "kakogawa.hyogo.jp",
    "kamigori.hyogo.jp",
    "kamikawa.hyogo.jp",
    "kasai.hyogo.jp",
    "kasuga.hyogo.jp",
    "kawanishi.hyogo.jp",
    "miki.hyogo.jp",
    "minamiawaji.hyogo.jp",
    "nishinomiya.hyogo.jp",
    "nishiwaki.hyogo.jp",
    "ono.hyogo.jp",
    "sanda.hyogo.jp",
    "sannan.hyogo.jp",
    "sasayama.hyogo.jp",
    "sayo.hyogo.jp",
    "shingu.hyogo.jp",
    "shinonsen.hyogo.jp",
    "shiso.hyogo.jp",
    "sumoto.hyogo.jp",
    "taishi.hyogo.jp",
    "taka.hyogo.jp",
    "takarazuka.hyogo.jp",
    "takasago.hyogo.jp",
    "takino.hyogo.jp",
    "tamba.hyogo.jp",
    "tatsuno.hyogo.jp",
    "toyooka.hyogo.jp",
    "yabu.hyogo.jp",
    "yashiro.hyogo.jp",
    "yoka.hyogo.jp",
    "yokawa.hyogo.jp",
    "ami.ibaraki.jp",
    "asahi.ibaraki.jp",
    "bando.ibaraki.jp",
    "chikusei.ibaraki.jp",
    "daigo.ibaraki.jp",
    "fujishiro.ibaraki.jp",
    "hitachi.ibaraki.jp",
    "hitachinaka.ibaraki.jp",
    "hitachiomiya.ibaraki.jp",
    "hitachiota.ibaraki.jp",
    "ibaraki.ibaraki.jp",
    "ina.ibaraki.jp",
    "inashiki.ibaraki.jp",
    "itako.ibaraki.jp",
    "iwama.ibaraki.jp",
    "joso.ibaraki.jp",
    "kamisu.ibaraki.jp",
    "kasama.ibaraki.jp",
    "kashima.ibaraki.jp",
    "kasumigaura.ibaraki.jp",
    "koga.ibaraki.jp",
    "miho.ibaraki.jp",
    "mito.ibaraki.jp",
    "moriya.ibaraki.jp",
    "naka.ibaraki.jp",
    "namegata.ibaraki.jp",
    "oarai.ibaraki.jp",
    "ogawa.ibaraki.jp",
    "omitama.ibaraki.jp",
    "ryugasaki.ibaraki.jp",
    "sakai.ibaraki.jp",
    "sakuragawa.ibaraki.jp",
    "shimodate.ibaraki.jp",
    "shimotsuma.ibaraki.jp",
    "shirosato.ibaraki.jp",
    "sowa.ibaraki.jp",
    "suifu.ibaraki.jp",
    "takahagi.ibaraki.jp",
    "tamatsukuri.ibaraki.jp",
    "tokai.ibaraki.jp",
    "tomobe.ibaraki.jp",
    "tone.ibaraki.jp",
    "toride.ibaraki.jp",
    "tsuchiura.ibaraki.jp",
    "tsukuba.ibaraki.jp",
    "uchihara.ibaraki.jp",
    "ushiku.ibaraki.jp",
    "yachiyo.ibaraki.jp",
    "yamagata.ibaraki.jp",
    "yawara.ibaraki.jp",
    "yuki.ibaraki.jp",
    "anamizu.ishikawa.jp",
    "hakui.ishikawa.jp",
    "hakusan.ishikawa.jp",
    "kaga.ishikawa.jp",
    "kahoku.ishikawa.jp",
    "kanazawa.ishikawa.jp",
    "kawakita.ishikawa.jp",
    "komatsu.ishikawa.jp",
    "nakanoto.ishikawa.jp",
    "nanao.ishikawa.jp",
    "nomi.ishikawa.jp",
    "nonoichi.ishikawa.jp",
    "noto.ishikawa.jp",
    "shika.ishikawa.jp",
    "suzu.ishikawa.jp",
    "tsubata.ishikawa.jp",
    "tsurugi.ishikawa.jp",
    "uchinada.ishikawa.jp",
    "wajima.ishikawa.jp",
    "fudai.iwate.jp",
    "fujisawa.iwate.jp",
    "hanamaki.iwate.jp",
    "hiraizumi.iwate.jp",
    "hirono.iwate.jp",
    "ichinohe.iwate.jp",
    "ichinoseki.iwate.jp",
    "iwaizumi.iwate.jp",
    "iwate.iwate.jp",
    "joboji.iwate.jp",
    "kamaishi.iwate.jp",
    "kanegasaki.iwate.jp",
    "karumai.iwate.jp",
    "kawai.iwate.jp",
    "kitakami.iwate.jp",
    "kuji.iwate.jp",
    "kunohe.iwate.jp",
    "kuzumaki.iwate.jp",
    "miyako.iwate.jp",
    "mizusawa.iwate.jp",
    "morioka.iwate.jp",
    "ninohe.iwate.jp",
    "noda.iwate.jp",
    "ofunato.iwate.jp",
    "oshu.iwate.jp",
    "otsuchi.iwate.jp",
    "rikuzentakata.iwate.jp",
    "shiwa.iwate.jp",
    "shizukuishi.iwate.jp",
    "sumita.iwate.jp",
    "tanohata.iwate.jp",
    "tono.iwate.jp",
    "yahaba.iwate.jp",
    "yamada.iwate.jp",
    "ayagawa.kagawa.jp",
    "higashikagawa.kagawa.jp",
    "kanonji.kagawa.jp",
    "kotohira.kagawa.jp",
    "manno.kagawa.jp",
    "marugame.kagawa.jp",
    "mitoyo.kagawa.jp",
    "naoshima.kagawa.jp",
    "sanuki.kagawa.jp",
    "tadotsu.kagawa.jp",
    "takamatsu.kagawa.jp",
    "tonosho.kagawa.jp",
    "uchinomi.kagawa.jp",
    "utazu.kagawa.jp",
    "zentsuji.kagawa.jp",
    "akune.kagoshima.jp",
    "amami.kagoshima.jp",
    "hioki.kagoshima.jp",
    "isa.kagoshima.jp",
    "isen.kagoshima.jp",
    "izumi.kagoshima.jp",
    "kagoshima.kagoshima.jp",
    "kanoya.kagoshima.jp",
    "kawanabe.kagoshima.jp",
    "kinko.kagoshima.jp",
    "kouyama.kagoshima.jp",
    "makurazaki.kagoshima.jp",
    "matsumoto.kagoshima.jp",
    "minamitane.kagoshima.jp",
    "nakatane.kagoshima.jp",
    "nishinoomote.kagoshima.jp",
    "satsumasendai.kagoshima.jp",
    "soo.kagoshima.jp",
    "tarumizu.kagoshima.jp",
    "yusui.kagoshima.jp",
    "aikawa.kanagawa.jp",
    "atsugi.kanagawa.jp",
    "ayase.kanagawa.jp",
    "chigasaki.kanagawa.jp",
    "ebina.kanagawa.jp",
    "fujisawa.kanagawa.jp",
    "hadano.kanagawa.jp",
    "hakone.kanagawa.jp",
    "hiratsuka.kanagawa.jp",
    "isehara.kanagawa.jp",
    "kaisei.kanagawa.jp",
    "kamakura.kanagawa.jp",
    "kiyokawa.kanagawa.jp",
    "matsuda.kanagawa.jp",
    "minamiashigara.kanagawa.jp",
    "miura.kanagawa.jp",
    "nakai.kanagawa.jp",
    "ninomiya.kanagawa.jp",
    "odawara.kanagawa.jp",
    "oi.kanagawa.jp",
    "oiso.kanagawa.jp",
    "sagamihara.kanagawa.jp",
    "samukawa.kanagawa.jp",
    "tsukui.kanagawa.jp",
    "yamakita.kanagawa.jp",
    "yamato.kanagawa.jp",
    "yokosuka.kanagawa.jp",
    "yugawara.kanagawa.jp",
    "zama.kanagawa.jp",
    "zushi.kanagawa.jp",
    "aki.kochi.jp",
    "geisei.kochi.jp",
    "hidaka.kochi.jp",
    "higashitsuno.kochi.jp",
    "ino.kochi.jp",
    "kagami.kochi.jp",
    "kami.kochi.jp",
    "kitagawa.kochi.jp",
    "kochi.kochi.jp",
    "mihara.kochi.jp",
    "motoyama.kochi.jp",
    "muroto.kochi.jp",
    "nahari.kochi.jp",
    "nakamura.kochi.jp",
    "nankoku.kochi.jp",
    "nishitosa.kochi.jp",
    "niyodogawa.kochi.jp",
    "ochi.kochi.jp",
    "okawa.kochi.jp",
    "otoyo.kochi.jp",
    "otsuki.kochi.jp",
    "sakawa.kochi.jp",
    "sukumo.kochi.jp",
    "susaki.kochi.jp",
    "tosa.kochi.jp",
    "tosashimizu.kochi.jp",
    "toyo.kochi.jp",
    "tsuno.kochi.jp",
    "umaji.kochi.jp",
    "yasuda.kochi.jp",
    "yusuhara.kochi.jp",
    "amakusa.kumamoto.jp",
    "arao.kumamoto.jp",
    "aso.kumamoto.jp",
    "choyo.kumamoto.jp",
    "gyokuto.kumamoto.jp",
    "kamiamakusa.kumamoto.jp",
    "kikuchi.kumamoto.jp",
    "kumamoto.kumamoto.jp",
    "mashiki.kumamoto.jp",
    "mifune.kumamoto.jp",
    "minamata.kumamoto.jp",
    "minamioguni.kumamoto.jp",
    "nagasu.kumamoto.jp",
    "nishihara.kumamoto.jp",
    "oguni.kumamoto.jp",
    "ozu.kumamoto.jp",
    "sumoto.kumamoto.jp",
    "takamori.kumamoto.jp",
    "uki.kumamoto.jp",
    "uto.kumamoto.jp",
    "yamaga.kumamoto.jp",
    "yamato.kumamoto.jp",
    "yatsushiro.kumamoto.jp",
    "ayabe.kyoto.jp",
    "fukuchiyama.kyoto.jp",
    "higashiyama.kyoto.jp",
    "ide.kyoto.jp",
    "ine.kyoto.jp",
    "joyo.kyoto.jp",
    "kameoka.kyoto.jp",
    "kamo.kyoto.jp",
    "kita.kyoto.jp",
    "kizu.kyoto.jp",
    "kumiyama.kyoto.jp",
    "kyotamba.kyoto.jp",
    "kyotanabe.kyoto.jp",
    "kyotango.kyoto.jp",
    "maizuru.kyoto.jp",
    "minami.kyoto.jp",
    "minamiyamashiro.kyoto.jp",
    "miyazu.kyoto.jp",
    "muko.kyoto.jp",
    "nagaokakyo.kyoto.jp",
    "nakagyo.kyoto.jp",
    "nantan.kyoto.jp",
    "oyamazaki.kyoto.jp",
    "sakyo.kyoto.jp",
    "seika.kyoto.jp",
    "tanabe.kyoto.jp",
    "uji.kyoto.jp",
    "ujitawara.kyoto.jp",
    "wazuka.kyoto.jp",
    "yamashina.kyoto.jp",
    "yawata.kyoto.jp",
    "asahi.mie.jp",
    "inabe.mie.jp",
    "ise.mie.jp",
    "kameyama.mie.jp",
    "kawagoe.mie.jp",
    "kiho.mie.jp",
    "kisosaki.mie.jp",
    "kiwa.mie.jp",
    "komono.mie.jp",
    "kumano.mie.jp",
    "kuwana.mie.jp",
    "matsusaka.mie.jp",
    "meiwa.mie.jp",
    "mihama.mie.jp",
    "minamiise.mie.jp",
    "misugi.mie.jp",
    "miyama.mie.jp",
    "nabari.mie.jp",
    "shima.mie.jp",
    "suzuka.mie.jp",
    "tado.mie.jp",
    "taiki.mie.jp",
    "taki.mie.jp",
    "tamaki.mie.jp",
    "toba.mie.jp",
    "tsu.mie.jp",
    "udono.mie.jp",
    "ureshino.mie.jp",
    "watarai.mie.jp",
    "yokkaichi.mie.jp",
    "furukawa.miyagi.jp",
    "higashimatsushima.miyagi.jp",
    "ishinomaki.miyagi.jp",
    "iwanuma.miyagi.jp",
    "kakuda.miyagi.jp",
    "kami.miyagi.jp",
    "kawasaki.miyagi.jp",
    "marumori.miyagi.jp",
    "matsushima.miyagi.jp",
    "minamisanriku.miyagi.jp",
    "misato.miyagi.jp",
    "murata.miyagi.jp",
    "natori.miyagi.jp",
    "ogawara.miyagi.jp",
    "ohira.miyagi.jp",
    "onagawa.miyagi.jp",
    "osaki.miyagi.jp",
    "rifu.miyagi.jp",
    "semine.miyagi.jp",
    "shibata.miyagi.jp",
    "shichikashuku.miyagi.jp",
    "shikama.miyagi.jp",
    "shiogama.miyagi.jp",
    "shiroishi.miyagi.jp",
    "tagajo.miyagi.jp",
    "taiwa.miyagi.jp",
    "tome.miyagi.jp",
    "tomiya.miyagi.jp",
    "wakuya.miyagi.jp",
    "watari.miyagi.jp",
    "yamamoto.miyagi.jp",
    "zao.miyagi.jp",
    "aya.miyazaki.jp",
    "ebino.miyazaki.jp",
    "gokase.miyazaki.jp",
    "hyuga.miyazaki.jp",
    "kadogawa.miyazaki.jp",
    "kawaminami.miyazaki.jp",
    "kijo.miyazaki.jp",
    "kitagawa.miyazaki.jp",
    "kitakata.miyazaki.jp",
    "kitaura.miyazaki.jp",
    "kobayashi.miyazaki.jp",
    "kunitomi.miyazaki.jp",
    "kushima.miyazaki.jp",
    "mimata.miyazaki.jp",
    "miyakonojo.miyazaki.jp",
    "miyazaki.miyazaki.jp",
    "morotsuka.miyazaki.jp",
    "nichinan.miyazaki.jp",
    "nishimera.miyazaki.jp",
    "nobeoka.miyazaki.jp",
    "saito.miyazaki.jp",
    "shiiba.miyazaki.jp",
    "shintomi.miyazaki.jp",
    "takaharu.miyazaki.jp",
    "takanabe.miyazaki.jp",
    "takazaki.miyazaki.jp",
    "tsuno.miyazaki.jp",
    "achi.nagano.jp",
    "agematsu.nagano.jp",
    "anan.nagano.jp",
    "aoki.nagano.jp",
    "asahi.nagano.jp",
    "azumino.nagano.jp",
    "chikuhoku.nagano.jp",
    "chikuma.nagano.jp",
    "chino.nagano.jp",
    "fujimi.nagano.jp",
    "hakuba.nagano.jp",
    "hara.nagano.jp",
    "hiraya.nagano.jp",
    "iida.nagano.jp",
    "iijima.nagano.jp",
    "iiyama.nagano.jp",
    "iizuna.nagano.jp",
    "ikeda.nagano.jp",
    "ikusaka.nagano.jp",
    "ina.nagano.jp",
    "karuizawa.nagano.jp",
    "kawakami.nagano.jp",
    "kiso.nagano.jp",
    "kisofukushima.nagano.jp",
    "kitaaiki.nagano.jp",
    "komagane.nagano.jp",
    "komoro.nagano.jp",
    "matsukawa.nagano.jp",
    "matsumoto.nagano.jp",
    "miasa.nagano.jp",
    "minamiaiki.nagano.jp",
    "minamimaki.nagano.jp",
    "minamiminowa.nagano.jp",
    "minowa.nagano.jp",
    "miyada.nagano.jp",
    "miyota.nagano.jp",
    "mochizuki.nagano.jp",
    "nagano.nagano.jp",
    "nagawa.nagano.jp",
    "nagiso.nagano.jp",
    "nakagawa.nagano.jp",
    "nakano.nagano.jp",
    "nozawaonsen.nagano.jp",
    "obuse.nagano.jp",
    "ogawa.nagano.jp",
    "okaya.nagano.jp",
    "omachi.nagano.jp",
    "omi.nagano.jp",
    "ookuwa.nagano.jp",
    "ooshika.nagano.jp",
    "otaki.nagano.jp",
    "otari.nagano.jp",
    "sakae.nagano.jp",
    "sakaki.nagano.jp",
    "saku.nagano.jp",
    "sakuho.nagano.jp",
    "shimosuwa.nagano.jp",
    "shinanomachi.nagano.jp",
    "shiojiri.nagano.jp",
    "suwa.nagano.jp",
    "suzaka.nagano.jp",
    "takagi.nagano.jp",
    "takamori.nagano.jp",
    "takayama.nagano.jp",
    "tateshina.nagano.jp",
    "tatsuno.nagano.jp",
    "togakushi.nagano.jp",
    "togura.nagano.jp",
    "tomi.nagano.jp",
    "ueda.nagano.jp",
    "wada.nagano.jp",
    "yamagata.nagano.jp",
    "yamanouchi.nagano.jp",
    "yasaka.nagano.jp",
    "yasuoka.nagano.jp",
    "chijiwa.nagasaki.jp",
    "futsu.nagasaki.jp",
    "goto.nagasaki.jp",
    "hasami.nagasaki.jp",
    "hirado.nagasaki.jp",
    "iki.nagasaki.jp",
    "isahaya.nagasaki.jp",
    "kawatana.nagasaki.jp",
    "kuchinotsu.nagasaki.jp",
    "matsuura.nagasaki.jp",
    "nagasaki.nagasaki.jp",
    "obama.nagasaki.jp",
    "omura.nagasaki.jp",
    "oseto.nagasaki.jp",
    "saikai.nagasaki.jp",
    "sasebo.nagasaki.jp",
    "seihi.nagasaki.jp",
    "shimabara.nagasaki.jp",
    "shinkamigoto.nagasaki.jp",
    "togitsu.nagasaki.jp",
    "tsushima.nagasaki.jp",
    "unzen.nagasaki.jp",
    "ando.nara.jp",
    "gose.nara.jp",
    "heguri.nara.jp",
    "higashiyoshino.nara.jp",
    "ikaruga.nara.jp",
    "ikoma.nara.jp",
    "kamikitayama.nara.jp",
    "kanmaki.nara.jp",
    "kashiba.nara.jp",
    "kashihara.nara.jp",
    "katsuragi.nara.jp",
    "kawai.nara.jp",
    "kawakami.nara.jp",
    "kawanishi.nara.jp",
    "koryo.nara.jp",
    "kurotaki.nara.jp",
    "mitsue.nara.jp",
    "miyake.nara.jp",
    "nara.nara.jp",
    "nosegawa.nara.jp",
    "oji.nara.jp",
    "ouda.nara.jp",
    "oyodo.nara.jp",
    "sakurai.nara.jp",
    "sango.nara.jp",
    "shimoichi.nara.jp",
    "shimokitayama.nara.jp",
    "shinjo.nara.jp",
    "soni.nara.jp",
    "takatori.nara.jp",
    "tawaramoto.nara.jp",
    "tenkawa.nara.jp",
    "tenri.nara.jp",
    "uda.nara.jp",
    "yamatokoriyama.nara.jp",
    "yamatotakada.nara.jp",
    "yamazoe.nara.jp",
    "yoshino.nara.jp",
    "aga.niigata.jp",
    "agano.niigata.jp",
    "gosen.niigata.jp",
    "itoigawa.niigata.jp",
    "izumozaki.niigata.jp",
    "joetsu.niigata.jp",
    "kamo.niigata.jp",
    "kariwa.niigata.jp",
    "kashiwazaki.niigata.jp",
    "minamiuonuma.niigata.jp",
    "mitsuke.niigata.jp",
    "muika.niigata.jp",
    "murakami.niigata.jp",
    "myoko.niigata.jp",
    "nagaoka.niigata.jp",
    "niigata.niigata.jp",
    "ojiya.niigata.jp",
    "omi.niigata.jp",
    "sado.niigata.jp",
    "sanjo.niigata.jp",
    "seiro.niigata.jp",
    "seirou.niigata.jp",
    "sekikawa.niigata.jp",
    "shibata.niigata.jp",
    "tagami.niigata.jp",
    "tainai.niigata.jp",
    "tochio.niigata.jp",
    "tokamachi.niigata.jp",
    "tsubame.niigata.jp",
    "tsunan.niigata.jp",
    "uonuma.niigata.jp",
    "yahiko.niigata.jp",
    "yoita.niigata.jp",
    "yuzawa.niigata.jp",
    "beppu.oita.jp",
    "bungoono.oita.jp",
    "bungotakada.oita.jp",
    "hasama.oita.jp",
    "hiji.oita.jp",
    "himeshima.oita.jp",
    "hita.oita.jp",
    "kamitsue.oita.jp",
    "kokonoe.oita.jp",
    "kuju.oita.jp",
    "kunisaki.oita.jp",
    "kusu.oita.jp",
    "oita.oita.jp",
    "saiki.oita.jp",
    "taketa.oita.jp",
    "tsukumi.oita.jp",
    "usa.oita.jp",
    "usuki.oita.jp",
    "yufu.oita.jp",
    "akaiwa.okayama.jp",
    "asakuchi.okayama.jp",
    "bizen.okayama.jp",
    "hayashima.okayama.jp",
    "ibara.okayama.jp",
    "kagamino.okayama.jp",
    "kasaoka.okayama.jp",
    "kibichuo.okayama.jp",
    "kumenan.okayama.jp",
    "kurashiki.okayama.jp",
    "maniwa.okayama.jp",
    "misaki.okayama.jp",
    "nagi.okayama.jp",
    "niimi.okayama.jp",
    "nishiawakura.okayama.jp",
    "okayama.okayama.jp",
    "satosho.okayama.jp",
    "setouchi.okayama.jp",
    "shinjo.okayama.jp",
    "shoo.okayama.jp",
    "soja.okayama.jp",
    "takahashi.okayama.jp",
    "tamano.okayama.jp",
    "tsuyama.okayama.jp",
    "wake.okayama.jp",
    "yakage.okayama.jp",
    "aguni.okinawa.jp",
    "ginowan.okinawa.jp",
    "ginoza.okinawa.jp",
    "gushikami.okinawa.jp",
    "haebaru.okinawa.jp",
    "higashi.okinawa.jp",
    "hirara.okinawa.jp",
    "iheya.okinawa.jp",
    "ishigaki.okinawa.jp",
    "ishikawa.okinawa.jp",
    "itoman.okinawa.jp",
    "izena.okinawa.jp",
    "kadena.okinawa.jp",
    "kin.okinawa.jp",
    "kitadaito.okinawa.jp",
    "kitanakagusuku.okinawa.jp",
    "kumejima.okinawa.jp",
    "kunigami.okinawa.jp",
    "minamidaito.okinawa.jp",
    "motobu.okinawa.jp",
    "nago.okinawa.jp",
    "naha.okinawa.jp",
    "nakagusuku.okinawa.jp",
    "nakijin.okinawa.jp",
    "nanjo.okinawa.jp",
    "nishihara.okinawa.jp",
    "ogimi.okinawa.jp",
    "okinawa.okinawa.jp",
    "onna.okinawa.jp",
    "shimoji.okinawa.jp",
    "taketomi.okinawa.jp",
    "tarama.okinawa.jp",
    "tokashiki.okinawa.jp",
    "tomigusuku.okinawa.jp",
    "tonaki.okinawa.jp",
    "urasoe.okinawa.jp",
    "uruma.okinawa.jp",
    "yaese.okinawa.jp",
    "yomitan.okinawa.jp",
    "yonabaru.okinawa.jp",
    "yonaguni.okinawa.jp",
    "zamami.okinawa.jp",
    "abeno.osaka.jp",
    "chihayaakasaka.osaka.jp",
    "chuo.osaka.jp",
    "daito.osaka.jp",
    "fujiidera.osaka.jp",
    "habikino.osaka.jp",
    "hannan.osaka.jp",
    "higashiosaka.osaka.jp",
    "higashisumiyoshi.osaka.jp",
    "higashiyodogawa.osaka.jp",
    "hirakata.osaka.jp",
    "ibaraki.osaka.jp",
    "ikeda.osaka.jp",
    "izumi.osaka.jp",
    "izumiotsu.osaka.jp",
    "izumisano.osaka.jp",
    "kadoma.osaka.jp",
    "kaizuka.osaka.jp",
    "kanan.osaka.jp",
    "kashiwara.osaka.jp",
    "katano.osaka.jp",
    "kawachinagano.osaka.jp",
    "kishiwada.osaka.jp",
    "kita.osaka.jp",
    "kumatori.osaka.jp",
    "matsubara.osaka.jp",
    "minato.osaka.jp",
    "minoh.osaka.jp",
    "misaki.osaka.jp",
    "moriguchi.osaka.jp",
    "neyagawa.osaka.jp",
    "nishi.osaka.jp",
    "nose.osaka.jp",
    "osakasayama.osaka.jp",
    "sakai.osaka.jp",
    "sayama.osaka.jp",
    "sennan.osaka.jp",
    "settsu.osaka.jp",
    "shijonawate.osaka.jp",
    "shimamoto.osaka.jp",
    "suita.osaka.jp",
    "tadaoka.osaka.jp",
    "taishi.osaka.jp",
    "tajiri.osaka.jp",
    "takaishi.osaka.jp",
    "takatsuki.osaka.jp",
    "tondabayashi.osaka.jp",
    "toyonaka.osaka.jp",
    "toyono.osaka.jp",
    "yao.osaka.jp",
    "ariake.saga.jp",
    "arita.saga.jp",
    "fukudomi.saga.jp",
    "genkai.saga.jp",
    "hamatama.saga.jp",
    "hizen.saga.jp",
    "imari.saga.jp",
    "kamimine.saga.jp",
    "kanzaki.saga.jp",
    "karatsu.saga.jp",
    "kashima.saga.jp",
    "kitagata.saga.jp",
    "kitahata.saga.jp",
    "kiyama.saga.jp",
    "kouhoku.saga.jp",
    "kyuragi.saga.jp",
    "nishiarita.saga.jp",
    "ogi.saga.jp",
    "omachi.saga.jp",
    "ouchi.saga.jp",
    "saga.saga.jp",
    "shiroishi.saga.jp",
    "taku.saga.jp",
    "tara.saga.jp",
    "tosu.saga.jp",
    "yoshinogari.saga.jp",
    "arakawa.saitama.jp",
    "asaka.saitama.jp",
    "chichibu.saitama.jp",
    "fujimi.saitama.jp",
    "fujimino.saitama.jp",
    "fukaya.saitama.jp",
    "hanno.saitama.jp",
    "hanyu.saitama.jp",
    "hasuda.saitama.jp",
    "hatogaya.saitama.jp",
    "hatoyama.saitama.jp",
    "hidaka.saitama.jp",
    "higashichichibu.saitama.jp",
    "higashimatsuyama.saitama.jp",
    "honjo.saitama.jp",
    "ina.saitama.jp",
    "iruma.saitama.jp",
    "iwatsuki.saitama.jp",
    "kamiizumi.saitama.jp",
    "kamikawa.saitama.jp",
    "kamisato.saitama.jp",
    "kasukabe.saitama.jp",
    "kawagoe.saitama.jp",
    "kawaguchi.saitama.jp",
    "kawajima.saitama.jp",
    "kazo.saitama.jp",
    "kitamoto.saitama.jp",
    "koshigaya.saitama.jp",
    "kounosu.saitama.jp",
    "kuki.saitama.jp",
    "kumagaya.saitama.jp",
    "matsubushi.saitama.jp",
    "minano.saitama.jp",
    "misato.saitama.jp",
    "miyashiro.saitama.jp",
    "miyoshi.saitama.jp",
    "moroyama.saitama.jp",
    "nagatoro.saitama.jp",
    "namegawa.saitama.jp",
    "niiza.saitama.jp",
    "ogano.saitama.jp",
    "ogawa.saitama.jp",
    "ogose.saitama.jp",
    "okegawa.saitama.jp",
    "omiya.saitama.jp",
    "otaki.saitama.jp",
    "ranzan.saitama.jp",
    "ryokami.saitama.jp",
    "saitama.saitama.jp",
    "sakado.saitama.jp",
    "satte.saitama.jp",
    "sayama.saitama.jp",
    "shiki.saitama.jp",
    "shiraoka.saitama.jp",
    "soka.saitama.jp",
    "sugito.saitama.jp",
    "toda.saitama.jp",
    "tokigawa.saitama.jp",
    "tokorozawa.saitama.jp",
    "tsurugashima.saitama.jp",
    "urawa.saitama.jp",
    "warabi.saitama.jp",
    "yashio.saitama.jp",
    "yokoze.saitama.jp",
    "yono.saitama.jp",
    "yorii.saitama.jp",
    "yoshida.saitama.jp",
    "yoshikawa.saitama.jp",
    "yoshimi.saitama.jp",
    "aisho.shiga.jp",
    "gamo.shiga.jp",
    "higashiomi.shiga.jp",
    "hikone.shiga.jp",
    "koka.shiga.jp",
    "konan.shiga.jp",
    "kosei.shiga.jp",
    "koto.shiga.jp",
    "kusatsu.shiga.jp",
    "maibara.shiga.jp",
    "moriyama.shiga.jp",
    "nagahama.shiga.jp",
    "nishiazai.shiga.jp",
    "notogawa.shiga.jp",
    "omihachiman.shiga.jp",
    "otsu.shiga.jp",
    "ritto.shiga.jp",
    "ryuoh.shiga.jp",
    "takashima.shiga.jp",
    "takatsuki.shiga.jp",
    "torahime.shiga.jp",
    "toyosato.shiga.jp",
    "yasu.shiga.jp",
    "akagi.shimane.jp",
    "ama.shimane.jp",
    "gotsu.shimane.jp",
    "hamada.shimane.jp",
    "higashiizumo.shimane.jp",
    "hikawa.shimane.jp",
    "hikimi.shimane.jp",
    "izumo.shimane.jp",
    "kakinoki.shimane.jp",
    "masuda.shimane.jp",
    "matsue.shimane.jp",
    "misato.shimane.jp",
    "nishinoshima.shimane.jp",
    "ohda.shimane.jp",
    "okinoshima.shimane.jp",
    "okuizumo.shimane.jp",
    "shimane.shimane.jp",
    "tamayu.shimane.jp",
    "tsuwano.shimane.jp",
    "unnan.shimane.jp",
    "yakumo.shimane.jp",
    "yasugi.shimane.jp",
    "yatsuka.shimane.jp",
    "arai.shizuoka.jp",
    "atami.shizuoka.jp",
    "fuji.shizuoka.jp",
    "fujieda.shizuoka.jp",
    "fujikawa.shizuoka.jp",
    "fujinomiya.shizuoka.jp",
    "fukuroi.shizuoka.jp",
    "gotemba.shizuoka.jp",
    "haibara.shizuoka.jp",
    "hamamatsu.shizuoka.jp",
    "higashiizu.shizuoka.jp",
    "ito.shizuoka.jp",
    "iwata.shizuoka.jp",
    "izu.shizuoka.jp",
    "izunokuni.shizuoka.jp",
    "kakegawa.shizuoka.jp",
    "kannami.shizuoka.jp",
    "kawanehon.shizuoka.jp",
    "kawazu.shizuoka.jp",
    "kikugawa.shizuoka.jp",
    "kosai.shizuoka.jp",
    "makinohara.shizuoka.jp",
    "matsuzaki.shizuoka.jp",
    "minamiizu.shizuoka.jp",
    "mishima.shizuoka.jp",
    "morimachi.shizuoka.jp",
    "nishiizu.shizuoka.jp",
    "numazu.shizuoka.jp",
    "omaezaki.shizuoka.jp",
    "shimada.shizuoka.jp",
    "shimizu.shizuoka.jp",
    "shimoda.shizuoka.jp",
    "shizuoka.shizuoka.jp",
    "susono.shizuoka.jp",
    "yaizu.shizuoka.jp",
    "yoshida.shizuoka.jp",
    "ashikaga.tochigi.jp",
    "bato.tochigi.jp",
    "haga.tochigi.jp",
    "ichikai.tochigi.jp",
    "iwafune.tochigi.jp",
    "kaminokawa.tochigi.jp",
    "kanuma.tochigi.jp",
    "karasuyama.tochigi.jp",
    "kuroiso.tochigi.jp",
    "mashiko.tochigi.jp",
    "mibu.tochigi.jp",
    "moka.tochigi.jp",
    "motegi.tochigi.jp",
    "nasu.tochigi.jp",
    "nasushiobara.tochigi.jp",
    "nikko.tochigi.jp",
    "nishikata.tochigi.jp",
    "nogi.tochigi.jp",
    "ohira.tochigi.jp",
    "ohtawara.tochigi.jp",
    "oyama.tochigi.jp",
    "sakura.tochigi.jp",
    "sano.tochigi.jp",
    "shimotsuke.tochigi.jp",
    "shioya.tochigi.jp",
    "takanezawa.tochigi.jp",
    "tochigi.tochigi.jp",
    "tsuga.tochigi.jp",
    "ujiie.tochigi.jp",
    "utsunomiya.tochigi.jp",
    "yaita.tochigi.jp",
    "aizumi.tokushima.jp",
    "anan.tokushima.jp",
    "ichiba.tokushima.jp",
    "itano.tokushima.jp",
    "kainan.tokushima.jp",
    "komatsushima.tokushima.jp",
    "matsushige.tokushima.jp",
    "mima.tokushima.jp",
    "minami.tokushima.jp",
    "miyoshi.tokushima.jp",
    "mugi.tokushima.jp",
    "nakagawa.tokushima.jp",
    "naruto.tokushima.jp",
    "sanagochi.tokushima.jp",
    "shishikui.tokushima.jp",
    "tokushima.tokushima.jp",
    "wajiki.tokushima.jp",
    "adachi.tokyo.jp",
    "akiruno.tokyo.jp",
    "akishima.tokyo.jp",
    "aogashima.tokyo.jp",
    "arakawa.tokyo.jp",
    "bunkyo.tokyo.jp",
    "chiyoda.tokyo.jp",
    "chofu.tokyo.jp",
    "chuo.tokyo.jp",
    "edogawa.tokyo.jp",
    "fuchu.tokyo.jp",
    "fussa.tokyo.jp",
    "hachijo.tokyo.jp",
    "hachioji.tokyo.jp",
    "hamura.tokyo.jp",
    "higashikurume.tokyo.jp",
    "higashimurayama.tokyo.jp",
    "higashiyamato.tokyo.jp",
    "hino.tokyo.jp",
    "hinode.tokyo.jp",
    "hinohara.tokyo.jp",
    "inagi.tokyo.jp",
    "itabashi.tokyo.jp",
    "katsushika.tokyo.jp",
    "kita.tokyo.jp",
    "kiyose.tokyo.jp",
    "kodaira.tokyo.jp",
    "koganei.tokyo.jp",
    "kokubunji.tokyo.jp",
    "komae.tokyo.jp",
    "koto.tokyo.jp",
    "kouzushima.tokyo.jp",
    "kunitachi.tokyo.jp",
    "machida.tokyo.jp",
    "meguro.tokyo.jp",
    "minato.tokyo.jp",
    "mitaka.tokyo.jp",
    "mizuho.tokyo.jp",
    "musashimurayama.tokyo.jp",
    "musashino.tokyo.jp",
    "nakano.tokyo.jp",
    "nerima.tokyo.jp",
    "ogasawara.tokyo.jp",
    "okutama.tokyo.jp",
    "ome.tokyo.jp",
    "oshima.tokyo.jp",
    "ota.tokyo.jp",
    "setagaya.tokyo.jp",
    "shibuya.tokyo.jp",
    "shinagawa.tokyo.jp",
    "shinjuku.tokyo.jp",
    "suginami.tokyo.jp",
    "sumida.tokyo.jp",
    "tachikawa.tokyo.jp",
    "taito.tokyo.jp",
    "tama.tokyo.jp",
    "toshima.tokyo.jp",
    "chizu.tottori.jp",
    "hino.tottori.jp",
    "kawahara.tottori.jp",
    "koge.tottori.jp",
    "kotoura.tottori.jp",
    "misasa.tottori.jp",
    "nanbu.tottori.jp",
    "nichinan.tottori.jp",
    "sakaiminato.tottori.jp",
    "tottori.tottori.jp",
    "wakasa.tottori.jp",
    "yazu.tottori.jp",
    "yonago.tottori.jp",
    "asahi.toyama.jp",
    "fuchu.toyama.jp",
    "fukumitsu.toyama.jp",
    "funahashi.toyama.jp",
    "himi.toyama.jp",
    "imizu.toyama.jp",
    "inami.toyama.jp",
    "johana.toyama.jp",
    "kamiichi.toyama.jp",
    "kurobe.toyama.jp",
    "nakaniikawa.toyama.jp",
    "namerikawa.toyama.jp",
    "nanto.toyama.jp",
    "nyuzen.toyama.jp",
    "oyabe.toyama.jp",
    "taira.toyama.jp",
    "takaoka.toyama.jp",
    "tateyama.toyama.jp",
    "toga.toyama.jp",
    "tonami.toyama.jp",
    "toyama.toyama.jp",
    "unazuki.toyama.jp",
    "uozu.toyama.jp",
    "yamada.toyama.jp",
    "arida.wakayama.jp",
    "aridagawa.wakayama.jp",
    "gobo.wakayama.jp",
    "hashimoto.wakayama.jp",
    "hidaka.wakayama.jp",
    "hirogawa.wakayama.jp",
    "inami.wakayama.jp",
    "iwade.wakayama.jp",
    "kainan.wakayama.jp",
    "kamitonda.wakayama.jp",
    "katsuragi.wakayama.jp",
    "kimino.wakayama.jp",
    "kinokawa.wakayama.jp",
    "kitayama.wakayama.jp",
    "koya.wakayama.jp",
    "koza.wakayama.jp",
    "kozagawa.wakayama.jp",
    "kudoyama.wakayama.jp",
    "kushimoto.wakayama.jp",
    "mihama.wakayama.jp",
    "misato.wakayama.jp",
    "nachikatsuura.wakayama.jp",
    "shingu.wakayama.jp",
    "shirahama.wakayama.jp",
    "taiji.wakayama.jp",
    "tanabe.wakayama.jp",
    "wakayama.wakayama.jp",
    "yuasa.wakayama.jp",
    "yura.wakayama.jp",
    "asahi.yamagata.jp",
    "funagata.yamagata.jp",
    "higashine.yamagata.jp",
    "iide.yamagata.jp",
    "kahoku.yamagata.jp",
    "kaminoyama.yamagata.jp",
    "kaneyama.yamagata.jp",
    "kawanishi.yamagata.jp",
    "mamurogawa.yamagata.jp",
    "mikawa.yamagata.jp",
    "murayama.yamagata.jp",
    "nagai.yamagata.jp",
    "nakayama.yamagata.jp",
    "nanyo.yamagata.jp",
    "nishikawa.yamagata.jp",
    "obanazawa.yamagata.jp",
    "oe.yamagata.jp",
    "oguni.yamagata.jp",
    "ohkura.yamagata.jp",
    "oishida.yamagata.jp",
    "sagae.yamagata.jp",
    "sakata.yamagata.jp",
    "sakegawa.yamagata.jp",
    "shinjo.yamagata.jp",
    "shirataka.yamagata.jp",
    "shonai.yamagata.jp",
    "takahata.yamagata.jp",
    "tendo.yamagata.jp",
    "tozawa.yamagata.jp",
    "tsuruoka.yamagata.jp",
    "yamagata.yamagata.jp",
    "yamanobe.yamagata.jp",
    "yonezawa.yamagata.jp",
    "yuza.yamagata.jp",
    "abu.yamaguchi.jp",
    "hagi.yamaguchi.jp",
    "hikari.yamaguchi.jp",
    "hofu.yamaguchi.jp",
    "iwakuni.yamaguchi.jp",
    "kudamatsu.yamaguchi.jp",
    "mitou.yamaguchi.jp",
    "nagato.yamaguchi.jp",
    "oshima.yamaguchi.jp",
    "shimonoseki.yamaguchi.jp",
    "shunan.yamaguchi.jp",
    "tabuse.yamaguchi.jp",
    "tokuyama.yamaguchi.jp",
    "toyota.yamaguchi.jp",
    "ube.yamaguchi.jp",
    "yuu.yamaguchi.jp",
    "chuo.yamanashi.jp",
    "doshi.yamanashi.jp",
    "fuefuki.yamanashi.jp",
    "fujikawa.yamanashi.jp",
    "fujikawaguchiko.yamanashi.jp",
    "fujiyoshida.yamanashi.jp",
    "hayakawa.yamanashi.jp",
    "hokuto.yamanashi.jp",
    "ichikawamisato.yamanashi.jp",
    "kai.yamanashi.jp",
    "kofu.yamanashi.jp",
    "koshu.yamanashi.jp",
    "kosuge.yamanashi.jp",
    "minami-alps.yamanashi.jp",
    "minobu.yamanashi.jp",
    "nakamichi.yamanashi.jp",
    "nanbu.yamanashi.jp",
    "narusawa.yamanashi.jp",
    "nirasaki.yamanashi.jp",
    "nishikatsura.yamanashi.jp",
    "oshino.yamanashi.jp",
    "otsuki.yamanashi.jp",
    "showa.yamanashi.jp",
    "tabayama.yamanashi.jp",
    "tsuru.yamanashi.jp",
    "uenohara.yamanashi.jp",
    "yamanakako.yamanashi.jp",
    "yamanashi.yamanashi.jp",
    "ke",
    "ac.ke",
    "co.ke",
    "go.ke",
    "info.ke",
    "me.ke",
    "mobi.ke",
    "ne.ke",
    "or.ke",
    "sc.ke",
    "kg",
    "org.kg",
    "net.kg",
    "com.kg",
    "edu.kg",
    "gov.kg",
    "mil.kg",
    "*.kh",
    "ki",
    "edu.ki",
    "biz.ki",
    "net.ki",
    "org.ki",
    "gov.ki",
    "info.ki",
    "com.ki",
    "km",
    "org.km",
    "nom.km",
    "gov.km",
    "prd.km",
    "tm.km",
    "edu.km",
    "mil.km",
    "ass.km",
    "com.km",
    "coop.km",
    "asso.km",
    "presse.km",
    "medecin.km",
    "notaires.km",
    "pharmaciens.km",
    "veterinaire.km",
    "gouv.km",
    "kn",
    "net.kn",
    "org.kn",
    "edu.kn",
    "gov.kn",
    "kp",
    "com.kp",
    "edu.kp",
    "gov.kp",
    "org.kp",
    "rep.kp",
    "tra.kp",
    "kr",
    "ac.kr",
    "co.kr",
    "es.kr",
    "go.kr",
    "hs.kr",
    "kg.kr",
    "mil.kr",
    "ms.kr",
    "ne.kr",
    "or.kr",
    "pe.kr",
    "re.kr",
    "sc.kr",
    "busan.kr",
    "chungbuk.kr",
    "chungnam.kr",
    "daegu.kr",
    "daejeon.kr",
    "gangwon.kr",
    "gwangju.kr",
    "gyeongbuk.kr",
    "gyeonggi.kr",
    "gyeongnam.kr",
    "incheon.kr",
    "jeju.kr",
    "jeonbuk.kr",
    "jeonnam.kr",
    "seoul.kr",
    "ulsan.kr",
    "kw",
    "com.kw",
    "edu.kw",
    "emb.kw",
    "gov.kw",
    "ind.kw",
    "net.kw",
    "org.kw",
    "ky",
    "com.ky",
    "edu.ky",
    "net.ky",
    "org.ky",
    "kz",
    "org.kz",
    "edu.kz",
    "net.kz",
    "gov.kz",
    "mil.kz",
    "com.kz",
    "la",
    "int.la",
    "net.la",
    "info.la",
    "edu.la",
    "gov.la",
    "per.la",
    "com.la",
    "org.la",
    "lb",
    "com.lb",
    "edu.lb",
    "gov.lb",
    "net.lb",
    "org.lb",
    "lc",
    "com.lc",
    "net.lc",
    "co.lc",
    "org.lc",
    "edu.lc",
    "gov.lc",
    "li",
    "lk",
    "gov.lk",
    "sch.lk",
    "net.lk",
    "int.lk",
    "com.lk",
    "org.lk",
    "edu.lk",
    "ngo.lk",
    "soc.lk",
    "web.lk",
    "ltd.lk",
    "assn.lk",
    "grp.lk",
    "hotel.lk",
    "ac.lk",
    "lr",
    "com.lr",
    "edu.lr",
    "gov.lr",
    "org.lr",
    "net.lr",
    "ls",
    "ac.ls",
    "biz.ls",
    "co.ls",
    "edu.ls",
    "gov.ls",
    "info.ls",
    "net.ls",
    "org.ls",
    "sc.ls",
    "lt",
    "gov.lt",
    "lu",
    "lv",
    "com.lv",
    "edu.lv",
    "gov.lv",
    "org.lv",
    "mil.lv",
    "id.lv",
    "net.lv",
    "asn.lv",
    "conf.lv",
    "ly",
    "com.ly",
    "net.ly",
    "gov.ly",
    "plc.ly",
    "edu.ly",
    "sch.ly",
    "med.ly",
    "org.ly",
    "id.ly",
    "ma",
    "co.ma",
    "net.ma",
    "gov.ma",
    "org.ma",
    "ac.ma",
    "press.ma",
    "mc",
    "tm.mc",
    "asso.mc",
    "md",
    "me",
    "co.me",
    "net.me",
    "org.me",
    "edu.me",
    "ac.me",
    "gov.me",
    "its.me",
    "priv.me",
    "mg",
    "org.mg",
    "nom.mg",
    "gov.mg",
    "prd.mg",
    "tm.mg",
    "edu.mg",
    "mil.mg",
    "com.mg",
    "co.mg",
    "mh",
    "mil",
    "mk",
    "com.mk",
    "org.mk",
    "net.mk",
    "edu.mk",
    "gov.mk",
    "inf.mk",
    "name.mk",
    "ml",
    "com.ml",
    "edu.ml",
    "gouv.ml",
    "gov.ml",
    "net.ml",
    "org.ml",
    "presse.ml",
    "*.mm",
    "mn",
    "gov.mn",
    "edu.mn",
    "org.mn",
    "mo",
    "com.mo",
    "net.mo",
    "org.mo",
    "edu.mo",
    "gov.mo",
    "mobi",
    "mp",
    "mq",
    "mr",
    "gov.mr",
    "ms",
    "com.ms",
    "edu.ms",
    "gov.ms",
    "net.ms",
    "org.ms",
    "mt",
    "com.mt",
    "edu.mt",
    "net.mt",
    "org.mt",
    "mu",
    "com.mu",
    "net.mu",
    "org.mu",
    "gov.mu",
    "ac.mu",
    "co.mu",
    "or.mu",
    "museum",
    "academy.museum",
    "agriculture.museum",
    "air.museum",
    "airguard.museum",
    "alabama.museum",
    "alaska.museum",
    "amber.museum",
    "ambulance.museum",
    "american.museum",
    "americana.museum",
    "americanantiques.museum",
    "americanart.museum",
    "amsterdam.museum",
    "and.museum",
    "annefrank.museum",
    "anthro.museum",
    "anthropology.museum",
    "antiques.museum",
    "aquarium.museum",
    "arboretum.museum",
    "archaeological.museum",
    "archaeology.museum",
    "architecture.museum",
    "art.museum",
    "artanddesign.museum",
    "artcenter.museum",
    "artdeco.museum",
    "arteducation.museum",
    "artgallery.museum",
    "arts.museum",
    "artsandcrafts.museum",
    "asmatart.museum",
    "assassination.museum",
    "assisi.museum",
    "association.museum",
    "astronomy.museum",
    "atlanta.museum",
    "austin.museum",
    "australia.museum",
    "automotive.museum",
    "aviation.museum",
    "axis.museum",
    "badajoz.museum",
    "baghdad.museum",
    "bahn.museum",
    "bale.museum",
    "baltimore.museum",
    "barcelona.museum",
    "baseball.museum",
    "basel.museum",
    "baths.museum",
    "bauern.museum",
    "beauxarts.museum",
    "beeldengeluid.museum",
    "bellevue.museum",
    "bergbau.museum",
    "berkeley.museum",
    "berlin.museum",
    "bern.museum",
    "bible.museum",
    "bilbao.museum",
    "bill.museum",
    "birdart.museum",
    "birthplace.museum",
    "bonn.museum",
    "boston.museum",
    "botanical.museum",
    "botanicalgarden.museum",
    "botanicgarden.museum",
    "botany.museum",
    "brandywinevalley.museum",
    "brasil.museum",
    "bristol.museum",
    "british.museum",
    "britishcolumbia.museum",
    "broadcast.museum",
    "brunel.museum",
    "brussel.museum",
    "brussels.museum",
    "bruxelles.museum",
    "building.museum",
    "burghof.museum",
    "bus.museum",
    "bushey.museum",
    "cadaques.museum",
    "california.museum",
    "cambridge.museum",
    "can.museum",
    "canada.museum",
    "capebreton.museum",
    "carrier.museum",
    "cartoonart.museum",
    "casadelamoneda.museum",
    "castle.museum",
    "castres.museum",
    "celtic.museum",
    "center.museum",
    "chattanooga.museum",
    "cheltenham.museum",
    "chesapeakebay.museum",
    "chicago.museum",
    "children.museum",
    "childrens.museum",
    "childrensgarden.museum",
    "chiropractic.museum",
    "chocolate.museum",
    "christiansburg.museum",
    "cincinnati.museum",
    "cinema.museum",
    "circus.museum",
    "civilisation.museum",
    "civilization.museum",
    "civilwar.museum",
    "clinton.museum",
    "clock.museum",
    "coal.museum",
    "coastaldefence.museum",
    "cody.museum",
    "coldwar.museum",
    "collection.museum",
    "colonialwilliamsburg.museum",
    "coloradoplateau.museum",
    "columbia.museum",
    "columbus.museum",
    "communication.museum",
    "communications.museum",
    "community.museum",
    "computer.museum",
    "computerhistory.museum",
    "comunicações.museum",
    "contemporary.museum",
    "contemporaryart.museum",
    "convent.museum",
    "copenhagen.museum",
    "corporation.museum",
    "correios-e-telecomunicações.museum",
    "corvette.museum",
    "costume.museum",
    "countryestate.museum",
    "county.museum",
    "crafts.museum",
    "cranbrook.museum",
    "creation.museum",
    "cultural.museum",
    "culturalcenter.museum",
    "culture.museum",
    "cyber.museum",
    "cymru.museum",
    "dali.museum",
    "dallas.museum",
    "database.museum",
    "ddr.museum",
    "decorativearts.museum",
    "delaware.museum",
    "delmenhorst.museum",
    "denmark.museum",
    "depot.museum",
    "design.museum",
    "detroit.museum",
    "dinosaur.museum",
    "discovery.museum",
    "dolls.museum",
    "donostia.museum",
    "durham.museum",
    "eastafrica.museum",
    "eastcoast.museum",
    "education.museum",
    "educational.museum",
    "egyptian.museum",
    "eisenbahn.museum",
    "elburg.museum",
    "elvendrell.museum",
    "embroidery.museum",
    "encyclopedic.museum",
    "england.museum",
    "entomology.museum",
    "environment.museum",
    "environmentalconservation.museum",
    "epilepsy.museum",
    "essex.museum",
    "estate.museum",
    "ethnology.museum",
    "exeter.museum",
    "exhibition.museum",
    "family.museum",
    "farm.museum",
    "farmequipment.museum",
    "farmers.museum",
    "farmstead.museum",
    "field.museum",
    "figueres.museum",
    "filatelia.museum",
    "film.museum",
    "fineart.museum",
    "finearts.museum",
    "finland.museum",
    "flanders.museum",
    "florida.museum",
    "force.museum",
    "fortmissoula.museum",
    "fortworth.museum",
    "foundation.museum",
    "francaise.museum",
    "frankfurt.museum",
    "franziskaner.museum",
    "freemasonry.museum",
    "freiburg.museum",
    "fribourg.museum",
    "frog.museum",
    "fundacio.museum",
    "furniture.museum",
    "gallery.museum",
    "garden.museum",
    "gateway.museum",
    "geelvinck.museum",
    "gemological.museum",
    "geology.museum",
    "georgia.museum",
    "giessen.museum",
    "glas.museum",
    "glass.museum",
    "gorge.museum",
    "grandrapids.museum",
    "graz.museum",
    "guernsey.museum",
    "halloffame.museum",
    "hamburg.museum",
    "handson.museum",
    "harvestcelebration.museum",
    "hawaii.museum",
    "health.museum",
    "heimatunduhren.museum",
    "hellas.museum",
    "helsinki.museum",
    "hembygdsforbund.museum",
    "heritage.museum",
    "histoire.museum",
    "historical.museum",
    "historicalsociety.museum",
    "historichouses.museum",
    "historisch.museum",
    "historisches.museum",
    "history.museum",
    "historyofscience.museum",
    "horology.museum",
    "house.museum",
    "humanities.museum",
    "illustration.museum",
    "imageandsound.museum",
    "indian.museum",
    "indiana.museum",
    "indianapolis.museum",
    "indianmarket.museum",
    "intelligence.museum",
    "interactive.museum",
    "iraq.museum",
    "iron.museum",
    "isleofman.museum",
    "jamison.museum",
    "jefferson.museum",
    "jerusalem.museum",
    "jewelry.museum",
    "jewish.museum",
    "jewishart.museum",
    "jfk.museum",
    "journalism.museum",
    "judaica.museum",
    "judygarland.museum",
    "juedisches.museum",
    "juif.museum",
    "karate.museum",
    "karikatur.museum",
    "kids.museum",
    "koebenhavn.museum",
    "koeln.museum",
    "kunst.museum",
    "kunstsammlung.museum",
    "kunstunddesign.museum",
    "labor.museum",
    "labour.museum",
    "lajolla.museum",
    "lancashire.museum",
    "landes.museum",
    "lans.museum",
    "läns.museum",
    "larsson.museum",
    "lewismiller.museum",
    "lincoln.museum",
    "linz.museum",
    "living.museum",
    "livinghistory.museum",
    "localhistory.museum",
    "london.museum",
    "losangeles.museum",
    "louvre.museum",
    "loyalist.museum",
    "lucerne.museum",
    "luxembourg.museum",
    "luzern.museum",
    "mad.museum",
    "madrid.museum",
    "mallorca.museum",
    "manchester.museum",
    "mansion.museum",
    "mansions.museum",
    "manx.museum",
    "marburg.museum",
    "maritime.museum",
    "maritimo.museum",
    "maryland.museum",
    "marylhurst.museum",
    "media.museum",
    "medical.museum",
    "medizinhistorisches.museum",
    "meeres.museum",
    "memorial.museum",
    "mesaverde.museum",
    "michigan.museum",
    "midatlantic.museum",
    "military.museum",
    "mill.museum",
    "miners.museum",
    "mining.museum",
    "minnesota.museum",
    "missile.museum",
    "missoula.museum",
    "modern.museum",
    "moma.museum",
    "money.museum",
    "monmouth.museum",
    "monticello.museum",
    "montreal.museum",
    "moscow.museum",
    "motorcycle.museum",
    "muenchen.museum",
    "muenster.museum",
    "mulhouse.museum",
    "muncie.museum",
    "museet.museum",
    "museumcenter.museum",
    "museumvereniging.museum",
    "music.museum",
    "national.museum",
    "nationalfirearms.museum",
    "nationalheritage.museum",
    "nativeamerican.museum",
    "naturalhistory.museum",
    "naturalhistorymuseum.museum",
    "naturalsciences.museum",
    "nature.museum",
    "naturhistorisches.museum",
    "natuurwetenschappen.museum",
    "naumburg.museum",
    "naval.museum",
    "nebraska.museum",
    "neues.museum",
    "newhampshire.museum",
    "newjersey.museum",
    "newmexico.museum",
    "newport.museum",
    "newspaper.museum",
    "newyork.museum",
    "niepce.museum",
    "norfolk.museum",
    "north.museum",
    "nrw.museum",
    "nyc.museum",
    "nyny.museum",
    "oceanographic.museum",
    "oceanographique.museum",
    "omaha.museum",
    "online.museum",
    "ontario.museum",
    "openair.museum",
    "oregon.museum",
    "oregontrail.museum",
    "otago.museum",
    "oxford.museum",
    "pacific.museum",
    "paderborn.museum",
    "palace.museum",
    "paleo.museum",
    "palmsprings.museum",
    "panama.museum",
    "paris.museum",
    "pasadena.museum",
    "pharmacy.museum",
    "philadelphia.museum",
    "philadelphiaarea.museum",
    "philately.museum",
    "phoenix.museum",
    "photography.museum",
    "pilots.museum",
    "pittsburgh.museum",
    "planetarium.museum",
    "plantation.museum",
    "plants.museum",
    "plaza.museum",
    "portal.museum",
    "portland.museum",
    "portlligat.museum",
    "posts-and-telecommunications.museum",
    "preservation.museum",
    "presidio.museum",
    "press.museum",
    "project.museum",
    "public.museum",
    "pubol.museum",
    "quebec.museum",
    "railroad.museum",
    "railway.museum",
    "research.museum",
    "resistance.museum",
    "riodejaneiro.museum",
    "rochester.museum",
    "rockart.museum",
    "roma.museum",
    "russia.museum",
    "saintlouis.museum",
    "salem.museum",
    "salvadordali.museum",
    "salzburg.museum",
    "sandiego.museum",
    "sanfrancisco.museum",
    "santabarbara.museum",
    "santacruz.museum",
    "santafe.museum",
    "saskatchewan.museum",
    "satx.museum",
    "savannahga.museum",
    "schlesisches.museum",
    "schoenbrunn.museum",
    "schokoladen.museum",
    "school.museum",
    "schweiz.museum",
    "science.museum",
    "scienceandhistory.museum",
    "scienceandindustry.museum",
    "sciencecenter.museum",
    "sciencecenters.museum",
    "science-fiction.museum",
    "sciencehistory.museum",
    "sciences.museum",
    "sciencesnaturelles.museum",
    "scotland.museum",
    "seaport.museum",
    "settlement.museum",
    "settlers.museum",
    "shell.museum",
    "sherbrooke.museum",
    "sibenik.museum",
    "silk.museum",
    "ski.museum",
    "skole.museum",
    "society.museum",
    "sologne.museum",
    "soundandvision.museum",
    "southcarolina.museum",
    "southwest.museum",
    "space.museum",
    "spy.museum",
    "square.museum",
    "stadt.museum",
    "stalbans.museum",
    "starnberg.museum",
    "state.museum",
    "stateofdelaware.museum",
    "station.museum",
    "steam.museum",
    "steiermark.museum",
    "stjohn.museum",
    "stockholm.museum",
    "stpetersburg.museum",
    "stuttgart.museum",
    "suisse.museum",
    "surgeonshall.museum",
    "surrey.museum",
    "svizzera.museum",
    "sweden.museum",
    "sydney.museum",
    "tank.museum",
    "tcm.museum",
    "technology.museum",
    "telekommunikation.museum",
    "television.museum",
    "texas.museum",
    "textile.museum",
    "theater.museum",
    "time.museum",
    "timekeeping.museum",
    "topology.museum",
    "torino.museum",
    "touch.museum",
    "town.museum",
    "transport.museum",
    "tree.museum",
    "trolley.museum",
    "trust.museum",
    "trustee.museum",
    "uhren.museum",
    "ulm.museum",
    "undersea.museum",
    "university.museum",
    "usa.museum",
    "usantiques.museum",
    "usarts.museum",
    "uscountryestate.museum",
    "usculture.museum",
    "usdecorativearts.museum",
    "usgarden.museum",
    "ushistory.museum",
    "ushuaia.museum",
    "uslivinghistory.museum",
    "utah.museum",
    "uvic.museum",
    "valley.museum",
    "vantaa.museum",
    "versailles.museum",
    "viking.museum",
    "village.museum",
    "virginia.museum",
    "virtual.museum",
    "virtuel.museum",
    "vlaanderen.museum",
    "volkenkunde.museum",
    "wales.museum",
    "wallonie.museum",
    "war.museum",
    "washingtondc.museum",
    "watchandclock.museum",
    "watch-and-clock.museum",
    "western.museum",
    "westfalen.museum",
    "whaling.museum",
    "wildlife.museum",
    "williamsburg.museum",
    "windmill.museum",
    "workshop.museum",
    "york.museum",
    "yorkshire.museum",
    "yosemite.museum",
    "youth.museum",
    "zoological.museum",
    "zoology.museum",
    "ירושלים.museum",
    "иком.museum",
    "mv",
    "aero.mv",
    "biz.mv",
    "com.mv",
    "coop.mv",
    "edu.mv",
    "gov.mv",
    "info.mv",
    "int.mv",
    "mil.mv",
    "museum.mv",
    "name.mv",
    "net.mv",
    "org.mv",
    "pro.mv",
    "mw",
    "ac.mw",
    "biz.mw",
    "co.mw",
    "com.mw",
    "coop.mw",
    "edu.mw",
    "gov.mw",
    "int.mw",
    "museum.mw",
    "net.mw",
    "org.mw",
    "mx",
    "com.mx",
    "org.mx",
    "gob.mx",
    "edu.mx",
    "net.mx",
    "my",
    "biz.my",
    "com.my",
    "edu.my",
    "gov.my",
    "mil.my",
    "name.my",
    "net.my",
    "org.my",
    "mz",
    "ac.mz",
    "adv.mz",
    "co.mz",
    "edu.mz",
    "gov.mz",
    "mil.mz",
    "net.mz",
    "org.mz",
    "na",
    "info.na",
    "pro.na",
    "name.na",
    "school.na",
    "or.na",
    "dr.na",
    "us.na",
    "mx.na",
    "ca.na",
    "in.na",
    "cc.na",
    "tv.na",
    "ws.na",
    "mobi.na",
    "co.na",
    "com.na",
    "org.na",
    "name",
    "nc",
    "asso.nc",
    "nom.nc",
    "ne",
    "net",
    "nf",
    "com.nf",
    "net.nf",
    "per.nf",
    "rec.nf",
    "web.nf",
    "arts.nf",
    "firm.nf",
    "info.nf",
    "other.nf",
    "store.nf",
    "ng",
    "com.ng",
    "edu.ng",
    "gov.ng",
    "i.ng",
    "mil.ng",
    "mobi.ng",
    "name.ng",
    "net.ng",
    "org.ng",
    "sch.ng",
    "ni",
    "ac.ni",
    "biz.ni",
    "co.ni",
    "com.ni",
    "edu.ni",
    "gob.ni",
    "in.ni",
    "info.ni",
    "int.ni",
    "mil.ni",
    "net.ni",
    "nom.ni",
    "org.ni",
    "web.ni",
    "nl",
    "no",
    "fhs.no",
    "vgs.no",
    "fylkesbibl.no",
    "folkebibl.no",
    "museum.no",
    "idrett.no",
    "priv.no",
    "mil.no",
    "stat.no",
    "dep.no",
    "kommune.no",
    "herad.no",
    "aa.no",
    "ah.no",
    "bu.no",
    "fm.no",
    "hl.no",
    "hm.no",
    "jan-mayen.no",
    "mr.no",
    "nl.no",
    "nt.no",
    "of.no",
    "ol.no",
    "oslo.no",
    "rl.no",
    "sf.no",
    "st.no",
    "svalbard.no",
    "tm.no",
    "tr.no",
    "va.no",
    "vf.no",
    "gs.aa.no",
    "gs.ah.no",
    "gs.bu.no",
    "gs.fm.no",
    "gs.hl.no",
    "gs.hm.no",
    "gs.jan-mayen.no",
    "gs.mr.no",
    "gs.nl.no",
    "gs.nt.no",
    "gs.of.no",
    "gs.ol.no",
    "gs.oslo.no",
    "gs.rl.no",
    "gs.sf.no",
    "gs.st.no",
    "gs.svalbard.no",
    "gs.tm.no",
    "gs.tr.no",
    "gs.va.no",
    "gs.vf.no",
    "akrehamn.no",
    "åkrehamn.no",
    "algard.no",
    "ålgård.no",
    "arna.no",
    "brumunddal.no",
    "bryne.no",
    "bronnoysund.no",
    "brønnøysund.no",
    "drobak.no",
    "drøbak.no",
    "egersund.no",
    "fetsund.no",
    "floro.no",
    "florø.no",
    "fredrikstad.no",
    "hokksund.no",
    "honefoss.no",
    "hønefoss.no",
    "jessheim.no",
    "jorpeland.no",
    "jørpeland.no",
    "kirkenes.no",
    "kopervik.no",
    "krokstadelva.no",
    "langevag.no",
    "langevåg.no",
    "leirvik.no",
    "mjondalen.no",
    "mjøndalen.no",
    "mo-i-rana.no",
    "mosjoen.no",
    "mosjøen.no",
    "nesoddtangen.no",
    "orkanger.no",
    "osoyro.no",
    "osøyro.no",
    "raholt.no",
    "råholt.no",
    "sandnessjoen.no",
    "sandnessjøen.no",
    "skedsmokorset.no",
    "slattum.no",
    "spjelkavik.no",
    "stathelle.no",
    "stavern.no",
    "stjordalshalsen.no",
    "stjørdalshalsen.no",
    "tananger.no",
    "tranby.no",
    "vossevangen.no",
    "afjord.no",
    "åfjord.no",
    "agdenes.no",
    "al.no",
    "ål.no",
    "alesund.no",
    "ålesund.no",
    "alstahaug.no",
    "alta.no",
    "áltá.no",
    "alaheadju.no",
    "álaheadju.no",
    "alvdal.no",
    "amli.no",
    "åmli.no",
    "amot.no",
    "åmot.no",
    "andebu.no",
    "andoy.no",
    "andøy.no",
    "andasuolo.no",
    "ardal.no",
    "årdal.no",
    "aremark.no",
    "arendal.no",
    "ås.no",
    "aseral.no",
    "åseral.no",
    "asker.no",
    "askim.no",
    "askvoll.no",
    "askoy.no",
    "askøy.no",
    "asnes.no",
    "åsnes.no",
    "audnedaln.no",
    "aukra.no",
    "aure.no",
    "aurland.no",
    "aurskog-holand.no",
    "aurskog-høland.no",
    "austevoll.no",
    "austrheim.no",
    "averoy.no",
    "averøy.no",
    "balestrand.no",
    "ballangen.no",
    "balat.no",
    "bálát.no",
    "balsfjord.no",
    "bahccavuotna.no",
    "báhccavuotna.no",
    "bamble.no",
    "bardu.no",
    "beardu.no",
    "beiarn.no",
    "bajddar.no",
    "bájddar.no",
    "baidar.no",
    "báidár.no",
    "berg.no",
    "bergen.no",
    "berlevag.no",
    "berlevåg.no",
    "bearalvahki.no",
    "bearalváhki.no",
    "bindal.no",
    "birkenes.no",
    "bjarkoy.no",
    "bjarkøy.no",
    "bjerkreim.no",
    "bjugn.no",
    "bodo.no",
    "bodø.no",
    "badaddja.no",
    "bådåddjå.no",
    "budejju.no",
    "bokn.no",
    "bremanger.no",
    "bronnoy.no",
    "brønnøy.no",
    "bygland.no",
    "bykle.no",
    "barum.no",
    "bærum.no",
    "bo.telemark.no",
    "bø.telemark.no",
    "bo.nordland.no",
    "bø.nordland.no",
    "bievat.no",
    "bievát.no",
    "bomlo.no",
    "bømlo.no",
    "batsfjord.no",
    "båtsfjord.no",
    "bahcavuotna.no",
    "báhcavuotna.no",
    "dovre.no",
    "drammen.no",
    "drangedal.no",
    "dyroy.no",
    "dyrøy.no",
    "donna.no",
    "dønna.no",
    "eid.no",
    "eidfjord.no",
    "eidsberg.no",
    "eidskog.no",
    "eidsvoll.no",
    "eigersund.no",
    "elverum.no",
    "enebakk.no",
    "engerdal.no",
    "etne.no",
    "etnedal.no",
    "evenes.no",
    "evenassi.no",
    "evenášši.no",
    "evje-og-hornnes.no",
    "farsund.no",
    "fauske.no",
    "fuossko.no",
    "fuoisku.no",
    "fedje.no",
    "fet.no",
    "finnoy.no",
    "finnøy.no",
    "fitjar.no",
    "fjaler.no",
    "fjell.no",
    "flakstad.no",
    "flatanger.no",
    "flekkefjord.no",
    "flesberg.no",
    "flora.no",
    "fla.no",
    "flå.no",
    "folldal.no",
    "forsand.no",
    "fosnes.no",
    "frei.no",
    "frogn.no",
    "froland.no",
    "frosta.no",
    "frana.no",
    "fræna.no",
    "froya.no",
    "frøya.no",
    "fusa.no",
    "fyresdal.no",
    "forde.no",
    "førde.no",
    "gamvik.no",
    "gangaviika.no",
    "gáŋgaviika.no",
    "gaular.no",
    "gausdal.no",
    "gildeskal.no",
    "gildeskål.no",
    "giske.no",
    "gjemnes.no",
    "gjerdrum.no",
    "gjerstad.no",
    "gjesdal.no",
    "gjovik.no",
    "gjøvik.no",
    "gloppen.no",
    "gol.no",
    "gran.no",
    "grane.no",
    "granvin.no",
    "gratangen.no",
    "grimstad.no",
    "grong.no",
    "kraanghke.no",
    "kråanghke.no",
    "grue.no",
    "gulen.no",
    "hadsel.no",
    "halden.no",
    "halsa.no",
    "hamar.no",
    "hamaroy.no",
    "habmer.no",
    "hábmer.no",
    "hapmir.no",
    "hápmir.no",
    "hammerfest.no",
    "hammarfeasta.no",
    "hámmárfeasta.no",
    "haram.no",
    "hareid.no",
    "harstad.no",
    "hasvik.no",
    "aknoluokta.no",
    "ákŋoluokta.no",
    "hattfjelldal.no",
    "aarborte.no",
    "haugesund.no",
    "hemne.no",
    "hemnes.no",
    "hemsedal.no",
    "heroy.more-og-romsdal.no",
    "herøy.møre-og-romsdal.no",
    "heroy.nordland.no",
    "herøy.nordland.no",
    "hitra.no",
    "hjartdal.no",
    "hjelmeland.no",
    "hobol.no",
    "hobøl.no",
    "hof.no",
    "hol.no",
    "hole.no",
    "holmestrand.no",
    "holtalen.no",
    "holtålen.no",
    "hornindal.no",
    "horten.no",
    "hurdal.no",
    "hurum.no",
    "hvaler.no",
    "hyllestad.no",
    "hagebostad.no",
    "hægebostad.no",
    "hoyanger.no",
    "høyanger.no",
    "hoylandet.no",
    "høylandet.no",
    "ha.no",
    "hå.no",
    "ibestad.no",
    "inderoy.no",
    "inderøy.no",
    "iveland.no",
    "jevnaker.no",
    "jondal.no",
    "jolster.no",
    "jølster.no",
    "karasjok.no",
    "karasjohka.no",
    "kárášjohka.no",
    "karlsoy.no",
    "galsa.no",
    "gálsá.no",
    "karmoy.no",
    "karmøy.no",
    "kautokeino.no",
    "guovdageaidnu.no",
    "klepp.no",
    "klabu.no",
    "klæbu.no",
    "kongsberg.no",
    "kongsvinger.no",
    "kragero.no",
    "kragerø.no",
    "kristiansand.no",
    "kristiansund.no",
    "krodsherad.no",
    "krødsherad.no",
    "kvalsund.no",
    "rahkkeravju.no",
    "ráhkkerávju.no",
    "kvam.no",
    "kvinesdal.no",
    "kvinnherad.no",
    "kviteseid.no",
    "kvitsoy.no",
    "kvitsøy.no",
    "kvafjord.no",
    "kvæfjord.no",
    "giehtavuoatna.no",
    "kvanangen.no",
    "kvænangen.no",
    "navuotna.no",
    "návuotna.no",
    "kafjord.no",
    "kåfjord.no",
    "gaivuotna.no",
    "gáivuotna.no",
    "larvik.no",
    "lavangen.no",
    "lavagis.no",
    "loabat.no",
    "loabát.no",
    "lebesby.no",
    "davvesiida.no",
    "leikanger.no",
    "leirfjord.no",
    "leka.no",
    "leksvik.no",
    "lenvik.no",
    "leangaviika.no",
    "leaŋgaviika.no",
    "lesja.no",
    "levanger.no",
    "lier.no",
    "lierne.no",
    "lillehammer.no",
    "lillesand.no",
    "lindesnes.no",
    "lindas.no",
    "lindås.no",
    "lom.no",
    "loppa.no",
    "lahppi.no",
    "láhppi.no",
    "lund.no",
    "lunner.no",
    "luroy.no",
    "lurøy.no",
    "luster.no",
    "lyngdal.no",
    "lyngen.no",
    "ivgu.no",
    "lardal.no",
    "lerdal.no",
    "lærdal.no",
    "lodingen.no",
    "lødingen.no",
    "lorenskog.no",
    "lørenskog.no",
    "loten.no",
    "løten.no",
    "malvik.no",
    "masoy.no",
    "måsøy.no",
    "muosat.no",
    "muosát.no",
    "mandal.no",
    "marker.no",
    "marnardal.no",
    "masfjorden.no",
    "meland.no",
    "meldal.no",
    "melhus.no",
    "meloy.no",
    "meløy.no",
    "meraker.no",
    "meråker.no",
    "moareke.no",
    "moåreke.no",
    "midsund.no",
    "midtre-gauldal.no",
    "modalen.no",
    "modum.no",
    "molde.no",
    "moskenes.no",
    "moss.no",
    "mosvik.no",
    "malselv.no",
    "målselv.no",
    "malatvuopmi.no",
    "málatvuopmi.no",
    "namdalseid.no",
    "aejrie.no",
    "namsos.no",
    "namsskogan.no",
    "naamesjevuemie.no",
    "nååmesjevuemie.no",
    "laakesvuemie.no",
    "nannestad.no",
    "narvik.no",
    "narviika.no",
    "naustdal.no",
    "nedre-eiker.no",
    "nes.akershus.no",
    "nes.buskerud.no",
    "nesna.no",
    "nesodden.no",
    "nesseby.no",
    "unjarga.no",
    "unjárga.no",
    "nesset.no",
    "nissedal.no",
    "nittedal.no",
    "nord-aurdal.no",
    "nord-fron.no",
    "nord-odal.no",
    "norddal.no",
    "nordkapp.no",
    "davvenjarga.no",
    "davvenjárga.no",
    "nordre-land.no",
    "nordreisa.no",
    "raisa.no",
    "ráisa.no",
    "nore-og-uvdal.no",
    "notodden.no",
    "naroy.no",
    "nærøy.no",
    "notteroy.no",
    "nøtterøy.no",
    "odda.no",
    "oksnes.no",
    "øksnes.no",
    "oppdal.no",
    "oppegard.no",
    "oppegård.no",
    "orkdal.no",
    "orland.no",
    "ørland.no",
    "orskog.no",
    "ørskog.no",
    "orsta.no",
    "ørsta.no",
    "os.hedmark.no",
    "os.hordaland.no",
    "osen.no",
    "osteroy.no",
    "osterøy.no",
    "ostre-toten.no",
    "østre-toten.no",
    "overhalla.no",
    "ovre-eiker.no",
    "øvre-eiker.no",
    "oyer.no",
    "øyer.no",
    "oygarden.no",
    "øygarden.no",
    "oystre-slidre.no",
    "øystre-slidre.no",
    "porsanger.no",
    "porsangu.no",
    "porsáŋgu.no",
    "porsgrunn.no",
    "radoy.no",
    "radøy.no",
    "rakkestad.no",
    "rana.no",
    "ruovat.no",
    "randaberg.no",
    "rauma.no",
    "rendalen.no",
    "rennebu.no",
    "rennesoy.no",
    "rennesøy.no",
    "rindal.no",
    "ringebu.no",
    "ringerike.no",
    "ringsaker.no",
    "rissa.no",
    "risor.no",
    "risør.no",
    "roan.no",
    "rollag.no",
    "rygge.no",
    "ralingen.no",
    "rælingen.no",
    "rodoy.no",
    "rødøy.no",
    "romskog.no",
    "rømskog.no",
    "roros.no",
    "røros.no",
    "rost.no",
    "røst.no",
    "royken.no",
    "røyken.no",
    "royrvik.no",
    "røyrvik.no",
    "rade.no",
    "råde.no",
    "salangen.no",
    "siellak.no",
    "saltdal.no",
    "salat.no",
    "sálát.no",
    "sálat.no",
    "samnanger.no",
    "sande.more-og-romsdal.no",
    "sande.møre-og-romsdal.no",
    "sande.vestfold.no",
    "sandefjord.no",
    "sandnes.no",
    "sandoy.no",
    "sandøy.no",
    "sarpsborg.no",
    "sauda.no",
    "sauherad.no",
    "sel.no",
    "selbu.no",
    "selje.no",
    "seljord.no",
    "sigdal.no",
    "siljan.no",
    "sirdal.no",
    "skaun.no",
    "skedsmo.no",
    "ski.no",
    "skien.no",
    "skiptvet.no",
    "skjervoy.no",
    "skjervøy.no",
    "skierva.no",
    "skiervá.no",
    "skjak.no",
    "skjåk.no",
    "skodje.no",
    "skanland.no",
    "skånland.no",
    "skanit.no",
    "skánit.no",
    "smola.no",
    "smøla.no",
    "snillfjord.no",
    "snasa.no",
    "snåsa.no",
    "snoasa.no",
    "snaase.no",
    "snåase.no",
    "sogndal.no",
    "sokndal.no",
    "sola.no",
    "solund.no",
    "songdalen.no",
    "sortland.no",
    "spydeberg.no",
    "stange.no",
    "stavanger.no",
    "steigen.no",
    "steinkjer.no",
    "stjordal.no",
    "stjørdal.no",
    "stokke.no",
    "stor-elvdal.no",
    "stord.no",
    "stordal.no",
    "storfjord.no",
    "omasvuotna.no",
    "strand.no",
    "stranda.no",
    "stryn.no",
    "sula.no",
    "suldal.no",
    "sund.no",
    "sunndal.no",
    "surnadal.no",
    "sveio.no",
    "svelvik.no",
    "sykkylven.no",
    "sogne.no",
    "søgne.no",
    "somna.no",
    "sømna.no",
    "sondre-land.no",
    "søndre-land.no",
    "sor-aurdal.no",
    "sør-aurdal.no",
    "sor-fron.no",
    "sør-fron.no",
    "sor-odal.no",
    "sør-odal.no",
    "sor-varanger.no",
    "sør-varanger.no",
    "matta-varjjat.no",
    "mátta-várjjat.no",
    "sorfold.no",
    "sørfold.no",
    "sorreisa.no",
    "sørreisa.no",
    "sorum.no",
    "sørum.no",
    "tana.no",
    "deatnu.no",
    "time.no",
    "tingvoll.no",
    "tinn.no",
    "tjeldsund.no",
    "dielddanuorri.no",
    "tjome.no",
    "tjøme.no",
    "tokke.no",
    "tolga.no",
    "torsken.no",
    "tranoy.no",
    "tranøy.no",
    "tromso.no",
    "tromsø.no",
    "tromsa.no",
    "romsa.no",
    "trondheim.no",
    "troandin.no",
    "trysil.no",
    "trana.no",
    "træna.no",
    "trogstad.no",
    "trøgstad.no",
    "tvedestrand.no",
    "tydal.no",
    "tynset.no",
    "tysfjord.no",
    "divtasvuodna.no",
    "divttasvuotna.no",
    "tysnes.no",
    "tysvar.no",
    "tysvær.no",
    "tonsberg.no",
    "tønsberg.no",
    "ullensaker.no",
    "ullensvang.no",
    "ulvik.no",
    "utsira.no",
    "vadso.no",
    "vadsø.no",
    "cahcesuolo.no",
    "čáhcesuolo.no",
    "vaksdal.no",
    "valle.no",
    "vang.no",
    "vanylven.no",
    "vardo.no",
    "vardø.no",
    "varggat.no",
    "várggát.no",
    "vefsn.no",
    "vaapste.no",
    "vega.no",
    "vegarshei.no",
    "vegårshei.no",
    "vennesla.no",
    "verdal.no",
    "verran.no",
    "vestby.no",
    "vestnes.no",
    "vestre-slidre.no",
    "vestre-toten.no",
    "vestvagoy.no",
    "vestvågøy.no",
    "vevelstad.no",
    "vik.no",
    "vikna.no",
    "vindafjord.no",
    "volda.no",
    "voss.no",
    "varoy.no",
    "værøy.no",
    "vagan.no",
    "vågan.no",
    "voagat.no",
    "vagsoy.no",
    "vågsøy.no",
    "vaga.no",
    "vågå.no",
    "valer.ostfold.no",
    "våler.østfold.no",
    "valer.hedmark.no",
    "våler.hedmark.no",
    "*.np",
    "nr",
    "biz.nr",
    "info.nr",
    "gov.nr",
    "edu.nr",
    "org.nr",
    "net.nr",
    "com.nr",
    "nu",
    "nz",
    "ac.nz",
    "co.nz",
    "cri.nz",
    "geek.nz",
    "gen.nz",
    "govt.nz",
    "health.nz",
    "iwi.nz",
    "kiwi.nz",
    "maori.nz",
    "mil.nz",
    "māori.nz",
    "net.nz",
    "org.nz",
    "parliament.nz",
    "school.nz",
    "om",
    "co.om",
    "com.om",
    "edu.om",
    "gov.om",
    "med.om",
    "museum.om",
    "net.om",
    "org.om",
    "pro.om",
    "onion",
    "org",
    "pa",
    "ac.pa",
    "gob.pa",
    "com.pa",
    "org.pa",
    "sld.pa",
    "edu.pa",
    "net.pa",
    "ing.pa",
    "abo.pa",
    "med.pa",
    "nom.pa",
    "pe",
    "edu.pe",
    "gob.pe",
    "nom.pe",
    "mil.pe",
    "org.pe",
    "com.pe",
    "net.pe",
    "pf",
    "com.pf",
    "org.pf",
    "edu.pf",
    "*.pg",
    "ph",
    "com.ph",
    "net.ph",
    "org.ph",
    "gov.ph",
    "edu.ph",
    "ngo.ph",
    "mil.ph",
    "i.ph",
    "pk",
    "com.pk",
    "net.pk",
    "edu.pk",
    "org.pk",
    "fam.pk",
    "biz.pk",
    "web.pk",
    "gov.pk",
    "gob.pk",
    "gok.pk",
    "gon.pk",
    "gop.pk",
    "gos.pk",
    "info.pk",
    "pl",
    "com.pl",
    "net.pl",
    "org.pl",
    "aid.pl",
    "agro.pl",
    "atm.pl",
    "auto.pl",
    "biz.pl",
    "edu.pl",
    "gmina.pl",
    "gsm.pl",
    "info.pl",
    "mail.pl",
    "miasta.pl",
    "media.pl",
    "mil.pl",
    "nieruchomosci.pl",
    "nom.pl",
    "pc.pl",
    "powiat.pl",
    "priv.pl",
    "realestate.pl",
    "rel.pl",
    "sex.pl",
    "shop.pl",
    "sklep.pl",
    "sos.pl",
    "szkola.pl",
    "targi.pl",
    "tm.pl",
    "tourism.pl",
    "travel.pl",
    "turystyka.pl",
    "gov.pl",
    "ap.gov.pl",
    "ic.gov.pl",
    "is.gov.pl",
    "us.gov.pl",
    "kmpsp.gov.pl",
    "kppsp.gov.pl",
    "kwpsp.gov.pl",
    "psp.gov.pl",
    "wskr.gov.pl",
    "kwp.gov.pl",
    "mw.gov.pl",
    "ug.gov.pl",
    "um.gov.pl",
    "umig.gov.pl",
    "ugim.gov.pl",
    "upow.gov.pl",
    "uw.gov.pl",
    "starostwo.gov.pl",
    "pa.gov.pl",
    "po.gov.pl",
    "psse.gov.pl",
    "pup.gov.pl",
    "rzgw.gov.pl",
    "sa.gov.pl",
    "so.gov.pl",
    "sr.gov.pl",
    "wsa.gov.pl",
    "sko.gov.pl",
    "uzs.gov.pl",
    "wiih.gov.pl",
    "winb.gov.pl",
    "pinb.gov.pl",
    "wios.gov.pl",
    "witd.gov.pl",
    "wzmiuw.gov.pl",
    "piw.gov.pl",
    "wiw.gov.pl",
    "griw.gov.pl",
    "wif.gov.pl",
    "oum.gov.pl",
    "sdn.gov.pl",
    "zp.gov.pl",
    "uppo.gov.pl",
    "mup.gov.pl",
    "wuoz.gov.pl",
    "konsulat.gov.pl",
    "oirm.gov.pl",
    "augustow.pl",
    "babia-gora.pl",
    "bedzin.pl",
    "beskidy.pl",
    "bialowieza.pl",
    "bialystok.pl",
    "bielawa.pl",
    "bieszczady.pl",
    "boleslawiec.pl",
    "bydgoszcz.pl",
    "bytom.pl",
    "cieszyn.pl",
    "czeladz.pl",
    "czest.pl",
    "dlugoleka.pl",
    "elblag.pl",
    "elk.pl",
    "glogow.pl",
    "gniezno.pl",
    "gorlice.pl",
    "grajewo.pl",
    "ilawa.pl",
    "jaworzno.pl",
    "jelenia-gora.pl",
    "jgora.pl",
    "kalisz.pl",
    "kazimierz-dolny.pl",
    "karpacz.pl",
    "kartuzy.pl",
    "kaszuby.pl",
    "katowice.pl",
    "kepno.pl",
    "ketrzyn.pl",
    "klodzko.pl",
    "kobierzyce.pl",
    "kolobrzeg.pl",
    "konin.pl",
    "konskowola.pl",
    "kutno.pl",
    "lapy.pl",
    "lebork.pl",
    "legnica.pl",
    "lezajsk.pl",
    "limanowa.pl",
    "lomza.pl",
    "lowicz.pl",
    "lubin.pl",
    "lukow.pl",
    "malbork.pl",
    "malopolska.pl",
    "mazowsze.pl",
    "mazury.pl",
    "mielec.pl",
    "mielno.pl",
    "mragowo.pl",
    "naklo.pl",
    "nowaruda.pl",
    "nysa.pl",
    "olawa.pl",
    "olecko.pl",
    "olkusz.pl",
    "olsztyn.pl",
    "opoczno.pl",
    "opole.pl",
    "ostroda.pl",
    "ostroleka.pl",
    "ostrowiec.pl",
    "ostrowwlkp.pl",
    "pila.pl",
    "pisz.pl",
    "podhale.pl",
    "podlasie.pl",
    "polkowice.pl",
    "pomorze.pl",
    "pomorskie.pl",
    "prochowice.pl",
    "pruszkow.pl",
    "przeworsk.pl",
    "pulawy.pl",
    "radom.pl",
    "rawa-maz.pl",
    "rybnik.pl",
    "rzeszow.pl",
    "sanok.pl",
    "sejny.pl",
    "slask.pl",
    "slupsk.pl",
    "sosnowiec.pl",
    "stalowa-wola.pl",
    "skoczow.pl",
    "starachowice.pl",
    "stargard.pl",
    "suwalki.pl",
    "swidnica.pl",
    "swiebodzin.pl",
    "swinoujscie.pl",
    "szczecin.pl",
    "szczytno.pl",
    "tarnobrzeg.pl",
    "tgory.pl",
    "turek.pl",
    "tychy.pl",
    "ustka.pl",
    "walbrzych.pl",
    "warmia.pl",
    "warszawa.pl",
    "waw.pl",
    "wegrow.pl",
    "wielun.pl",
    "wlocl.pl",
    "wloclawek.pl",
    "wodzislaw.pl",
    "wolomin.pl",
    "wroclaw.pl",
    "zachpomor.pl",
    "zagan.pl",
    "zarow.pl",
    "zgora.pl",
    "zgorzelec.pl",
    "pm",
    "pn",
    "gov.pn",
    "co.pn",
    "org.pn",
    "edu.pn",
    "net.pn",
    "post",
    "pr",
    "com.pr",
    "net.pr",
    "org.pr",
    "gov.pr",
    "edu.pr",
    "isla.pr",
    "pro.pr",
    "biz.pr",
    "info.pr",
    "name.pr",
    "est.pr",
    "prof.pr",
    "ac.pr",
    "pro",
    "aaa.pro",
    "aca.pro",
    "acct.pro",
    "avocat.pro",
    "bar.pro",
    "cpa.pro",
    "eng.pro",
    "jur.pro",
    "law.pro",
    "med.pro",
    "recht.pro",
    "ps",
    "edu.ps",
    "gov.ps",
    "sec.ps",
    "plo.ps",
    "com.ps",
    "org.ps",
    "net.ps",
    "pt",
    "net.pt",
    "gov.pt",
    "org.pt",
    "edu.pt",
    "int.pt",
    "publ.pt",
    "com.pt",
    "nome.pt",
    "pw",
    "co.pw",
    "ne.pw",
    "or.pw",
    "ed.pw",
    "go.pw",
    "belau.pw",
    "py",
    "com.py",
    "coop.py",
    "edu.py",
    "gov.py",
    "mil.py",
    "net.py",
    "org.py",
    "qa",
    "com.qa",
    "edu.qa",
    "gov.qa",
    "mil.qa",
    "name.qa",
    "net.qa",
    "org.qa",
    "sch.qa",
    "re",
    "asso.re",
    "com.re",
    "nom.re",
    "ro",
    "arts.ro",
    "com.ro",
    "firm.ro",
    "info.ro",
    "nom.ro",
    "nt.ro",
    "org.ro",
    "rec.ro",
    "store.ro",
    "tm.ro",
    "www.ro",
    "rs",
    "ac.rs",
    "co.rs",
    "edu.rs",
    "gov.rs",
    "in.rs",
    "org.rs",
    "ru",
    "rw",
    "ac.rw",
    "co.rw",
    "coop.rw",
    "gov.rw",
    "mil.rw",
    "net.rw",
    "org.rw",
    "sa",
    "com.sa",
    "net.sa",
    "org.sa",
    "gov.sa",
    "med.sa",
    "pub.sa",
    "edu.sa",
    "sch.sa",
    "sb",
    "com.sb",
    "edu.sb",
    "gov.sb",
    "net.sb",
    "org.sb",
    "sc",
    "com.sc",
    "gov.sc",
    "net.sc",
    "org.sc",
    "edu.sc",
    "sd",
    "com.sd",
    "net.sd",
    "org.sd",
    "edu.sd",
    "med.sd",
    "tv.sd",
    "gov.sd",
    "info.sd",
    "se",
    "a.se",
    "ac.se",
    "b.se",
    "bd.se",
    "brand.se",
    "c.se",
    "d.se",
    "e.se",
    "f.se",
    "fh.se",
    "fhsk.se",
    "fhv.se",
    "g.se",
    "h.se",
    "i.se",
    "k.se",
    "komforb.se",
    "kommunalforbund.se",
    "komvux.se",
    "l.se",
    "lanbib.se",
    "m.se",
    "n.se",
    "naturbruksgymn.se",
    "o.se",
    "org.se",
    "p.se",
    "parti.se",
    "pp.se",
    "press.se",
    "r.se",
    "s.se",
    "t.se",
    "tm.se",
    "u.se",
    "w.se",
    "x.se",
    "y.se",
    "z.se",
    "sg",
    "com.sg",
    "net.sg",
    "org.sg",
    "gov.sg",
    "edu.sg",
    "per.sg",
    "sh",
    "com.sh",
    "net.sh",
    "gov.sh",
    "org.sh",
    "mil.sh",
    "si",
    "sj",
    "sk",
    "sl",
    "com.sl",
    "net.sl",
    "edu.sl",
    "gov.sl",
    "org.sl",
    "sm",
    "sn",
    "art.sn",
    "com.sn",
    "edu.sn",
    "gouv.sn",
    "org.sn",
    "perso.sn",
    "univ.sn",
    "so",
    "com.so",
    "edu.so",
    "gov.so",
    "me.so",
    "net.so",
    "org.so",
    "sr",
    "ss",
    "biz.ss",
    "com.ss",
    "edu.ss",
    "gov.ss",
    "me.ss",
    "net.ss",
    "org.ss",
    "sch.ss",
    "st",
    "co.st",
    "com.st",
    "consulado.st",
    "edu.st",
    "embaixada.st",
    "mil.st",
    "net.st",
    "org.st",
    "principe.st",
    "saotome.st",
    "store.st",
    "su",
    "sv",
    "com.sv",
    "edu.sv",
    "gob.sv",
    "org.sv",
    "red.sv",
    "sx",
    "gov.sx",
    "sy",
    "edu.sy",
    "gov.sy",
    "net.sy",
    "mil.sy",
    "com.sy",
    "org.sy",
    "sz",
    "co.sz",
    "ac.sz",
    "org.sz",
    "tc",
    "td",
    "tel",
    "tf",
    "tg",
    "th",
    "ac.th",
    "co.th",
    "go.th",
    "in.th",
    "mi.th",
    "net.th",
    "or.th",
    "tj",
    "ac.tj",
    "biz.tj",
    "co.tj",
    "com.tj",
    "edu.tj",
    "go.tj",
    "gov.tj",
    "int.tj",
    "mil.tj",
    "name.tj",
    "net.tj",
    "nic.tj",
    "org.tj",
    "test.tj",
    "web.tj",
    "tk",
    "tl",
    "gov.tl",
    "tm",
    "com.tm",
    "co.tm",
    "org.tm",
    "net.tm",
    "nom.tm",
    "gov.tm",
    "mil.tm",
    "edu.tm",
    "tn",
    "com.tn",
    "ens.tn",
    "fin.tn",
    "gov.tn",
    "ind.tn",
    "info.tn",
    "intl.tn",
    "mincom.tn",
    "nat.tn",
    "net.tn",
    "org.tn",
    "perso.tn",
    "tourism.tn",
    "to",
    "com.to",
    "gov.to",
    "net.to",
    "org.to",
    "edu.to",
    "mil.to",
    "tr",
    "av.tr",
    "bbs.tr",
    "bel.tr",
    "biz.tr",
    "com.tr",
    "dr.tr",
    "edu.tr",
    "gen.tr",
    "gov.tr",
    "info.tr",
    "mil.tr",
    "k12.tr",
    "kep.tr",
    "name.tr",
    "net.tr",
    "org.tr",
    "pol.tr",
    "tel.tr",
    "tsk.tr",
    "tv.tr",
    "web.tr",
    "nc.tr",
    "gov.nc.tr",
    "tt",
    "co.tt",
    "com.tt",
    "org.tt",
    "net.tt",
    "biz.tt",
    "info.tt",
    "pro.tt",
    "int.tt",
    "coop.tt",
    "jobs.tt",
    "mobi.tt",
    "travel.tt",
    "museum.tt",
    "aero.tt",
    "name.tt",
    "gov.tt",
    "edu.tt",
    "tv",
    "tw",
    "edu.tw",
    "gov.tw",
    "mil.tw",
    "com.tw",
    "net.tw",
    "org.tw",
    "idv.tw",
    "game.tw",
    "ebiz.tw",
    "club.tw",
    "網路.tw",
    "組織.tw",
    "商業.tw",
    "tz",
    "ac.tz",
    "co.tz",
    "go.tz",
    "hotel.tz",
    "info.tz",
    "me.tz",
    "mil.tz",
    "mobi.tz",
    "ne.tz",
    "or.tz",
    "sc.tz",
    "tv.tz",
    "ua",
    "com.ua",
    "edu.ua",
    "gov.ua",
    "in.ua",
    "net.ua",
    "org.ua",
    "cherkassy.ua",
    "cherkasy.ua",
    "chernigov.ua",
    "chernihiv.ua",
    "chernivtsi.ua",
    "chernovtsy.ua",
    "ck.ua",
    "cn.ua",
    "cr.ua",
    "crimea.ua",
    "cv.ua",
    "dn.ua",
    "dnepropetrovsk.ua",
    "dnipropetrovsk.ua",
    "donetsk.ua",
    "dp.ua",
    "if.ua",
    "ivano-frankivsk.ua",
    "kh.ua",
    "kharkiv.ua",
    "kharkov.ua",
    "kherson.ua",
    "khmelnitskiy.ua",
    "khmelnytskyi.ua",
    "kiev.ua",
    "kirovograd.ua",
    "km.ua",
    "kr.ua",
    "krym.ua",
    "ks.ua",
    "kv.ua",
    "kyiv.ua",
    "lg.ua",
    "lt.ua",
    "lugansk.ua",
    "lutsk.ua",
    "lv.ua",
    "lviv.ua",
    "mk.ua",
    "mykolaiv.ua",
    "nikolaev.ua",
    "od.ua",
    "odesa.ua",
    "odessa.ua",
    "pl.ua",
    "poltava.ua",
    "rivne.ua",
    "rovno.ua",
    "rv.ua",
    "sb.ua",
    "sebastopol.ua",
    "sevastopol.ua",
    "sm.ua",
    "sumy.ua",
    "te.ua",
    "ternopil.ua",
    "uz.ua",
    "uzhgorod.ua",
    "vinnica.ua",
    "vinnytsia.ua",
    "vn.ua",
    "volyn.ua",
    "yalta.ua",
    "zaporizhzhe.ua",
    "zaporizhzhia.ua",
    "zhitomir.ua",
    "zhytomyr.ua",
    "zp.ua",
    "zt.ua",
    "ug",
    "co.ug",
    "or.ug",
    "ac.ug",
    "sc.ug",
    "go.ug",
    "ne.ug",
    "com.ug",
    "org.ug",
    "uk",
    "ac.uk",
    "co.uk",
    "gov.uk",
    "ltd.uk",
    "me.uk",
    "net.uk",
    "nhs.uk",
    "org.uk",
    "plc.uk",
    "police.uk",
    "*.sch.uk",
    "us",
    "dni.us",
    "fed.us",
    "isa.us",
    "kids.us",
    "nsn.us",
    "ak.us",
    "al.us",
    "ar.us",
    "as.us",
    "az.us",
    "ca.us",
    "co.us",
    "ct.us",
    "dc.us",
    "de.us",
    "fl.us",
    "ga.us",
    "gu.us",
    "hi.us",
    "ia.us",
    "id.us",
    "il.us",
    "in.us",
    "ks.us",
    "ky.us",
    "la.us",
    "ma.us",
    "md.us",
    "me.us",
    "mi.us",
    "mn.us",
    "mo.us",
    "ms.us",
    "mt.us",
    "nc.us",
    "nd.us",
    "ne.us",
    "nh.us",
    "nj.us",
    "nm.us",
    "nv.us",
    "ny.us",
    "oh.us",
    "ok.us",
    "or.us",
    "pa.us",
    "pr.us",
    "ri.us",
    "sc.us",
    "sd.us",
    "tn.us",
    "tx.us",
    "ut.us",
    "vi.us",
    "vt.us",
    "va.us",
    "wa.us",
    "wi.us",
    "wv.us",
    "wy.us",
    "k12.ak.us",
    "k12.al.us",
    "k12.ar.us",
    "k12.as.us",
    "k12.az.us",
    "k12.ca.us",
    "k12.co.us",
    "k12.ct.us",
    "k12.dc.us",
    "k12.de.us",
    "k12.fl.us",
    "k12.ga.us",
    "k12.gu.us",
    "k12.ia.us",
    "k12.id.us",
    "k12.il.us",
    "k12.in.us",
    "k12.ks.us",
    "k12.ky.us",
    "k12.la.us",
    "k12.ma.us",
    "k12.md.us",
    "k12.me.us",
    "k12.mi.us",
    "k12.mn.us",
    "k12.mo.us",
    "k12.ms.us",
    "k12.mt.us",
    "k12.nc.us",
    "k12.ne.us",
    "k12.nh.us",
    "k12.nj.us",
    "k12.nm.us",
    "k12.nv.us",
    "k12.ny.us",
    "k12.oh.us",
    "k12.ok.us",
    "k12.or.us",
    "k12.pa.us",
    "k12.pr.us",
    "k12.sc.us",
    "k12.tn.us",
    "k12.tx.us",
    "k12.ut.us",
    "k12.vi.us",
    "k12.vt.us",
    "k12.va.us",
    "k12.wa.us",
    "k12.wi.us",
    "k12.wy.us",
    "cc.ak.us",
    "cc.al.us",
    "cc.ar.us",
    "cc.as.us",
    "cc.az.us",
    "cc.ca.us",
    "cc.co.us",
    "cc.ct.us",
    "cc.dc.us",
    "cc.de.us",
    "cc.fl.us",
    "cc.ga.us",
    "cc.gu.us",
    "cc.hi.us",
    "cc.ia.us",
    "cc.id.us",
    "cc.il.us",
    "cc.in.us",
    "cc.ks.us",
    "cc.ky.us",
    "cc.la.us",
    "cc.ma.us",
    "cc.md.us",
    "cc.me.us",
    "cc.mi.us",
    "cc.mn.us",
    "cc.mo.us",
    "cc.ms.us",
    "cc.mt.us",
    "cc.nc.us",
    "cc.nd.us",
    "cc.ne.us",
    "cc.nh.us",
    "cc.nj.us",
    "cc.nm.us",
    "cc.nv.us",
    "cc.ny.us",
    "cc.oh.us",
    "cc.ok.us",
    "cc.or.us",
    "cc.pa.us",
    "cc.pr.us",
    "cc.ri.us",
    "cc.sc.us",
    "cc.sd.us",
    "cc.tn.us",
    "cc.tx.us",
    "cc.ut.us",
    "cc.vi.us",
    "cc.vt.us",
    "cc.va.us",
    "cc.wa.us",
    "cc.wi.us",
    "cc.wv.us",
    "cc.wy.us",
    "lib.ak.us",
    "lib.al.us",
    "lib.ar.us",
    "lib.as.us",
    "lib.az.us",
    "lib.ca.us",
    "lib.co.us",
    "lib.ct.us",
    "lib.dc.us",
    "lib.fl.us",
    "lib.ga.us",
    "lib.gu.us",
    "lib.hi.us",
    "lib.ia.us",
    "lib.id.us",
    "lib.il.us",
    "lib.in.us",
    "lib.ks.us",
    "lib.ky.us",
    "lib.la.us",
    "lib.ma.us",
    "lib.md.us",
    "lib.me.us",
    "lib.mi.us",
    "lib.mn.us",
    "lib.mo.us",
    "lib.ms.us",
    "lib.mt.us",
    "lib.nc.us",
    "lib.nd.us",
    "lib.ne.us",
    "lib.nh.us",
    "lib.nj.us",
    "lib.nm.us",
    "lib.nv.us",
    "lib.ny.us",
    "lib.oh.us",
    "lib.ok.us",
    "lib.or.us",
    "lib.pa.us",
    "lib.pr.us",
    "lib.ri.us",
    "lib.sc.us",
    "lib.sd.us",
    "lib.tn.us",
    "lib.tx.us",
    "lib.ut.us",
    "lib.vi.us",
    "lib.vt.us",
    "lib.va.us",
    "lib.wa.us",
    "lib.wi.us",
    "lib.wy.us",
    "pvt.k12.ma.us",
    "chtr.k12.ma.us",
    "paroch.k12.ma.us",
    "ann-arbor.mi.us",
    "cog.mi.us",
    "dst.mi.us",
    "eaton.mi.us",
    "gen.mi.us",
    "mus.mi.us",
    "tec.mi.us",
    "washtenaw.mi.us",
    "uy",
    "com.uy",
    "edu.uy",
    "gub.uy",
    "mil.uy",
    "net.uy",
    "org.uy",
    "uz",
    "co.uz",
    "com.uz",
    "net.uz",
    "org.uz",
    "va",
    "vc",
    "com.vc",
    "net.vc",
    "org.vc",
    "gov.vc",
    "mil.vc",
    "edu.vc",
    "ve",
    "arts.ve",
    "bib.ve",
    "co.ve",
    "com.ve",
    "e12.ve",
    "edu.ve",
    "firm.ve",
    "gob.ve",
    "gov.ve",
    "info.ve",
    "int.ve",
    "mil.ve",
    "net.ve",
    "nom.ve",
    "org.ve",
    "rar.ve",
    "rec.ve",
    "store.ve",
    "tec.ve",
    "web.ve",
    "vg",
    "vi",
    "co.vi",
    "com.vi",
    "k12.vi",
    "net.vi",
    "org.vi",
    "vn",
    "com.vn",
    "net.vn",
    "org.vn",
    "edu.vn",
    "gov.vn",
    "int.vn",
    "ac.vn",
    "biz.vn",
    "info.vn",
    "name.vn",
    "pro.vn",
    "health.vn",
    "vu",
    "com.vu",
    "edu.vu",
    "net.vu",
    "org.vu",
    "wf",
    "ws",
    "com.ws",
    "net.ws",
    "org.ws",
    "gov.ws",
    "edu.ws",
    "yt",
    "امارات",
    "հայ",
    "বাংলা",
    "бг",
    "البحرين",
    "бел",
    "中国",
    "中國",
    "الجزائر",
    "مصر",
    "ею",
    "ευ",
    "موريتانيا",
    "გე",
    "ελ",
    "香港",
    "公司.香港",
    "教育.香港",
    "政府.香港",
    "個人.香港",
    "網絡.香港",
    "組織.香港",
    "ಭಾರತ",
    "ଭାରତ",
    "ভাৰত",
    "भारतम्",
    "भारोत",
    "ڀارت",
    "ഭാരതം",
    "भारत",
    "بارت",
    "بھارت",
    "భారత్",
    "ભારત",
    "ਭਾਰਤ",
    "ভারত",
    "இந்தியா",
    "ایران",
    "ايران",
    "عراق",
    "الاردن",
    "한국",
    "қаз",
    "ລາວ",
    "ලංකා",
    "இலங்கை",
    "المغرب",
    "мкд",
    "мон",
    "澳門",
    "澳门",
    "مليسيا",
    "عمان",
    "پاکستان",
    "پاكستان",
    "فلسطين",
    "срб",
    "пр.срб",
    "орг.срб",
    "обр.срб",
    "од.срб",
    "упр.срб",
    "ак.срб",
    "рф",
    "قطر",
    "السعودية",
    "السعودیة",
    "السعودیۃ",
    "السعوديه",
    "سودان",
    "新加坡",
    "சிங்கப்பூர்",
    "سورية",
    "سوريا",
    "ไทย",
    "ศึกษา.ไทย",
    "ธุรกิจ.ไทย",
    "รัฐบาล.ไทย",
    "ทหาร.ไทย",
    "เน็ต.ไทย",
    "องค์กร.ไทย",
    "تونس",
    "台灣",
    "台湾",
    "臺灣",
    "укр",
    "اليمن",
    "xxx",
    "ye",
    "com.ye",
    "edu.ye",
    "gov.ye",
    "net.ye",
    "mil.ye",
    "org.ye",
    "ac.za",
    "agric.za",
    "alt.za",
    "co.za",
    "edu.za",
    "gov.za",
    "grondar.za",
    "law.za",
    "mil.za",
    "net.za",
    "ngo.za",
    "nic.za",
    "nis.za",
    "nom.za",
    "org.za",
    "school.za",
    "tm.za",
    "web.za",
    "zm",
    "ac.zm",
    "biz.zm",
    "co.zm",
    "com.zm",
    "edu.zm",
    "gov.zm",
    "info.zm",
    "mil.zm",
    "net.zm",
    "org.zm",
    "sch.zm",
    "zw",
    "ac.zw",
    "co.zw",
    "gov.zw",
    "mil.zw",
    "org.zw",
    "aaa",
    "aarp",
    "abarth",
    "abb",
    "abbott",
    "abbvie",
    "abc",
    "able",
    "abogado",
    "abudhabi",
    "academy",
    "accenture",
    "accountant",
    "accountants",
    "aco",
    "actor",
    "adac",
    "ads",
    "adult",
    "aeg",
    "aetna",
    "afl",
    "africa",
    "agakhan",
    "agency",
    "aig",
    "airbus",
    "airforce",
    "airtel",
    "akdn",
    "alfaromeo",
    "alibaba",
    "alipay",
    "allfinanz",
    "allstate",
    "ally",
    "alsace",
    "alstom",
    "amazon",
    "americanexpress",
    "americanfamily",
    "amex",
    "amfam",
    "amica",
    "amsterdam",
    "analytics",
    "android",
    "anquan",
    "anz",
    "aol",
    "apartments",
    "app",
    "apple",
    "aquarelle",
    "arab",
    "aramco",
    "archi",
    "army",
    "art",
    "arte",
    "asda",
    "associates",
    "athleta",
    "attorney",
    "auction",
    "audi",
    "audible",
    "audio",
    "auspost",
    "author",
    "auto",
    "autos",
    "avianca",
    "aws",
    "axa",
    "azure",
    "baby",
    "baidu",
    "banamex",
    "bananarepublic",
    "band",
    "bank",
    "bar",
    "barcelona",
    "barclaycard",
    "barclays",
    "barefoot",
    "bargains",
    "baseball",
    "basketball",
    "bauhaus",
    "bayern",
    "bbc",
    "bbt",
    "bbva",
    "bcg",
    "bcn",
    "beats",
    "beauty",
    "beer",
    "bentley",
    "berlin",
    "best",
    "bestbuy",
    "bet",
    "bharti",
    "bible",
    "bid",
    "bike",
    "bing",
    "bingo",
    "bio",
    "black",
    "blackfriday",
    "blockbuster",
    "blog",
    "bloomberg",
    "blue",
    "bms",
    "bmw",
    "bnpparibas",
    "boats",
    "boehringer",
    "bofa",
    "bom",
    "bond",
    "boo",
    "book",
    "booking",
    "bosch",
    "bostik",
    "boston",
    "bot",
    "boutique",
    "box",
    "bradesco",
    "bridgestone",
    "broadway",
    "broker",
    "brother",
    "brussels",
    "bugatti",
    "build",
    "builders",
    "business",
    "buy",
    "buzz",
    "bzh",
    "cab",
    "cafe",
    "cal",
    "call",
    "calvinklein",
    "cam",
    "camera",
    "camp",
    "cancerresearch",
    "canon",
    "capetown",
    "capital",
    "capitalone",
    "car",
    "caravan",
    "cards",
    "care",
    "career",
    "careers",
    "cars",
    "casa",
    "case",
    "cash",
    "casino",
    "catering",
    "catholic",
    "cba",
    "cbn",
    "cbre",
    "cbs",
    "center",
    "ceo",
    "cern",
    "cfa",
    "cfd",
    "chanel",
    "channel",
    "charity",
    "chase",
    "chat",
    "cheap",
    "chintai",
    "christmas",
    "chrome",
    "church",
    "cipriani",
    "circle",
    "cisco",
    "citadel",
    "citi",
    "citic",
    "city",
    "cityeats",
    "claims",
    "cleaning",
    "click",
    "clinic",
    "clinique",
    "clothing",
    "cloud",
    "club",
    "clubmed",
    "coach",
    "codes",
    "coffee",
    "college",
    "cologne",
    "comcast",
    "commbank",
    "community",
    "company",
    "compare",
    "computer",
    "comsec",
    "condos",
    "construction",
    "consulting",
    "contact",
    "contractors",
    "cooking",
    "cookingchannel",
    "cool",
    "corsica",
    "country",
    "coupon",
    "coupons",
    "courses",
    "cpa",
    "credit",
    "creditcard",
    "creditunion",
    "cricket",
    "crown",
    "crs",
    "cruise",
    "cruises",
    "cuisinella",
    "cymru",
    "cyou",
    "dabur",
    "dad",
    "dance",
    "data",
    "date",
    "dating",
    "datsun",
    "day",
    "dclk",
    "dds",
    "deal",
    "dealer",
    "deals",
    "degree",
    "delivery",
    "dell",
    "deloitte",
    "delta",
    "democrat",
    "dental",
    "dentist",
    "desi",
    "design",
    "dev",
    "dhl",
    "diamonds",
    "diet",
    "digital",
    "direct",
    "directory",
    "discount",
    "discover",
    "dish",
    "diy",
    "dnp",
    "docs",
    "doctor",
    "dog",
    "domains",
    "dot",
    "download",
    "drive",
    "dtv",
    "dubai",
    "dunlop",
    "dupont",
    "durban",
    "dvag",
    "dvr",
    "earth",
    "eat",
    "eco",
    "edeka",
    "education",
    "email",
    "emerck",
    "energy",
    "engineer",
    "engineering",
    "enterprises",
    "epson",
    "equipment",
    "ericsson",
    "erni",
    "esq",
    "estate",
    "etisalat",
    "eurovision",
    "eus",
    "events",
    "exchange",
    "expert",
    "exposed",
    "express",
    "extraspace",
    "fage",
    "fail",
    "fairwinds",
    "faith",
    "family",
    "fan",
    "fans",
    "farm",
    "farmers",
    "fashion",
    "fast",
    "fedex",
    "feedback",
    "ferrari",
    "ferrero",
    "fiat",
    "fidelity",
    "fido",
    "film",
    "final",
    "finance",
    "financial",
    "fire",
    "firestone",
    "firmdale",
    "fish",
    "fishing",
    "fit",
    "fitness",
    "flickr",
    "flights",
    "flir",
    "florist",
    "flowers",
    "fly",
    "foo",
    "food",
    "foodnetwork",
    "football",
    "ford",
    "forex",
    "forsale",
    "forum",
    "foundation",
    "fox",
    "free",
    "fresenius",
    "frl",
    "frogans",
    "frontdoor",
    "frontier",
    "ftr",
    "fujitsu",
    "fun",
    "fund",
    "furniture",
    "futbol",
    "fyi",
    "gal",
    "gallery",
    "gallo",
    "gallup",
    "game",
    "games",
    "gap",
    "garden",
    "gay",
    "gbiz",
    "gdn",
    "gea",
    "gent",
    "genting",
    "george",
    "ggee",
    "gift",
    "gifts",
    "gives",
    "giving",
    "glass",
    "gle",
    "global",
    "globo",
    "gmail",
    "gmbh",
    "gmo",
    "gmx",
    "godaddy",
    "gold",
    "goldpoint",
    "golf",
    "goo",
    "goodyear",
    "goog",
    "google",
    "gop",
    "got",
    "grainger",
    "graphics",
    "gratis",
    "green",
    "gripe",
    "grocery",
    "group",
    "guardian",
    "gucci",
    "guge",
    "guide",
    "guitars",
    "guru",
    "hair",
    "hamburg",
    "hangout",
    "haus",
    "hbo",
    "hdfc",
    "hdfcbank",
    "health",
    "healthcare",
    "help",
    "helsinki",
    "here",
    "hermes",
    "hgtv",
    "hiphop",
    "hisamitsu",
    "hitachi",
    "hiv",
    "hkt",
    "hockey",
    "holdings",
    "holiday",
    "homedepot",
    "homegoods",
    "homes",
    "homesense",
    "honda",
    "horse",
    "hospital",
    "host",
    "hosting",
    "hot",
    "hoteles",
    "hotels",
    "hotmail",
    "house",
    "how",
    "hsbc",
    "hughes",
    "hyatt",
    "hyundai",
    "ibm",
    "icbc",
    "ice",
    "icu",
    "ieee",
    "ifm",
    "ikano",
    "imamat",
    "imdb",
    "immo",
    "immobilien",
    "inc",
    "industries",
    "infiniti",
    "ing",
    "ink",
    "institute",
    "insurance",
    "insure",
    "international",
    "intuit",
    "investments",
    "ipiranga",
    "irish",
    "ismaili",
    "ist",
    "istanbul",
    "itau",
    "itv",
    "jaguar",
    "java",
    "jcb",
    "jeep",
    "jetzt",
    "jewelry",
    "jio",
    "jll",
    "jmp",
    "jnj",
    "joburg",
    "jot",
    "joy",
    "jpmorgan",
    "jprs",
    "juegos",
    "juniper",
    "kaufen",
    "kddi",
    "kerryhotels",
    "kerrylogistics",
    "kerryproperties",
    "kfh",
    "kia",
    "kids",
    "kim",
    "kinder",
    "kindle",
    "kitchen",
    "kiwi",
    "koeln",
    "komatsu",
    "kosher",
    "kpmg",
    "kpn",
    "krd",
    "kred",
    "kuokgroup",
    "kyoto",
    "lacaixa",
    "lamborghini",
    "lamer",
    "lancaster",
    "lancia",
    "land",
    "landrover",
    "lanxess",
    "lasalle",
    "lat",
    "latino",
    "latrobe",
    "law",
    "lawyer",
    "lds",
    "lease",
    "leclerc",
    "lefrak",
    "legal",
    "lego",
    "lexus",
    "lgbt",
    "lidl",
    "life",
    "lifeinsurance",
    "lifestyle",
    "lighting",
    "like",
    "lilly",
    "limited",
    "limo",
    "lincoln",
    "linde",
    "link",
    "lipsy",
    "live",
    "living",
    "llc",
    "llp",
    "loan",
    "loans",
    "locker",
    "locus",
    "loft",
    "lol",
    "london",
    "lotte",
    "lotto",
    "love",
    "lpl",
    "lplfinancial",
    "ltd",
    "ltda",
    "lundbeck",
    "luxe",
    "luxury",
    "macys",
    "madrid",
    "maif",
    "maison",
    "makeup",
    "man",
    "management",
    "mango",
    "map",
    "market",
    "marketing",
    "markets",
    "marriott",
    "marshalls",
    "maserati",
    "mattel",
    "mba",
    "mckinsey",
    "med",
    "media",
    "meet",
    "melbourne",
    "meme",
    "memorial",
    "men",
    "menu",
    "merckmsd",
    "miami",
    "microsoft",
    "mini",
    "mint",
    "mit",
    "mitsubishi",
    "mlb",
    "mls",
    "mma",
    "mobile",
    "moda",
    "moe",
    "moi",
    "mom",
    "monash",
    "money",
    "monster",
    "mormon",
    "mortgage",
    "moscow",
    "moto",
    "motorcycles",
    "mov",
    "movie",
    "msd",
    "mtn",
    "mtr",
    "music",
    "mutual",
    "nab",
    "nagoya",
    "natura",
    "navy",
    "nba",
    "nec",
    "netbank",
    "netflix",
    "network",
    "neustar",
    "new",
    "news",
    "next",
    "nextdirect",
    "nexus",
    "nfl",
    "ngo",
    "nhk",
    "nico",
    "nike",
    "nikon",
    "ninja",
    "nissan",
    "nissay",
    "nokia",
    "northwesternmutual",
    "norton",
    "now",
    "nowruz",
    "nowtv",
    "nra",
    "nrw",
    "ntt",
    "nyc",
    "obi",
    "observer",
    "office",
    "okinawa",
    "olayan",
    "olayangroup",
    "oldnavy",
    "ollo",
    "omega",
    "one",
    "ong",
    "onl",
    "online",
    "ooo",
    "open",
    "oracle",
    "orange",
    "organic",
    "origins",
    "osaka",
    "otsuka",
    "ott",
    "ovh",
    "page",
    "panasonic",
    "paris",
    "pars",
    "partners",
    "parts",
    "party",
    "passagens",
    "pay",
    "pccw",
    "pet",
    "pfizer",
    "pharmacy",
    "phd",
    "philips",
    "phone",
    "photo",
    "photography",
    "photos",
    "physio",
    "pics",
    "pictet",
    "pictures",
    "pid",
    "pin",
    "ping",
    "pink",
    "pioneer",
    "pizza",
    "place",
    "play",
    "playstation",
    "plumbing",
    "plus",
    "pnc",
    "pohl",
    "poker",
    "politie",
    "porn",
    "pramerica",
    "praxi",
    "press",
    "prime",
    "prod",
    "productions",
    "prof",
    "progressive",
    "promo",
    "properties",
    "property",
    "protection",
    "pru",
    "prudential",
    "pub",
    "pwc",
    "qpon",
    "quebec",
    "quest",
    "racing",
    "radio",
    "read",
    "realestate",
    "realtor",
    "realty",
    "recipes",
    "red",
    "redstone",
    "redumbrella",
    "rehab",
    "reise",
    "reisen",
    "reit",
    "reliance",
    "ren",
    "rent",
    "rentals",
    "repair",
    "report",
    "republican",
    "rest",
    "restaurant",
    "review",
    "reviews",
    "rexroth",
    "rich",
    "richardli",
    "ricoh",
    "ril",
    "rio",
    "rip",
    "rocher",
    "rocks",
    "rodeo",
    "rogers",
    "room",
    "rsvp",
    "rugby",
    "ruhr",
    "run",
    "rwe",
    "ryukyu",
    "saarland",
    "safe",
    "safety",
    "sakura",
    "sale",
    "salon",
    "samsclub",
    "samsung",
    "sandvik",
    "sandvikcoromant",
    "sanofi",
    "sap",
    "sarl",
    "sas",
    "save",
    "saxo",
    "sbi",
    "sbs",
    "sca",
    "scb",
    "schaeffler",
    "schmidt",
    "scholarships",
    "school",
    "schule",
    "schwarz",
    "science",
    "scot",
    "search",
    "seat",
    "secure",
    "security",
    "seek",
    "select",
    "sener",
    "services",
    "ses",
    "seven",
    "sew",
    "sex",
    "sexy",
    "sfr",
    "shangrila",
    "sharp",
    "shaw",
    "shell",
    "shia",
    "shiksha",
    "shoes",
    "shop",
    "shopping",
    "shouji",
    "show",
    "showtime",
    "silk",
    "sina",
    "singles",
    "site",
    "ski",
    "skin",
    "sky",
    "skype",
    "sling",
    "smart",
    "smile",
    "sncf",
    "soccer",
    "social",
    "softbank",
    "software",
    "sohu",
    "solar",
    "solutions",
    "song",
    "sony",
    "soy",
    "spa",
    "space",
    "sport",
    "spot",
    "srl",
    "stada",
    "staples",
    "star",
    "statebank",
    "statefarm",
    "stc",
    "stcgroup",
    "stockholm",
    "storage",
    "store",
    "stream",
    "studio",
    "study",
    "style",
    "sucks",
    "supplies",
    "supply",
    "support",
    "surf",
    "surgery",
    "suzuki",
    "swatch",
    "swiss",
    "sydney",
    "systems",
    "tab",
    "taipei",
    "talk",
    "taobao",
    "target",
    "tatamotors",
    "tatar",
    "tattoo",
    "tax",
    "taxi",
    "tci",
    "tdk",
    "team",
    "tech",
    "technology",
    "temasek",
    "tennis",
    "teva",
    "thd",
    "theater",
    "theatre",
    "tiaa",
    "tickets",
    "tienda",
    "tiffany",
    "tips",
    "tires",
    "tirol",
    "tjmaxx",
    "tjx",
    "tkmaxx",
    "tmall",
    "today",
    "tokyo",
    "tools",
    "top",
    "toray",
    "toshiba",
    "total",
    "tours",
    "town",
    "toyota",
    "toys",
    "trade",
    "trading",
    "training",
    "travel",
    "travelchannel",
    "travelers",
    "travelersinsurance",
    "trust",
    "trv",
    "tube",
    "tui",
    "tunes",
    "tushu",
    "tvs",
    "ubank",
    "ubs",
    "unicom",
    "university",
    "uno",
    "uol",
    "ups",
    "vacations",
    "vana",
    "vanguard",
    "vegas",
    "ventures",
    "verisign",
    "versicherung",
    "vet",
    "viajes",
    "video",
    "vig",
    "viking",
    "villas",
    "vin",
    "vip",
    "virgin",
    "visa",
    "vision",
    "viva",
    "vivo",
    "vlaanderen",
    "vodka",
    "volkswagen",
    "volvo",
    "vote",
    "voting",
    "voto",
    "voyage",
    "vuelos",
    "wales",
    "walmart",
    "walter",
    "wang",
    "wanggou",
    "watch",
    "watches",
    "weather",
    "weatherchannel",
    "webcam",
    "weber",
    "website",
    "wedding",
    "weibo",
    "weir",
    "whoswho",
    "wien",
    "wiki",
    "williamhill",
    "win",
    "windows",
    "wine",
    "winners",
    "wme",
    "wolterskluwer",
    "woodside",
    "work",
    "works",
    "world",
    "wow",
    "wtc",
    "wtf",
    "xbox",
    "xerox",
    "xfinity",
    "xihuan",
    "xin",
    "कॉम",
    "セール",
    "佛山",
    "慈善",
    "集团",
    "在线",
    "点看",
    "คอม",
    "八卦",
    "موقع",
    "公益",
    "公司",
    "香格里拉",
    "网站",
    "移动",
    "我爱你",
    "москва",
    "католик",
    "онлайн",
    "сайт",
    "联通",
    "קום",
    "时尚",
    "微博",
    "淡马锡",
    "ファッション",
    "орг",
    "नेट",
    "ストア",
    "アマゾン",
    "삼성",
    "商标",
    "商店",
    "商城",
    "дети",
    "ポイント",
    "新闻",
    "家電",
    "كوم",
    "中文网",
    "中信",
    "娱乐",
    "谷歌",
    "電訊盈科",
    "购物",
    "クラウド",
    "通販",
    "网店",
    "संगठन",
    "餐厅",
    "网络",
    "ком",
    "亚马逊",
    "诺基亚",
    "食品",
    "飞利浦",
    "手机",
    "ارامكو",
    "العليان",
    "اتصالات",
    "بازار",
    "ابوظبي",
    "كاثوليك",
    "همراه",
    "닷컴",
    "政府",
    "شبكة",
    "بيتك",
    "عرب",
    "机构",
    "组织机构",
    "健康",
    "招聘",
    "рус",
    "大拿",
    "みんな",
    "グーグル",
    "世界",
    "書籍",
    "网址",
    "닷넷",
    "コム",
    "天主教",
    "游戏",
    "vermögensberater",
    "vermögensberatung",
    "企业",
    "信息",
    "嘉里大酒店",
    "嘉里",
    "广东",
    "政务",
    "xyz",
    "yachts",
    "yahoo",
    "yamaxun",
    "yandex",
    "yodobashi",
    "yoga",
    "yokohama",
    "you",
    "youtube",
    "yun",
    "zappos",
    "zara",
    "zero",
    "zip",
    "zone",
    "zuerich",
    "cc.ua",
    "inf.ua",
    "ltd.ua",
    "611.to",
    "graphox.us",
    "*.devcdnaccesso.com",
    "adobeaemcloud.com",
    "*.dev.adobeaemcloud.com",
    "hlx.live",
    "adobeaemcloud.net",
    "hlx.page",
    "hlx3.page",
    "beep.pl",
    "airkitapps.com",
    "airkitapps-au.com",
    "airkitapps.eu",
    "aivencloud.com",
    "barsy.ca",
    "*.compute.estate",
    "*.alces.network",
    "kasserver.com",
    "altervista.org",
    "alwaysdata.net",
    "cloudfront.net",
    "*.compute.amazonaws.com",
    "*.compute-1.amazonaws.com",
    "*.compute.amazonaws.com.cn",
    "us-east-1.amazonaws.com",
    "cn-north-1.eb.amazonaws.com.cn",
    "cn-northwest-1.eb.amazonaws.com.cn",
    "elasticbeanstalk.com",
    "ap-northeast-1.elasticbeanstalk.com",
    "ap-northeast-2.elasticbeanstalk.com",
    "ap-northeast-3.elasticbeanstalk.com",
    "ap-south-1.elasticbeanstalk.com",
    "ap-southeast-1.elasticbeanstalk.com",
    "ap-southeast-2.elasticbeanstalk.com",
    "ca-central-1.elasticbeanstalk.com",
    "eu-central-1.elasticbeanstalk.com",
    "eu-west-1.elasticbeanstalk.com",
    "eu-west-2.elasticbeanstalk.com",
    "eu-west-3.elasticbeanstalk.com",
    "sa-east-1.elasticbeanstalk.com",
    "us-east-1.elasticbeanstalk.com",
    "us-east-2.elasticbeanstalk.com",
    "us-gov-west-1.elasticbeanstalk.com",
    "us-west-1.elasticbeanstalk.com",
    "us-west-2.elasticbeanstalk.com",
    "*.elb.amazonaws.com",
    "*.elb.amazonaws.com.cn",
    "awsglobalaccelerator.com",
    "s3.amazonaws.com",
    "s3-ap-northeast-1.amazonaws.com",
    "s3-ap-northeast-2.amazonaws.com",
    "s3-ap-south-1.amazonaws.com",
    "s3-ap-southeast-1.amazonaws.com",
    "s3-ap-southeast-2.amazonaws.com",
    "s3-ca-central-1.amazonaws.com",
    "s3-eu-central-1.amazonaws.com",
    "s3-eu-west-1.amazonaws.com",
    "s3-eu-west-2.amazonaws.com",
    "s3-eu-west-3.amazonaws.com",
    "s3-external-1.amazonaws.com",
    "s3-fips-us-gov-west-1.amazonaws.com",
    "s3-sa-east-1.amazonaws.com",
    "s3-us-gov-west-1.amazonaws.com",
    "s3-us-east-2.amazonaws.com",
    "s3-us-west-1.amazonaws.com",
    "s3-us-west-2.amazonaws.com",
    "s3.ap-northeast-2.amazonaws.com",
    "s3.ap-south-1.amazonaws.com",
    "s3.cn-north-1.amazonaws.com.cn",
    "s3.ca-central-1.amazonaws.com",
    "s3.eu-central-1.amazonaws.com",
    "s3.eu-west-2.amazonaws.com",
    "s3.eu-west-3.amazonaws.com",
    "s3.us-east-2.amazonaws.com",
    "s3.dualstack.ap-northeast-1.amazonaws.com",
    "s3.dualstack.ap-northeast-2.amazonaws.com",
    "s3.dualstack.ap-south-1.amazonaws.com",
    "s3.dualstack.ap-southeast-1.amazonaws.com",
    "s3.dualstack.ap-southeast-2.amazonaws.com",
    "s3.dualstack.ca-central-1.amazonaws.com",
    "s3.dualstack.eu-central-1.amazonaws.com",
    "s3.dualstack.eu-west-1.amazonaws.com",
    "s3.dualstack.eu-west-2.amazonaws.com",
    "s3.dualstack.eu-west-3.amazonaws.com",
    "s3.dualstack.sa-east-1.amazonaws.com",
    "s3.dualstack.us-east-1.amazonaws.com",
    "s3.dualstack.us-east-2.amazonaws.com",
    "s3-website-us-east-1.amazonaws.com",
    "s3-website-us-west-1.amazonaws.com",
    "s3-website-us-west-2.amazonaws.com",
    "s3-website-ap-northeast-1.amazonaws.com",
    "s3-website-ap-southeast-1.amazonaws.com",
    "s3-website-ap-southeast-2.amazonaws.com",
    "s3-website-eu-west-1.amazonaws.com",
    "s3-website-sa-east-1.amazonaws.com",
    "s3-website.ap-northeast-2.amazonaws.com",
    "s3-website.ap-south-1.amazonaws.com",
    "s3-website.ca-central-1.amazonaws.com",
    "s3-website.eu-central-1.amazonaws.com",
    "s3-website.eu-west-2.amazonaws.com",
    "s3-website.eu-west-3.amazonaws.com",
    "s3-website.us-east-2.amazonaws.com",
    "t3l3p0rt.net",
    "tele.amune.org",
    "apigee.io",
    "siiites.com",
    "appspacehosted.com",
    "appspaceusercontent.com",
    "appudo.net",
    "on-aptible.com",
    "user.aseinet.ne.jp",
    "gv.vc",
    "d.gv.vc",
    "user.party.eus",
    "pimienta.org",
    "poivron.org",
    "potager.org",
    "sweetpepper.org",
    "myasustor.com",
    "cdn.prod.atlassian-dev.net",
    "translated.page",
    "myfritz.net",
    "onavstack.net",
    "*.awdev.ca",
    "*.advisor.ws",
    "ecommerce-shop.pl",
    "b-data.io",
    "backplaneapp.io",
    "balena-devices.com",
    "rs.ba",
    "*.banzai.cloud",
    "app.banzaicloud.io",
    "*.backyards.banzaicloud.io",
    "base.ec",
    "official.ec",
    "buyshop.jp",
    "fashionstore.jp",
    "handcrafted.jp",
    "kawaiishop.jp",
    "supersale.jp",
    "theshop.jp",
    "shopselect.net",
    "base.shop",
    "*.beget.app",
    "betainabox.com",
    "bnr.la",
    "bitbucket.io",
    "blackbaudcdn.net",
    "of.je",
    "bluebite.io",
    "boomla.net",
    "boutir.com",
    "boxfuse.io",
    "square7.ch",
    "bplaced.com",
    "bplaced.de",
    "square7.de",
    "bplaced.net",
    "square7.net",
    "shop.brendly.rs",
    "browsersafetymark.io",
    "uk0.bigv.io",
    "dh.bytemark.co.uk",
    "vm.bytemark.co.uk",
    "cafjs.com",
    "mycd.eu",
    "drr.ac",
    "uwu.ai",
    "carrd.co",
    "crd.co",
    "ju.mp",
    "ae.org",
    "br.com",
    "cn.com",
    "com.de",
    "com.se",
    "de.com",
    "eu.com",
    "gb.net",
    "hu.net",
    "jp.net",
    "jpn.com",
    "mex.com",
    "ru.com",
    "sa.com",
    "se.net",
    "uk.com",
    "uk.net",
    "us.com",
    "za.bz",
    "za.com",
    "ar.com",
    "hu.com",
    "kr.com",
    "no.com",
    "qc.com",
    "uy.com",
    "africa.com",
    "gr.com",
    "in.net",
    "web.in",
    "us.org",
    "co.com",
    "aus.basketball",
    "nz.basketball",
    "radio.am",
    "radio.fm",
    "c.la",
    "certmgr.org",
    "cx.ua",
    "discourse.group",
    "discourse.team",
    "cleverapps.io",
    "clerk.app",
    "clerkstage.app",
    "*.lcl.dev",
    "*.lclstage.dev",
    "*.stg.dev",
    "*.stgstage.dev",
    "clickrising.net",
    "c66.me",
    "cloud66.ws",
    "cloud66.zone",
    "jdevcloud.com",
    "wpdevcloud.com",
    "cloudaccess.host",
    "freesite.host",
    "cloudaccess.net",
    "cloudcontrolled.com",
    "cloudcontrolapp.com",
    "*.cloudera.site",
    "pages.dev",
    "trycloudflare.com",
    "workers.dev",
    "wnext.app",
    "co.ca",
    "*.otap.co",
    "co.cz",
    "c.cdn77.org",
    "cdn77-ssl.net",
    "r.cdn77.net",
    "rsc.cdn77.org",
    "ssl.origin.cdn77-secure.org",
    "cloudns.asia",
    "cloudns.biz",
    "cloudns.club",
    "cloudns.cc",
    "cloudns.eu",
    "cloudns.in",
    "cloudns.info",
    "cloudns.org",
    "cloudns.pro",
    "cloudns.pw",
    "cloudns.us",
    "cnpy.gdn",
    "codeberg.page",
    "co.nl",
    "co.no",
    "webhosting.be",
    "hosting-cluster.nl",
    "ac.ru",
    "edu.ru",
    "gov.ru",
    "int.ru",
    "mil.ru",
    "test.ru",
    "dyn.cosidns.de",
    "dynamisches-dns.de",
    "dnsupdater.de",
    "internet-dns.de",
    "l-o-g-i-n.de",
    "dynamic-dns.info",
    "feste-ip.net",
    "knx-server.net",
    "static-access.net",
    "realm.cz",
    "*.cryptonomic.net",
    "cupcake.is",
    "curv.dev",
    "*.customer-oci.com",
    "*.oci.customer-oci.com",
    "*.ocp.customer-oci.com",
    "*.ocs.customer-oci.com",
    "cyon.link",
    "cyon.site",
    "fnwk.site",
    "folionetwork.site",
    "platform0.app",
    "daplie.me",
    "localhost.daplie.me",
    "dattolocal.com",
    "dattorelay.com",
    "dattoweb.com",
    "mydatto.com",
    "dattolocal.net",
    "mydatto.net",
    "biz.dk",
    "co.dk",
    "firm.dk",
    "reg.dk",
    "store.dk",
    "dyndns.dappnode.io",
    "*.dapps.earth",
    "*.bzz.dapps.earth",
    "builtwithdark.com",
    "demo.datadetect.com",
    "instance.datadetect.com",
    "edgestack.me",
    "ddns5.com",
    "debian.net",
    "deno.dev",
    "deno-staging.dev",
    "dedyn.io",
    "deta.app",
    "deta.dev",
    "*.rss.my.id",
    "*.diher.solutions",
    "discordsays.com",
    "discordsez.com",
    "jozi.biz",
    "dnshome.de",
    "online.th",
    "shop.th",
    "drayddns.com",
    "shoparena.pl",
    "dreamhosters.com",
    "mydrobo.com",
    "drud.io",
    "drud.us",
    "duckdns.org",
    "bip.sh",
    "bitbridge.net",
    "dy.fi",
    "tunk.org",
    "dyndns-at-home.com",
    "dyndns-at-work.com",
    "dyndns-blog.com",
    "dyndns-free.com",
    "dyndns-home.com",
    "dyndns-ip.com",
    "dyndns-mail.com",
    "dyndns-office.com",
    "dyndns-pics.com",
    "dyndns-remote.com",
    "dyndns-server.com",
    "dyndns-web.com",
    "dyndns-wiki.com",
    "dyndns-work.com",
    "dyndns.biz",
    "dyndns.info",
    "dyndns.org",
    "dyndns.tv",
    "at-band-camp.net",
    "ath.cx",
    "barrel-of-knowledge.info",
    "barrell-of-knowledge.info",
    "better-than.tv",
    "blogdns.com",
    "blogdns.net",
    "blogdns.org",
    "blogsite.org",
    "boldlygoingnowhere.org",
    "broke-it.net",
    "buyshouses.net",
    "cechire.com",
    "dnsalias.com",
    "dnsalias.net",
    "dnsalias.org",
    "dnsdojo.com",
    "dnsdojo.net",
    "dnsdojo.org",
    "does-it.net",
    "doesntexist.com",
    "doesntexist.org",
    "dontexist.com",
    "dontexist.net",
    "dontexist.org",
    "doomdns.com",
    "doomdns.org",
    "dvrdns.org",
    "dyn-o-saur.com",
    "dynalias.com",
    "dynalias.net",
    "dynalias.org",
    "dynathome.net",
    "dyndns.ws",
    "endofinternet.net",
    "endofinternet.org",
    "endoftheinternet.org",
    "est-a-la-maison.com",
    "est-a-la-masion.com",
    "est-le-patron.com",
    "est-mon-blogueur.com",
    "for-better.biz",
    "for-more.biz",
    "for-our.info",
    "for-some.biz",
    "for-the.biz",
    "forgot.her.name",
    "forgot.his.name",
    "from-ak.com",
    "from-al.com",
    "from-ar.com",
    "from-az.net",
    "from-ca.com",
    "from-co.net",
    "from-ct.com",
    "from-dc.com",
    "from-de.com",
    "from-fl.com",
    "from-ga.com",
    "from-hi.com",
    "from-ia.com",
    "from-id.com",
    "from-il.com",
    "from-in.com",
    "from-ks.com",
    "from-ky.com",
    "from-la.net",
    "from-ma.com",
    "from-md.com",
    "from-me.org",
    "from-mi.com",
    "from-mn.com",
    "from-mo.com",
    "from-ms.com",
    "from-mt.com",
    "from-nc.com",
    "from-nd.com",
    "from-ne.com",
    "from-nh.com",
    "from-nj.com",
    "from-nm.com",
    "from-nv.com",
    "from-ny.net",
    "from-oh.com",
    "from-ok.com",
    "from-or.com",
    "from-pa.com",
    "from-pr.com",
    "from-ri.com",
    "from-sc.com",
    "from-sd.com",
    "from-tn.com",
    "from-tx.com",
    "from-ut.com",
    "from-va.com",
    "from-vt.com",
    "from-wa.com",
    "from-wi.com",
    "from-wv.com",
    "from-wy.com",
    "ftpaccess.cc",
    "fuettertdasnetz.de",
    "game-host.org",
    "game-server.cc",
    "getmyip.com",
    "gets-it.net",
    "go.dyndns.org",
    "gotdns.com",
    "gotdns.org",
    "groks-the.info",
    "groks-this.info",
    "ham-radio-op.net",
    "here-for-more.info",
    "hobby-site.com",
    "hobby-site.org",
    "home.dyndns.org",
    "homedns.org",
    "homeftp.net",
    "homeftp.org",
    "homeip.net",
    "homelinux.com",
    "homelinux.net",
    "homelinux.org",
    "homeunix.com",
    "homeunix.net",
    "homeunix.org",
    "iamallama.com",
    "in-the-band.net",
    "is-a-anarchist.com",
    "is-a-blogger.com",
    "is-a-bookkeeper.com",
    "is-a-bruinsfan.org",
    "is-a-bulls-fan.com",
    "is-a-candidate.org",
    "is-a-caterer.com",
    "is-a-celticsfan.org",
    "is-a-chef.com",
    "is-a-chef.net",
    "is-a-chef.org",
    "is-a-conservative.com",
    "is-a-cpa.com",
    "is-a-cubicle-slave.com",
    "is-a-democrat.com",
    "is-a-designer.com",
    "is-a-doctor.com",
    "is-a-financialadvisor.com",
    "is-a-geek.com",
    "is-a-geek.net",
    "is-a-geek.org",
    "is-a-green.com",
    "is-a-guru.com",
    "is-a-hard-worker.com",
    "is-a-hunter.com",
    "is-a-knight.org",
    "is-a-landscaper.com",
    "is-a-lawyer.com",
    "is-a-liberal.com",
    "is-a-libertarian.com",
    "is-a-linux-user.org",
    "is-a-llama.com",
    "is-a-musician.com",
    "is-a-nascarfan.com",
    "is-a-nurse.com",
    "is-a-painter.com",
    "is-a-patsfan.org",
    "is-a-personaltrainer.com",
    "is-a-photographer.com",
    "is-a-player.com",
    "is-a-republican.com",
    "is-a-rockstar.com",
    "is-a-socialist.com",
    "is-a-soxfan.org",
    "is-a-student.com",
    "is-a-teacher.com",
    "is-a-techie.com",
    "is-a-therapist.com",
    "is-an-accountant.com",
    "is-an-actor.com",
    "is-an-actress.com",
    "is-an-anarchist.com",
    "is-an-artist.com",
    "is-an-engineer.com",
    "is-an-entertainer.com",
    "is-by.us",
    "is-certified.com",
    "is-found.org",
    "is-gone.com",
    "is-into-anime.com",
    "is-into-cars.com",
    "is-into-cartoons.com",
    "is-into-games.com",
    "is-leet.com",
    "is-lost.org",
    "is-not-certified.com",
    "is-saved.org",
    "is-slick.com",
    "is-uberleet.com",
    "is-very-bad.org",
    "is-very-evil.org",
    "is-very-good.org",
    "is-very-nice.org",
    "is-very-sweet.org",
    "is-with-theband.com",
    "isa-geek.com",
    "isa-geek.net",
    "isa-geek.org",
    "isa-hockeynut.com",
    "issmarterthanyou.com",
    "isteingeek.de",
    "istmein.de",
    "kicks-ass.net",
    "kicks-ass.org",
    "knowsitall.info",
    "land-4-sale.us",
    "lebtimnetz.de",
    "leitungsen.de",
    "likes-pie.com",
    "likescandy.com",
    "merseine.nu",
    "mine.nu",
    "misconfused.org",
    "mypets.ws",
    "myphotos.cc",
    "neat-url.com",
    "office-on-the.net",
    "on-the-web.tv",
    "podzone.net",
    "podzone.org",
    "readmyblog.org",
    "saves-the-whales.com",
    "scrapper-site.net",
    "scrapping.cc",
    "selfip.biz",
    "selfip.com",
    "selfip.info",
    "selfip.net",
    "selfip.org",
    "sells-for-less.com",
    "sells-for-u.com",
    "sells-it.net",
    "sellsyourhome.org",
    "servebbs.com",
    "servebbs.net",
    "servebbs.org",
    "serveftp.net",
    "serveftp.org",
    "servegame.org",
    "shacknet.nu",
    "simple-url.com",
    "space-to-rent.com",
    "stuff-4-sale.org",
    "stuff-4-sale.us",
    "teaches-yoga.com",
    "thruhere.net",
    "traeumtgerade.de",
    "webhop.biz",
    "webhop.info",
    "webhop.net",
    "webhop.org",
    "worse-than.tv",
    "writesthisblog.com",
    "ddnss.de",
    "dyn.ddnss.de",
    "dyndns.ddnss.de",
    "dyndns1.de",
    "dyn-ip24.de",
    "home-webserver.de",
    "dyn.home-webserver.de",
    "myhome-server.de",
    "ddnss.org",
    "definima.net",
    "definima.io",
    "ondigitalocean.app",
    "*.digitaloceanspaces.com",
    "bci.dnstrace.pro",
    "ddnsfree.com",
    "ddnsgeek.com",
    "giize.com",
    "gleeze.com",
    "kozow.com",
    "loseyourip.com",
    "ooguy.com",
    "theworkpc.com",
    "casacam.net",
    "dynu.net",
    "accesscam.org",
    "camdvr.org",
    "freeddns.org",
    "mywire.org",
    "webredirect.org",
    "myddns.rocks",
    "blogsite.xyz",
    "dynv6.net",
    "e4.cz",
    "eero.online",
    "eero-stage.online",
    "elementor.cloud",
    "elementor.cool",
    "en-root.fr",
    "mytuleap.com",
    "tuleap-partners.com",
    "encr.app",
    "encoreapi.com",
    "onred.one",
    "staging.onred.one",
    "eu.encoway.cloud",
    "eu.org",
    "al.eu.org",
    "asso.eu.org",
    "at.eu.org",
    "au.eu.org",
    "be.eu.org",
    "bg.eu.org",
    "ca.eu.org",
    "cd.eu.org",
    "ch.eu.org",
    "cn.eu.org",
    "cy.eu.org",
    "cz.eu.org",
    "de.eu.org",
    "dk.eu.org",
    "edu.eu.org",
    "ee.eu.org",
    "es.eu.org",
    "fi.eu.org",
    "fr.eu.org",
    "gr.eu.org",
    "hr.eu.org",
    "hu.eu.org",
    "ie.eu.org",
    "il.eu.org",
    "in.eu.org",
    "int.eu.org",
    "is.eu.org",
    "it.eu.org",
    "jp.eu.org",
    "kr.eu.org",
    "lt.eu.org",
    "lu.eu.org",
    "lv.eu.org",
    "mc.eu.org",
    "me.eu.org",
    "mk.eu.org",
    "mt.eu.org",
    "my.eu.org",
    "net.eu.org",
    "ng.eu.org",
    "nl.eu.org",
    "no.eu.org",
    "nz.eu.org",
    "paris.eu.org",
    "pl.eu.org",
    "pt.eu.org",
    "q-a.eu.org",
    "ro.eu.org",
    "ru.eu.org",
    "se.eu.org",
    "si.eu.org",
    "sk.eu.org",
    "tr.eu.org",
    "uk.eu.org",
    "us.eu.org",
    "eurodir.ru",
    "eu-1.evennode.com",
    "eu-2.evennode.com",
    "eu-3.evennode.com",
    "eu-4.evennode.com",
    "us-1.evennode.com",
    "us-2.evennode.com",
    "us-3.evennode.com",
    "us-4.evennode.com",
    "twmail.cc",
    "twmail.net",
    "twmail.org",
    "mymailer.com.tw",
    "url.tw",
    "onfabrica.com",
    "apps.fbsbx.com",
    "ru.net",
    "adygeya.ru",
    "bashkiria.ru",
    "bir.ru",
    "cbg.ru",
    "com.ru",
    "dagestan.ru",
    "grozny.ru",
    "kalmykia.ru",
    "kustanai.ru",
    "marine.ru",
    "mordovia.ru",
    "msk.ru",
    "mytis.ru",
    "nalchik.ru",
    "nov.ru",
    "pyatigorsk.ru",
    "spb.ru",
    "vladikavkaz.ru",
    "vladimir.ru",
    "abkhazia.su",
    "adygeya.su",
    "aktyubinsk.su",
    "arkhangelsk.su",
    "armenia.su",
    "ashgabad.su",
    "azerbaijan.su",
    "balashov.su",
    "bashkiria.su",
    "bryansk.su",
    "bukhara.su",
    "chimkent.su",
    "dagestan.su",
    "east-kazakhstan.su",
    "exnet.su",
    "georgia.su",
    "grozny.su",
    "ivanovo.su",
    "jambyl.su",
    "kalmykia.su",
    "kaluga.su",
    "karacol.su",
    "karaganda.su",
    "karelia.su",
    "khakassia.su",
    "krasnodar.su",
    "kurgan.su",
    "kustanai.su",
    "lenug.su",
    "mangyshlak.su",
    "mordovia.su",
    "msk.su",
    "murmansk.su",
    "nalchik.su",
    "navoi.su",
    "north-kazakhstan.su",
    "nov.su",
    "obninsk.su",
    "penza.su",
    "pokrovsk.su",
    "sochi.su",
    "spb.su",
    "tashkent.su",
    "termez.su",
    "togliatti.su",
    "troitsk.su",
    "tselinograd.su",
    "tula.su",
    "tuva.su",
    "vladikavkaz.su",
    "vladimir.su",
    "vologda.su",
    "channelsdvr.net",
    "u.channelsdvr.net",
    "edgecompute.app",
    "fastly-terrarium.com",
    "fastlylb.net",
    "map.fastlylb.net",
    "freetls.fastly.net",
    "map.fastly.net",
    "a.prod.fastly.net",
    "global.prod.fastly.net",
    "a.ssl.fastly.net",
    "b.ssl.fastly.net",
    "global.ssl.fastly.net",
    "fastvps-server.com",
    "fastvps.host",
    "myfast.host",
    "fastvps.site",
    "myfast.space",
    "fedorainfracloud.org",
    "fedorapeople.org",
    "cloud.fedoraproject.org",
    "app.os.fedoraproject.org",
    "app.os.stg.fedoraproject.org",
    "conn.uk",
    "copro.uk",
    "hosp.uk",
    "mydobiss.com",
    "fh-muenster.io",
    "filegear.me",
    "filegear-au.me",
    "filegear-de.me",
    "filegear-gb.me",
    "filegear-ie.me",
    "filegear-jp.me",
    "filegear-sg.me",
    "firebaseapp.com",
    "fireweb.app",
    "flap.id",
    "onflashdrive.app",
    "fldrv.com",
    "fly.dev",
    "edgeapp.net",
    "shw.io",
    "flynnhosting.net",
    "forgeblocks.com",
    "id.forgerock.io",
    "framer.app",
    "framercanvas.com",
    "*.frusky.de",
    "ravpage.co.il",
    "0e.vc",
    "freebox-os.com",
    "freeboxos.com",
    "fbx-os.fr",
    "fbxos.fr",
    "freebox-os.fr",
    "freeboxos.fr",
    "freedesktop.org",
    "freemyip.com",
    "wien.funkfeuer.at",
    "*.futurecms.at",
    "*.ex.futurecms.at",
    "*.in.futurecms.at",
    "futurehosting.at",
    "futuremailing.at",
    "*.ex.ortsinfo.at",
    "*.kunden.ortsinfo.at",
    "*.statics.cloud",
    "independent-commission.uk",
    "independent-inquest.uk",
    "independent-inquiry.uk",
    "independent-panel.uk",
    "independent-review.uk",
    "public-inquiry.uk",
    "royal-commission.uk",
    "campaign.gov.uk",
    "service.gov.uk",
    "api.gov.uk",
    "gehirn.ne.jp",
    "usercontent.jp",
    "gentapps.com",
    "gentlentapis.com",
    "lab.ms",
    "cdn-edges.net",
    "ghost.io",
    "gsj.bz",
    "githubusercontent.com",
    "githubpreview.dev",
    "github.io",
    "gitlab.io",
    "gitapp.si",
    "gitpage.si",
    "glitch.me",
    "nog.community",
    "co.ro",
    "shop.ro",
    "lolipop.io",
    "angry.jp",
    "babyblue.jp",
    "babymilk.jp",
    "backdrop.jp",
    "bambina.jp",
    "bitter.jp",
    "blush.jp",
    "boo.jp",
    "boy.jp",
    "boyfriend.jp",
    "but.jp",
    "candypop.jp",
    "capoo.jp",
    "catfood.jp",
    "cheap.jp",
    "chicappa.jp",
    "chillout.jp",
    "chips.jp",
    "chowder.jp",
    "chu.jp",
    "ciao.jp",
    "cocotte.jp",
    "coolblog.jp",
    "cranky.jp",
    "cutegirl.jp",
    "daa.jp",
    "deca.jp",
    "deci.jp",
    "digick.jp",
    "egoism.jp",
    "fakefur.jp",
    "fem.jp",
    "flier.jp",
    "floppy.jp",
    "fool.jp",
    "frenchkiss.jp",
    "girlfriend.jp",
    "girly.jp",
    "gloomy.jp",
    "gonna.jp",
    "greater.jp",
    "hacca.jp",
    "heavy.jp",
    "her.jp",
    "hiho.jp",
    "hippy.jp",
    "holy.jp",
    "hungry.jp",
    "icurus.jp",
    "itigo.jp",
    "jellybean.jp",
    "kikirara.jp",
    "kill.jp",
    "kilo.jp",
    "kuron.jp",
    "littlestar.jp",
    "lolipopmc.jp",
    "lolitapunk.jp",
    "lomo.jp",
    "lovepop.jp",
    "lovesick.jp",
    "main.jp",
    "mods.jp",
    "mond.jp",
    "mongolian.jp",
    "moo.jp",
    "namaste.jp",
    "nikita.jp",
    "nobushi.jp",
    "noor.jp",
    "oops.jp",
    "parallel.jp",
    "parasite.jp",
    "pecori.jp",
    "peewee.jp",
    "penne.jp",
    "pepper.jp",
    "perma.jp",
    "pigboat.jp",
    "pinoko.jp",
    "punyu.jp",
    "pupu.jp",
    "pussycat.jp",
    "pya.jp",
    "raindrop.jp",
    "readymade.jp",
    "sadist.jp",
    "schoolbus.jp",
    "secret.jp",
    "staba.jp",
    "stripper.jp",
    "sub.jp",
    "sunnyday.jp",
    "thick.jp",
    "tonkotsu.jp",
    "under.jp",
    "upper.jp",
    "velvet.jp",
    "verse.jp",
    "versus.jp",
    "vivian.jp",
    "watson.jp",
    "weblike.jp",
    "whitesnow.jp",
    "zombie.jp",
    "heteml.net",
    "cloudapps.digital",
    "london.cloudapps.digital",
    "pymnt.uk",
    "homeoffice.gov.uk",
    "ro.im",
    "goip.de",
    "run.app",
    "a.run.app",
    "web.app",
    "*.0emm.com",
    "appspot.com",
    "*.r.appspot.com",
    "codespot.com",
    "googleapis.com",
    "googlecode.com",
    "pagespeedmobilizer.com",
    "publishproxy.com",
    "withgoogle.com",
    "withyoutube.com",
    "*.gateway.dev",
    "cloud.goog",
    "translate.goog",
    "*.usercontent.goog",
    "cloudfunctions.net",
    "blogspot.ae",
    "blogspot.al",
    "blogspot.am",
    "blogspot.ba",
    "blogspot.be",
    "blogspot.bg",
    "blogspot.bj",
    "blogspot.ca",
    "blogspot.cf",
    "blogspot.ch",
    "blogspot.cl",
    "blogspot.co.at",
    "blogspot.co.id",
    "blogspot.co.il",
    "blogspot.co.ke",
    "blogspot.co.nz",
    "blogspot.co.uk",
    "blogspot.co.za",
    "blogspot.com",
    "blogspot.com.ar",
    "blogspot.com.au",
    "blogspot.com.br",
    "blogspot.com.by",
    "blogspot.com.co",
    "blogspot.com.cy",
    "blogspot.com.ee",
    "blogspot.com.eg",
    "blogspot.com.es",
    "blogspot.com.mt",
    "blogspot.com.ng",
    "blogspot.com.tr",
    "blogspot.com.uy",
    "blogspot.cv",
    "blogspot.cz",
    "blogspot.de",
    "blogspot.dk",
    "blogspot.fi",
    "blogspot.fr",
    "blogspot.gr",
    "blogspot.hk",
    "blogspot.hr",
    "blogspot.hu",
    "blogspot.ie",
    "blogspot.in",
    "blogspot.is",
    "blogspot.it",
    "blogspot.jp",
    "blogspot.kr",
    "blogspot.li",
    "blogspot.lt",
    "blogspot.lu",
    "blogspot.md",
    "blogspot.mk",
    "blogspot.mr",
    "blogspot.mx",
    "blogspot.my",
    "blogspot.nl",
    "blogspot.no",
    "blogspot.pe",
    "blogspot.pt",
    "blogspot.qa",
    "blogspot.re",
    "blogspot.ro",
    "blogspot.rs",
    "blogspot.ru",
    "blogspot.se",
    "blogspot.sg",
    "blogspot.si",
    "blogspot.sk",
    "blogspot.sn",
    "blogspot.td",
    "blogspot.tw",
    "blogspot.ug",
    "blogspot.vn",
    "goupile.fr",
    "gov.nl",
    "awsmppl.com",
    "günstigbestellen.de",
    "günstigliefern.de",
    "fin.ci",
    "free.hr",
    "caa.li",
    "ua.rs",
    "conf.se",
    "hs.zone",
    "hs.run",
    "hashbang.sh",
    "hasura.app",
    "hasura-app.io",
    "pages.it.hs-heilbronn.de",
    "hepforge.org",
    "herokuapp.com",
    "herokussl.com",
    "ravendb.cloud",
    "myravendb.com",
    "ravendb.community",
    "ravendb.me",
    "development.run",
    "ravendb.run",
    "homesklep.pl",
    "secaas.hk",
    "hoplix.shop",
    "orx.biz",
    "biz.gl",
    "col.ng",
    "firm.ng",
    "gen.ng",
    "ltd.ng",
    "ngo.ng",
    "edu.scot",
    "sch.so",
    "hostyhosting.io",
    "häkkinen.fi",
    "*.moonscale.io",
    "moonscale.net",
    "iki.fi",
    "ibxos.it",
    "iliadboxos.it",
    "impertrixcdn.com",
    "impertrix.com",
    "smushcdn.com",
    "wphostedmail.com",
    "wpmucdn.com",
    "tempurl.host",
    "wpmudev.host",
    "dyn-berlin.de",
    "in-berlin.de",
    "in-brb.de",
    "in-butter.de",
    "in-dsl.de",
    "in-dsl.net",
    "in-dsl.org",
    "in-vpn.de",
    "in-vpn.net",
    "in-vpn.org",
    "biz.at",
    "info.at",
    "info.cx",
    "ac.leg.br",
    "al.leg.br",
    "am.leg.br",
    "ap.leg.br",
    "ba.leg.br",
    "ce.leg.br",
    "df.leg.br",
    "es.leg.br",
    "go.leg.br",
    "ma.leg.br",
    "mg.leg.br",
    "ms.leg.br",
    "mt.leg.br",
    "pa.leg.br",
    "pb.leg.br",
    "pe.leg.br",
    "pi.leg.br",
    "pr.leg.br",
    "rj.leg.br",
    "rn.leg.br",
    "ro.leg.br",
    "rr.leg.br",
    "rs.leg.br",
    "sc.leg.br",
    "se.leg.br",
    "sp.leg.br",
    "to.leg.br",
    "pixolino.com",
    "na4u.ru",
    "iopsys.se",
    "ipifony.net",
    "iservschule.de",
    "mein-iserv.de",
    "schulplattform.de",
    "schulserver.de",
    "test-iserv.de",
    "iserv.dev",
    "iobb.net",
    "mel.cloudlets.com.au",
    "cloud.interhostsolutions.be",
    "users.scale.virtualcloud.com.br",
    "mycloud.by",
    "alp1.ae.flow.ch",
    "appengine.flow.ch",
    "es-1.axarnet.cloud",
    "diadem.cloud",
    "vip.jelastic.cloud",
    "jele.cloud",
    "it1.eur.aruba.jenv-aruba.cloud",
    "it1.jenv-aruba.cloud",
    "keliweb.cloud",
    "cs.keliweb.cloud",
    "oxa.cloud",
    "tn.oxa.cloud",
    "uk.oxa.cloud",
    "primetel.cloud",
    "uk.primetel.cloud",
    "ca.reclaim.cloud",
    "uk.reclaim.cloud",
    "us.reclaim.cloud",
    "ch.trendhosting.cloud",
    "de.trendhosting.cloud",
    "jele.club",
    "amscompute.com",
    "clicketcloud.com",
    "dopaas.com",
    "hidora.com",
    "paas.hosted-by-previder.com",
    "rag-cloud.hosteur.com",
    "rag-cloud-ch.hosteur.com",
    "jcloud.ik-server.com",
    "jcloud-ver-jpc.ik-server.com",
    "demo.jelastic.com",
    "kilatiron.com",
    "paas.massivegrid.com",
    "jed.wafaicloud.com",
    "lon.wafaicloud.com",
    "ryd.wafaicloud.com",
    "j.scaleforce.com.cy",
    "jelastic.dogado.eu",
    "fi.cloudplatform.fi",
    "demo.datacenter.fi",
    "paas.datacenter.fi",
    "jele.host",
    "mircloud.host",
    "paas.beebyte.io",
    "sekd1.beebyteapp.io",
    "jele.io",
    "cloud-fr1.unispace.io",
    "jc.neen.it",
    "cloud.jelastic.open.tim.it",
    "jcloud.kz",
    "upaas.kazteleport.kz",
    "cloudjiffy.net",
    "fra1-de.cloudjiffy.net",
    "west1-us.cloudjiffy.net",
    "jls-sto1.elastx.net",
    "jls-sto2.elastx.net",
    "jls-sto3.elastx.net",
    "faststacks.net",
    "fr-1.paas.massivegrid.net",
    "lon-1.paas.massivegrid.net",
    "lon-2.paas.massivegrid.net",
    "ny-1.paas.massivegrid.net",
    "ny-2.paas.massivegrid.net",
    "sg-1.paas.massivegrid.net",
    "jelastic.saveincloud.net",
    "nordeste-idc.saveincloud.net",
    "j.scaleforce.net",
    "jelastic.tsukaeru.net",
    "sdscloud.pl",
    "unicloud.pl",
    "mircloud.ru",
    "jelastic.regruhosting.ru",
    "enscaled.sg",
    "jele.site",
    "jelastic.team",
    "orangecloud.tn",
    "j.layershift.co.uk",
    "phx.enscaled.us",
    "mircloud.us",
    "myjino.ru",
    "*.hosting.myjino.ru",
    "*.landing.myjino.ru",
    "*.spectrum.myjino.ru",
    "*.vps.myjino.ru",
    "jotelulu.cloud",
    "*.triton.zone",
    "*.cns.joyent.com",
    "js.org",
    "kaas.gg",
    "khplay.nl",
    "ktistory.com",
    "kapsi.fi",
    "keymachine.de",
    "kinghost.net",
    "uni5.net",
    "knightpoint.systems",
    "koobin.events",
    "oya.to",
    "kuleuven.cloud",
    "ezproxy.kuleuven.be",
    "co.krd",
    "edu.krd",
    "krellian.net",
    "webthings.io",
    "git-repos.de",
    "lcube-server.de",
    "svn-repos.de",
    "leadpages.co",
    "lpages.co",
    "lpusercontent.com",
    "lelux.site",
    "co.business",
    "co.education",
    "co.events",
    "co.financial",
    "co.network",
    "co.place",
    "co.technology",
    "app.lmpm.com",
    "linkyard.cloud",
    "linkyard-cloud.ch",
    "members.linode.com",
    "*.nodebalancer.linode.com",
    "*.linodeobjects.com",
    "ip.linodeusercontent.com",
    "we.bs",
    "*.user.localcert.dev",
    "localzone.xyz",
    "loginline.app",
    "loginline.dev",
    "loginline.io",
    "loginline.services",
    "loginline.site",
    "servers.run",
    "lohmus.me",
    "krasnik.pl",
    "leczna.pl",
    "lubartow.pl",
    "lublin.pl",
    "poniatowa.pl",
    "swidnik.pl",
    "glug.org.uk",
    "lug.org.uk",
    "lugs.org.uk",
    "barsy.bg",
    "barsy.co.uk",
    "barsyonline.co.uk",
    "barsycenter.com",
    "barsyonline.com",
    "barsy.club",
    "barsy.de",
    "barsy.eu",
    "barsy.in",
    "barsy.info",
    "barsy.io",
    "barsy.me",
    "barsy.menu",
    "barsy.mobi",
    "barsy.net",
    "barsy.online",
    "barsy.org",
    "barsy.pro",
    "barsy.pub",
    "barsy.ro",
    "barsy.shop",
    "barsy.site",
    "barsy.support",
    "barsy.uk",
    "*.magentosite.cloud",
    "mayfirst.info",
    "mayfirst.org",
    "hb.cldmail.ru",
    "cn.vu",
    "mazeplay.com",
    "mcpe.me",
    "mcdir.me",
    "mcdir.ru",
    "mcpre.ru",
    "vps.mcdir.ru",
    "mediatech.by",
    "mediatech.dev",
    "hra.health",
    "miniserver.com",
    "memset.net",
    "messerli.app",
    "*.cloud.metacentrum.cz",
    "custom.metacentrum.cz",
    "flt.cloud.muni.cz",
    "usr.cloud.muni.cz",
    "meteorapp.com",
    "eu.meteorapp.com",
    "co.pl",
    "*.azurecontainer.io",
    "azurewebsites.net",
    "azure-mobile.net",
    "cloudapp.net",
    "azurestaticapps.net",
    "1.azurestaticapps.net",
    "centralus.azurestaticapps.net",
    "eastasia.azurestaticapps.net",
    "eastus2.azurestaticapps.net",
    "westeurope.azurestaticapps.net",
    "westus2.azurestaticapps.net",
    "csx.cc",
    "mintere.site",
    "forte.id",
    "mozilla-iot.org",
    "bmoattachments.org",
    "net.ru",
    "org.ru",
    "pp.ru",
    "hostedpi.com",
    "customer.mythic-beasts.com",
    "caracal.mythic-beasts.com",
    "fentiger.mythic-beasts.com",
    "lynx.mythic-beasts.com",
    "ocelot.mythic-beasts.com",
    "oncilla.mythic-beasts.com",
    "onza.mythic-beasts.com",
    "sphinx.mythic-beasts.com",
    "vs.mythic-beasts.com",
    "x.mythic-beasts.com",
    "yali.mythic-beasts.com",
    "cust.retrosnub.co.uk",
    "ui.nabu.casa",
    "pony.club",
    "of.fashion",
    "in.london",
    "of.london",
    "from.marketing",
    "with.marketing",
    "for.men",
    "repair.men",
    "and.mom",
    "for.mom",
    "for.one",
    "under.one",
    "for.sale",
    "that.win",
    "from.work",
    "to.work",
    "cloud.nospamproxy.com",
    "netlify.app",
    "4u.com",
    "ngrok.io",
    "nh-serv.co.uk",
    "nfshost.com",
    "*.developer.app",
    "noop.app",
    "*.northflank.app",
    "*.build.run",
    "*.code.run",
    "*.database.run",
    "*.migration.run",
    "noticeable.news",
    "dnsking.ch",
    "mypi.co",
    "n4t.co",
    "001www.com",
    "ddnslive.com",
    "myiphost.com",
    "forumz.info",
    "16-b.it",
    "32-b.it",
    "64-b.it",
    "soundcast.me",
    "tcp4.me",
    "dnsup.net",
    "hicam.net",
    "now-dns.net",
    "ownip.net",
    "vpndns.net",
    "dynserv.org",
    "now-dns.org",
    "x443.pw",
    "now-dns.top",
    "ntdll.top",
    "freeddns.us",
    "crafting.xyz",
    "zapto.xyz",
    "nsupdate.info",
    "nerdpol.ovh",
    "blogsyte.com",
    "brasilia.me",
    "cable-modem.org",
    "ciscofreak.com",
    "collegefan.org",
    "couchpotatofries.org",
    "damnserver.com",
    "ddns.me",
    "ditchyourip.com",
    "dnsfor.me",
    "dnsiskinky.com",
    "dvrcam.info",
    "dynns.com",
    "eating-organic.net",
    "fantasyleague.cc",
    "geekgalaxy.com",
    "golffan.us",
    "health-carereform.com",
    "homesecuritymac.com",
    "homesecuritypc.com",
    "hopto.me",
    "ilovecollege.info",
    "loginto.me",
    "mlbfan.org",
    "mmafan.biz",
    "myactivedirectory.com",
    "mydissent.net",
    "myeffect.net",
    "mymediapc.net",
    "mypsx.net",
    "mysecuritycamera.com",
    "mysecuritycamera.net",
    "mysecuritycamera.org",
    "net-freaks.com",
    "nflfan.org",
    "nhlfan.net",
    "no-ip.ca",
    "no-ip.co.uk",
    "no-ip.net",
    "noip.us",
    "onthewifi.com",
    "pgafan.net",
    "point2this.com",
    "pointto.us",
    "privatizehealthinsurance.net",
    "quicksytes.com",
    "read-books.org",
    "securitytactics.com",
    "serveexchange.com",
    "servehumour.com",
    "servep2p.com",
    "servesarcasm.com",
    "stufftoread.com",
    "ufcfan.org",
    "unusualperson.com",
    "workisboring.com",
    "3utilities.com",
    "bounceme.net",
    "ddns.net",
    "ddnsking.com",
    "gotdns.ch",
    "hopto.org",
    "myftp.biz",
    "myftp.org",
    "myvnc.com",
    "no-ip.biz",
    "no-ip.info",
    "no-ip.org",
    "noip.me",
    "redirectme.net",
    "servebeer.com",
    "serveblog.net",
    "servecounterstrike.com",
    "serveftp.com",
    "servegame.com",
    "servehalflife.com",
    "servehttp.com",
    "serveirc.com",
    "serveminecraft.net",
    "servemp3.com",
    "servepics.com",
    "servequake.com",
    "sytes.net",
    "webhop.me",
    "zapto.org",
    "stage.nodeart.io",
    "pcloud.host",
    "nyc.mn",
    "static.observableusercontent.com",
    "cya.gg",
    "omg.lol",
    "cloudycluster.net",
    "omniwe.site",
    "service.one",
    "nid.io",
    "opensocial.site",
    "opencraft.hosting",
    "orsites.com",
    "operaunite.com",
    "tech.orange",
    "authgear-staging.com",
    "authgearapps.com",
    "skygearapp.com",
    "outsystemscloud.com",
    "*.webpaas.ovh.net",
    "*.hosting.ovh.net",
    "ownprovider.com",
    "own.pm",
    "*.owo.codes",
    "ox.rs",
    "oy.lc",
    "pgfog.com",
    "pagefrontapp.com",
    "pagexl.com",
    "*.paywhirl.com",
    "bar0.net",
    "bar1.net",
    "bar2.net",
    "rdv.to",
    "art.pl",
    "gliwice.pl",
    "krakow.pl",
    "poznan.pl",
    "wroc.pl",
    "zakopane.pl",
    "pantheonsite.io",
    "gotpantheon.com",
    "mypep.link",
    "perspecta.cloud",
    "lk3.ru",
    "on-web.fr",
    "bc.platform.sh",
    "ent.platform.sh",
    "eu.platform.sh",
    "us.platform.sh",
    "*.platformsh.site",
    "*.tst.site",
    "platter-app.com",
    "platter-app.dev",
    "platterp.us",
    "pdns.page",
    "plesk.page",
    "pleskns.com",
    "dyn53.io",
    "onporter.run",
    "co.bn",
    "postman-echo.com",
    "pstmn.io",
    "mock.pstmn.io",
    "httpbin.org",
    "prequalifyme.today",
    "xen.prgmr.com",
    "priv.at",
    "prvcy.page",
    "*.dweb.link",
    "protonet.io",
    "chirurgiens-dentistes-en-france.fr",
    "byen.site",
    "pubtls.org",
    "pythonanywhere.com",
    "eu.pythonanywhere.com",
    "qoto.io",
    "qualifioapp.com",
    "qbuser.com",
    "cloudsite.builders",
    "instances.spawn.cc",
    "instantcloud.cn",
    "ras.ru",
    "qa2.com",
    "qcx.io",
    "*.sys.qcx.io",
    "dev-myqnapcloud.com",
    "alpha-myqnapcloud.com",
    "myqnapcloud.com",
    "*.quipelements.com",
    "vapor.cloud",
    "vaporcloud.io",
    "rackmaze.com",
    "rackmaze.net",
    "g.vbrplsbx.io",
    "*.on-k3s.io",
    "*.on-rancher.cloud",
    "*.on-rio.io",
    "readthedocs.io",
    "rhcloud.com",
    "app.render.com",
    "onrender.com",
    "repl.co",
    "id.repl.co",
    "repl.run",
    "resindevice.io",
    "devices.resinstaging.io",
    "hzc.io",
    "wellbeingzone.eu",
    "wellbeingzone.co.uk",
    "adimo.co.uk",
    "itcouldbewor.se",
    "git-pages.rit.edu",
    "rocky.page",
    "биз.рус",
    "ком.рус",
    "крым.рус",
    "мир.рус",
    "мск.рус",
    "орг.рус",
    "самара.рус",
    "сочи.рус",
    "спб.рус",
    "я.рус",
    "*.builder.code.com",
    "*.dev-builder.code.com",
    "*.stg-builder.code.com",
    "sandcats.io",
    "logoip.de",
    "logoip.com",
    "fr-par-1.baremetal.scw.cloud",
    "fr-par-2.baremetal.scw.cloud",
    "nl-ams-1.baremetal.scw.cloud",
    "fnc.fr-par.scw.cloud",
    "functions.fnc.fr-par.scw.cloud",
    "k8s.fr-par.scw.cloud",
    "nodes.k8s.fr-par.scw.cloud",
    "s3.fr-par.scw.cloud",
    "s3-website.fr-par.scw.cloud",
    "whm.fr-par.scw.cloud",
    "priv.instances.scw.cloud",
    "pub.instances.scw.cloud",
    "k8s.scw.cloud",
    "k8s.nl-ams.scw.cloud",
    "nodes.k8s.nl-ams.scw.cloud",
    "s3.nl-ams.scw.cloud",
    "s3-website.nl-ams.scw.cloud",
    "whm.nl-ams.scw.cloud",
    "k8s.pl-waw.scw.cloud",
    "nodes.k8s.pl-waw.scw.cloud",
    "s3.pl-waw.scw.cloud",
    "s3-website.pl-waw.scw.cloud",
    "scalebook.scw.cloud",
    "smartlabeling.scw.cloud",
    "dedibox.fr",
    "schokokeks.net",
    "gov.scot",
    "service.gov.scot",
    "scrysec.com",
    "firewall-gateway.com",
    "firewall-gateway.de",
    "my-gateway.de",
    "my-router.de",
    "spdns.de",
    "spdns.eu",
    "firewall-gateway.net",
    "my-firewall.org",
    "myfirewall.org",
    "spdns.org",
    "seidat.net",
    "sellfy.store",
    "senseering.net",
    "minisite.ms",
    "magnet.page",
    "biz.ua",
    "co.ua",
    "pp.ua",
    "shiftcrypto.dev",
    "shiftcrypto.io",
    "shiftedit.io",
    "myshopblocks.com",
    "myshopify.com",
    "shopitsite.com",
    "shopware.store",
    "mo-siemens.io",
    "1kapp.com",
    "appchizi.com",
    "applinzi.com",
    "sinaapp.com",
    "vipsinaapp.com",
    "siteleaf.net",
    "bounty-full.com",
    "alpha.bounty-full.com",
    "beta.bounty-full.com",
    "small-web.org",
    "vp4.me",
    "try-snowplow.com",
    "srht.site",
    "stackhero-network.com",
    "musician.io",
    "novecore.site",
    "static.land",
    "dev.static.land",
    "sites.static.land",
    "storebase.store",
    "vps-host.net",
    "atl.jelastic.vps-host.net",
    "njs.jelastic.vps-host.net",
    "ric.jelastic.vps-host.net",
    "playstation-cloud.com",
    "apps.lair.io",
    "*.stolos.io",
    "spacekit.io",
    "customer.speedpartner.de",
    "myspreadshop.at",
    "myspreadshop.com.au",
    "myspreadshop.be",
    "myspreadshop.ca",
    "myspreadshop.ch",
    "myspreadshop.com",
    "myspreadshop.de",
    "myspreadshop.dk",
    "myspreadshop.es",
    "myspreadshop.fi",
    "myspreadshop.fr",
    "myspreadshop.ie",
    "myspreadshop.it",
    "myspreadshop.net",
    "myspreadshop.nl",
    "myspreadshop.no",
    "myspreadshop.pl",
    "myspreadshop.se",
    "myspreadshop.co.uk",
    "api.stdlib.com",
    "storj.farm",
    "utwente.io",
    "soc.srcf.net",
    "user.srcf.net",
    "temp-dns.com",
    "supabase.co",
    "supabase.in",
    "supabase.net",
    "su.paba.se",
    "*.s5y.io",
    "*.sensiosite.cloud",
    "syncloud.it",
    "dscloud.biz",
    "direct.quickconnect.cn",
    "dsmynas.com",
    "familyds.com",
    "diskstation.me",
    "dscloud.me",
    "i234.me",
    "myds.me",
    "synology.me",
    "dscloud.mobi",
    "dsmynas.net",
    "familyds.net",
    "dsmynas.org",
    "familyds.org",
    "vpnplus.to",
    "direct.quickconnect.to",
    "tabitorder.co.il",
    "taifun-dns.de",
    "beta.tailscale.net",
    "ts.net",
    "gda.pl",
    "gdansk.pl",
    "gdynia.pl",
    "med.pl",
    "sopot.pl",
    "site.tb-hosting.com",
    "edugit.io",
    "s3.teckids.org",
    "telebit.app",
    "telebit.io",
    "*.telebit.xyz",
    "gwiddle.co.uk",
    "*.firenet.ch",
    "*.svc.firenet.ch",
    "reservd.com",
    "thingdustdata.com",
    "cust.dev.thingdust.io",
    "cust.disrec.thingdust.io",
    "cust.prod.thingdust.io",
    "cust.testing.thingdust.io",
    "reservd.dev.thingdust.io",
    "reservd.disrec.thingdust.io",
    "reservd.testing.thingdust.io",
    "tickets.io",
    "arvo.network",
    "azimuth.network",
    "tlon.network",
    "torproject.net",
    "pages.torproject.net",
    "bloxcms.com",
    "townnews-staging.com",
    "tbits.me",
    "12hp.at",
    "2ix.at",
    "4lima.at",
    "lima-city.at",
    "12hp.ch",
    "2ix.ch",
    "4lima.ch",
    "lima-city.ch",
    "trafficplex.cloud",
    "de.cool",
    "12hp.de",
    "2ix.de",
    "4lima.de",
    "lima-city.de",
    "1337.pictures",
    "clan.rip",
    "lima-city.rocks",
    "webspace.rocks",
    "lima.zone",
    "*.transurl.be",
    "*.transurl.eu",
    "*.transurl.nl",
    "site.transip.me",
    "tuxfamily.org",
    "dd-dns.de",
    "diskstation.eu",
    "diskstation.org",
    "dray-dns.de",
    "draydns.de",
    "dyn-vpn.de",
    "dynvpn.de",
    "mein-vigor.de",
    "my-vigor.de",
    "my-wan.de",
    "syno-ds.de",
    "synology-diskstation.de",
    "synology-ds.de",
    "typedream.app",
    "pro.typeform.com",
    "uber.space",
    "*.uberspace.de",
    "hk.com",
    "hk.org",
    "ltd.hk",
    "inc.hk",
    "name.pm",
    "sch.tf",
    "biz.wf",
    "sch.wf",
    "org.yt",
    "virtualuser.de",
    "virtual-user.de",
    "upli.io",
    "urown.cloud",
    "dnsupdate.info",
    "lib.de.us",
    "2038.io",
    "vercel.app",
    "vercel.dev",
    "now.sh",
    "router.management",
    "v-info.info",
    "voorloper.cloud",
    "neko.am",
    "nyaa.am",
    "be.ax",
    "cat.ax",
    "es.ax",
    "eu.ax",
    "gg.ax",
    "mc.ax",
    "us.ax",
    "xy.ax",
    "nl.ci",
    "xx.gl",
    "app.gp",
    "blog.gt",
    "de.gt",
    "to.gt",
    "be.gy",
    "cc.hn",
    "blog.kg",
    "io.kg",
    "jp.kg",
    "tv.kg",
    "uk.kg",
    "us.kg",
    "de.ls",
    "at.md",
    "de.md",
    "jp.md",
    "to.md",
    "indie.porn",
    "vxl.sh",
    "ch.tc",
    "me.tc",
    "we.tc",
    "nyan.to",
    "at.vg",
    "blog.vu",
    "dev.vu",
    "me.vu",
    "v.ua",
    "*.vultrobjects.com",
    "wafflecell.com",
    "*.webhare.dev",
    "reserve-online.net",
    "reserve-online.com",
    "bookonline.app",
    "hotelwithflight.com",
    "wedeploy.io",
    "wedeploy.me",
    "wedeploy.sh",
    "remotewd.com",
    "pages.wiardweb.com",
    "wmflabs.org",
    "toolforge.org",
    "wmcloud.org",
    "panel.gg",
    "daemon.panel.gg",
    "messwithdns.com",
    "woltlab-demo.com",
    "myforum.community",
    "community-pro.de",
    "diskussionsbereich.de",
    "community-pro.net",
    "meinforum.net",
    "affinitylottery.org.uk",
    "raffleentry.org.uk",
    "weeklylottery.org.uk",
    "wpenginepowered.com",
    "js.wpenginepowered.com",
    "wixsite.com",
    "editorx.io",
    "half.host",
    "xnbay.com",
    "u2.xnbay.com",
    "u2-local.xnbay.com",
    "cistron.nl",
    "demon.nl",
    "xs4all.space",
    "yandexcloud.net",
    "storage.yandexcloud.net",
    "website.yandexcloud.net",
    "official.academy",
    "yolasite.com",
    "ybo.faith",
    "yombo.me",
    "homelink.one",
    "ybo.party",
    "ybo.review",
    "ybo.science",
    "ybo.trade",
    "ynh.fr",
    "nohost.me",
    "noho.st",
    "za.net",
    "za.org",
    "bss.design",
    "basicserver.io",
    "virtualserver.io",
    "enterprisecloud.nu"
  ];
  (function(exports) {
    var Punycode = require$$8$1;
    var internals = {};
    internals.rules = require$$1$1.map(function(rule) {
      return {
        rule,
        suffix: rule.replace(/^(\*\.|\!)/, ""),
        punySuffix: -1,
        wildcard: rule.charAt(0) === "*",
        exception: rule.charAt(0) === "!"
      };
    });
    internals.endsWith = function(str, suffix) {
      return str.indexOf(suffix, str.length - suffix.length) !== -1;
    };
    internals.findRule = function(domain) {
      var punyDomain = Punycode.toASCII(domain);
      return internals.rules.reduce(function(memo, rule) {
        if (rule.punySuffix === -1) {
          rule.punySuffix = Punycode.toASCII(rule.suffix);
        }
        if (!internals.endsWith(punyDomain, "." + rule.punySuffix) && punyDomain !== rule.punySuffix) {
          return memo;
        }
        return rule;
      }, null);
    };
    exports.errorCodes = {
      DOMAIN_TOO_SHORT: "Domain name too short.",
      DOMAIN_TOO_LONG: "Domain name too long. It should be no more than 255 chars.",
      LABEL_STARTS_WITH_DASH: "Domain name label can not start with a dash.",
      LABEL_ENDS_WITH_DASH: "Domain name label can not end with a dash.",
      LABEL_TOO_LONG: "Domain name label should be at most 63 chars long.",
      LABEL_TOO_SHORT: "Domain name label should be at least 1 character long.",
      LABEL_INVALID_CHARS: "Domain name label can only contain alphanumeric characters or dashes."
    };
    internals.validate = function(input) {
      var ascii = Punycode.toASCII(input);
      if (ascii.length < 1) {
        return "DOMAIN_TOO_SHORT";
      }
      if (ascii.length > 255) {
        return "DOMAIN_TOO_LONG";
      }
      var labels = ascii.split(".");
      var label;
      for (var i2 = 0; i2 < labels.length; ++i2) {
        label = labels[i2];
        if (!label.length) {
          return "LABEL_TOO_SHORT";
        }
        if (label.length > 63) {
          return "LABEL_TOO_LONG";
        }
        if (label.charAt(0) === "-") {
          return "LABEL_STARTS_WITH_DASH";
        }
        if (label.charAt(label.length - 1) === "-") {
          return "LABEL_ENDS_WITH_DASH";
        }
        if (!/^[a-z0-9\-]+$/.test(label)) {
          return "LABEL_INVALID_CHARS";
        }
      }
    };
    exports.parse = function(input) {
      if (typeof input !== "string") {
        throw new TypeError("Domain name must be a string.");
      }
      var domain = input.slice(0).toLowerCase();
      if (domain.charAt(domain.length - 1) === ".") {
        domain = domain.slice(0, domain.length - 1);
      }
      var error2 = internals.validate(domain);
      if (error2) {
        return {
          input,
          error: {
            message: exports.errorCodes[error2],
            code: error2
          }
        };
      }
      var parsed = {
        input,
        tld: null,
        sld: null,
        domain: null,
        subdomain: null,
        listed: false
      };
      var domainParts = domain.split(".");
      if (domainParts[domainParts.length - 1] === "local") {
        return parsed;
      }
      var handlePunycode = function() {
        if (!/xn--/.test(domain)) {
          return parsed;
        }
        if (parsed.domain) {
          parsed.domain = Punycode.toASCII(parsed.domain);
        }
        if (parsed.subdomain) {
          parsed.subdomain = Punycode.toASCII(parsed.subdomain);
        }
        return parsed;
      };
      var rule = internals.findRule(domain);
      if (!rule) {
        if (domainParts.length < 2) {
          return parsed;
        }
        parsed.tld = domainParts.pop();
        parsed.sld = domainParts.pop();
        parsed.domain = [parsed.sld, parsed.tld].join(".");
        if (domainParts.length) {
          parsed.subdomain = domainParts.pop();
        }
        return handlePunycode();
      }
      parsed.listed = true;
      var tldParts = rule.suffix.split(".");
      var privateParts = domainParts.slice(0, domainParts.length - tldParts.length);
      if (rule.exception) {
        privateParts.push(tldParts.shift());
      }
      parsed.tld = tldParts.join(".");
      if (!privateParts.length) {
        return handlePunycode();
      }
      if (rule.wildcard) {
        tldParts.unshift(privateParts.pop());
        parsed.tld = tldParts.join(".");
      }
      if (!privateParts.length) {
        return handlePunycode();
      }
      parsed.sld = privateParts.pop();
      parsed.domain = [parsed.sld, parsed.tld].join(".");
      if (privateParts.length) {
        parsed.subdomain = privateParts.join(".");
      }
      return handlePunycode();
    };
    exports.get = function(domain) {
      if (!domain) {
        return null;
      }
      return exports.parse(domain).domain || null;
    };
    exports.isValid = function(domain) {
      var parsed = exports.parse(domain);
      return Boolean(parsed.domain && parsed.listed);
    };
  })(psl$1);
  /*!
   * Copyright (c) 2018, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  var psl = psl$1;
  function getPublicSuffix(domain) {
    return psl.get(domain);
  }
  pubsuffixPsl.getPublicSuffix = getPublicSuffix;
  var store = {};
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  function Store$2() {
  }
  store.Store = Store$2;
  Store$2.prototype.synchronous = false;
  Store$2.prototype.findCookie = function(domain, path, key2, cb) {
    throw new Error("findCookie is not implemented");
  };
  Store$2.prototype.findCookies = function(domain, path, cb) {
    throw new Error("findCookies is not implemented");
  };
  Store$2.prototype.putCookie = function(cookie2, cb) {
    throw new Error("putCookie is not implemented");
  };
  Store$2.prototype.updateCookie = function(oldCookie, newCookie, cb) {
    throw new Error("updateCookie is not implemented");
  };
  Store$2.prototype.removeCookie = function(domain, path, key2, cb) {
    throw new Error("removeCookie is not implemented");
  };
  Store$2.prototype.removeCookies = function(domain, path, cb) {
    throw new Error("removeCookies is not implemented");
  };
  Store$2.prototype.removeAllCookies = function(cb) {
    throw new Error("removeAllCookies is not implemented");
  };
  Store$2.prototype.getAllCookies = function(cb) {
    throw new Error("getAllCookies is not implemented (therefore jar cannot be serialized)");
  };
  var memstore = {};
  var permuteDomain$2 = {};
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  var pubsuffix$1 = pubsuffixPsl;
  function permuteDomain$1(domain) {
    var pubSuf = pubsuffix$1.getPublicSuffix(domain);
    if (!pubSuf) {
      return null;
    }
    if (pubSuf == domain) {
      return [domain];
    }
    var prefix = domain.slice(0, -(pubSuf.length + 1));
    var parts = prefix.split(".").reverse();
    var cur = pubSuf;
    var permutations = [cur];
    while (parts.length) {
      cur = parts.shift() + "." + cur;
      permutations.push(cur);
    }
    return permutations;
  }
  permuteDomain$2.permuteDomain = permuteDomain$1;
  var pathMatch$3 = {};
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  function pathMatch$2(reqPath, cookiePath) {
    if (cookiePath === reqPath) {
      return true;
    }
    var idx = reqPath.indexOf(cookiePath);
    if (idx === 0) {
      if (cookiePath.substr(-1) === "/") {
        return true;
      }
      if (reqPath.substr(cookiePath.length, 1) === "/") {
        return true;
      }
    }
    return false;
  }
  pathMatch$3.pathMatch = pathMatch$2;
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  var Store$1 = store.Store;
  var permuteDomain = permuteDomain$2.permuteDomain;
  var pathMatch$1 = pathMatch$3.pathMatch;
  var util$3 = require$$0$2;
  function MemoryCookieStore$1() {
    Store$1.call(this);
    this.idx = {};
  }
  util$3.inherits(MemoryCookieStore$1, Store$1);
  memstore.MemoryCookieStore = MemoryCookieStore$1;
  MemoryCookieStore$1.prototype.idx = null;
  MemoryCookieStore$1.prototype.synchronous = true;
  MemoryCookieStore$1.prototype.inspect = function() {
    return "{ idx: " + util$3.inspect(this.idx, false, 2) + " }";
  };
  if (util$3.inspect.custom) {
    MemoryCookieStore$1.prototype[util$3.inspect.custom] = MemoryCookieStore$1.prototype.inspect;
  }
  MemoryCookieStore$1.prototype.findCookie = function(domain, path, key2, cb) {
    if (!this.idx[domain]) {
      return cb(null, void 0);
    }
    if (!this.idx[domain][path]) {
      return cb(null, void 0);
    }
    return cb(null, this.idx[domain][path][key2] || null);
  };
  MemoryCookieStore$1.prototype.findCookies = function(domain, path, cb) {
    var results = [];
    if (!domain) {
      return cb(null, []);
    }
    var pathMatcher;
    if (!path) {
      pathMatcher = function matchAll(domainIndex) {
        for (var curPath in domainIndex) {
          var pathIndex = domainIndex[curPath];
          for (var key2 in pathIndex) {
            results.push(pathIndex[key2]);
          }
        }
      };
    } else {
      pathMatcher = function matchRFC(domainIndex) {
        Object.keys(domainIndex).forEach(function(cookiePath) {
          if (pathMatch$1(path, cookiePath)) {
            var pathIndex = domainIndex[cookiePath];
            for (var key2 in pathIndex) {
              results.push(pathIndex[key2]);
            }
          }
        });
      };
    }
    var domains = permuteDomain(domain) || [domain];
    var idx = this.idx;
    domains.forEach(function(curDomain) {
      var domainIndex = idx[curDomain];
      if (!domainIndex) {
        return;
      }
      pathMatcher(domainIndex);
    });
    cb(null, results);
  };
  MemoryCookieStore$1.prototype.putCookie = function(cookie2, cb) {
    if (!this.idx[cookie2.domain]) {
      this.idx[cookie2.domain] = {};
    }
    if (!this.idx[cookie2.domain][cookie2.path]) {
      this.idx[cookie2.domain][cookie2.path] = {};
    }
    this.idx[cookie2.domain][cookie2.path][cookie2.key] = cookie2;
    cb(null);
  };
  MemoryCookieStore$1.prototype.updateCookie = function(oldCookie, newCookie, cb) {
    this.putCookie(newCookie, cb);
  };
  MemoryCookieStore$1.prototype.removeCookie = function(domain, path, key2, cb) {
    if (this.idx[domain] && this.idx[domain][path] && this.idx[domain][path][key2]) {
      delete this.idx[domain][path][key2];
    }
    cb(null);
  };
  MemoryCookieStore$1.prototype.removeCookies = function(domain, path, cb) {
    if (this.idx[domain]) {
      if (path) {
        delete this.idx[domain][path];
      } else {
        delete this.idx[domain];
      }
    }
    return cb(null);
  };
  MemoryCookieStore$1.prototype.removeAllCookies = function(cb) {
    this.idx = {};
    return cb(null);
  };
  MemoryCookieStore$1.prototype.getAllCookies = function(cb) {
    var cookies2 = [];
    var idx = this.idx;
    var domains = Object.keys(idx);
    domains.forEach(function(domain) {
      var paths = Object.keys(idx[domain]);
      paths.forEach(function(path) {
        var keys = Object.keys(idx[domain][path]);
        keys.forEach(function(key2) {
          if (key2 !== null) {
            cookies2.push(idx[domain][path][key2]);
          }
        });
      });
    });
    cookies2.sort(function(a2, b2) {
      return (a2.creationIndex || 0) - (b2.creationIndex || 0);
    });
    cb(null, cookies2);
  };
  var version$1 = "2.5.0";
  /*!
   * Copyright (c) 2015, Salesforce.com, Inc.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * 1. Redistributions of source code must retain the above copyright notice,
   * this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright notice,
   * this list of conditions and the following disclaimer in the documentation
   * and/or other materials provided with the distribution.
   *
   * 3. Neither the name of Salesforce.com nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  var net = require$$0$2;
  var urlParse = require$$0$2.parse;
  var util$2 = require$$0$2;
  var pubsuffix = pubsuffixPsl;
  var Store = store.Store;
  var MemoryCookieStore = memstore.MemoryCookieStore;
  var pathMatch = pathMatch$3.pathMatch;
  var VERSION = version$1;
  var punycode;
  try {
    punycode = require$$8$1;
  } catch (e) {
    console.warn("tough-cookie: can't load punycode; won't use punycode for domain normalization");
  }
  var COOKIE_OCTETS = /^[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]+$/;
  var CONTROL_CHARS = /[\x00-\x1F]/;
  var TERMINATORS = ["\n", "\r", "\0"];
  var PATH_VALUE = /[\x20-\x3A\x3C-\x7E]+/;
  var DATE_DELIM = /[\x09\x20-\x2F\x3B-\x40\x5B-\x60\x7B-\x7E]/;
  var MONTH_TO_NUM = {
    jan: 0,
    feb: 1,
    mar: 2,
    apr: 3,
    may: 4,
    jun: 5,
    jul: 6,
    aug: 7,
    sep: 8,
    oct: 9,
    nov: 10,
    dec: 11
  };
  var NUM_TO_MONTH = [
    "Jan",
    "Feb",
    "Mar",
    "Apr",
    "May",
    "Jun",
    "Jul",
    "Aug",
    "Sep",
    "Oct",
    "Nov",
    "Dec"
  ];
  var NUM_TO_DAY = [
    "Sun",
    "Mon",
    "Tue",
    "Wed",
    "Thu",
    "Fri",
    "Sat"
  ];
  var MAX_TIME = 2147483647e3;
  var MIN_TIME = 0;
  function parseDigits(token, minDigits, maxDigits2, trailingOK) {
    var count = 0;
    while (count < token.length) {
      var c2 = token.charCodeAt(count);
      if (c2 <= 47 || c2 >= 58) {
        break;
      }
      count++;
    }
    if (count < minDigits || count > maxDigits2) {
      return null;
    }
    if (!trailingOK && count != token.length) {
      return null;
    }
    return parseInt(token.substr(0, count), 10);
  }
  function parseTime(token) {
    var parts = token.split(":");
    var result2 = [0, 0, 0];
    if (parts.length !== 3) {
      return null;
    }
    for (var i2 = 0; i2 < 3; i2++) {
      var trailingOK = i2 == 2;
      var num = parseDigits(parts[i2], 1, 2, trailingOK);
      if (num === null) {
        return null;
      }
      result2[i2] = num;
    }
    return result2;
  }
  function parseMonth(token) {
    token = String(token).substr(0, 3).toLowerCase();
    var num = MONTH_TO_NUM[token];
    return num >= 0 ? num : null;
  }
  function parseDate(str) {
    if (!str) {
      return;
    }
    var tokens = str.split(DATE_DELIM);
    if (!tokens) {
      return;
    }
    var hour = null;
    var minute = null;
    var second = null;
    var dayOfMonth = null;
    var month = null;
    var year = null;
    for (var i2 = 0; i2 < tokens.length; i2++) {
      var token = tokens[i2].trim();
      if (!token.length) {
        continue;
      }
      var result2;
      if (second === null) {
        result2 = parseTime(token);
        if (result2) {
          hour = result2[0];
          minute = result2[1];
          second = result2[2];
          continue;
        }
      }
      if (dayOfMonth === null) {
        result2 = parseDigits(token, 1, 2, true);
        if (result2 !== null) {
          dayOfMonth = result2;
          continue;
        }
      }
      if (month === null) {
        result2 = parseMonth(token);
        if (result2 !== null) {
          month = result2;
          continue;
        }
      }
      if (year === null) {
        result2 = parseDigits(token, 2, 4, true);
        if (result2 !== null) {
          year = result2;
          if (year >= 70 && year <= 99) {
            year += 1900;
          } else if (year >= 0 && year <= 69) {
            year += 2e3;
          }
        }
      }
    }
    if (dayOfMonth === null || month === null || year === null || second === null || dayOfMonth < 1 || dayOfMonth > 31 || year < 1601 || hour > 23 || minute > 59 || second > 59) {
      return;
    }
    return new Date(Date.UTC(year, month, dayOfMonth, hour, minute, second));
  }
  function formatDate(date) {
    var d2 = date.getUTCDate();
    d2 = d2 >= 10 ? d2 : "0" + d2;
    var h = date.getUTCHours();
    h = h >= 10 ? h : "0" + h;
    var m = date.getUTCMinutes();
    m = m >= 10 ? m : "0" + m;
    var s = date.getUTCSeconds();
    s = s >= 10 ? s : "0" + s;
    return NUM_TO_DAY[date.getUTCDay()] + ", " + d2 + " " + NUM_TO_MONTH[date.getUTCMonth()] + " " + date.getUTCFullYear() + " " + h + ":" + m + ":" + s + " GMT";
  }
  function canonicalDomain(str) {
    if (str == null) {
      return null;
    }
    str = str.trim().replace(/^\./, "");
    if (punycode && /[^\u0001-\u007f]/.test(str)) {
      str = punycode.toASCII(str);
    }
    return str.toLowerCase();
  }
  function domainMatch(str, domStr, canonicalize) {
    if (str == null || domStr == null) {
      return null;
    }
    if (canonicalize !== false) {
      str = canonicalDomain(str);
      domStr = canonicalDomain(domStr);
    }
    if (str == domStr) {
      return true;
    }
    if (net.isIP(str)) {
      return false;
    }
    var idx = str.indexOf(domStr);
    if (idx <= 0) {
      return false;
    }
    if (str.length !== domStr.length + idx) {
      return false;
    }
    if (str.substr(idx - 1, 1) !== ".") {
      return false;
    }
    return true;
  }
  function defaultPath(path) {
    if (!path || path.substr(0, 1) !== "/") {
      return "/";
    }
    if (path === "/") {
      return path;
    }
    var rightSlash = path.lastIndexOf("/");
    if (rightSlash === 0) {
      return "/";
    }
    return path.slice(0, rightSlash);
  }
  function trimTerminator(str) {
    for (var t = 0; t < TERMINATORS.length; t++) {
      var terminatorIdx = str.indexOf(TERMINATORS[t]);
      if (terminatorIdx !== -1) {
        str = str.substr(0, terminatorIdx);
      }
    }
    return str;
  }
  function parseCookiePair(cookiePair, looseMode) {
    cookiePair = trimTerminator(cookiePair);
    var firstEq = cookiePair.indexOf("=");
    if (looseMode) {
      if (firstEq === 0) {
        cookiePair = cookiePair.substr(1);
        firstEq = cookiePair.indexOf("=");
      }
    } else {
      if (firstEq <= 0) {
        return;
      }
    }
    var cookieName, cookieValue;
    if (firstEq <= 0) {
      cookieName = "";
      cookieValue = cookiePair.trim();
    } else {
      cookieName = cookiePair.substr(0, firstEq).trim();
      cookieValue = cookiePair.substr(firstEq + 1).trim();
    }
    if (CONTROL_CHARS.test(cookieName) || CONTROL_CHARS.test(cookieValue)) {
      return;
    }
    var c2 = new Cookie$1();
    c2.key = cookieName;
    c2.value = cookieValue;
    return c2;
  }
  function parse$1(str, options) {
    if (!options || typeof options !== "object") {
      options = {};
    }
    str = str.trim();
    var firstSemi = str.indexOf(";");
    var cookiePair = firstSemi === -1 ? str : str.substr(0, firstSemi);
    var c2 = parseCookiePair(cookiePair, !!options.loose);
    if (!c2) {
      return;
    }
    if (firstSemi === -1) {
      return c2;
    }
    var unparsed = str.slice(firstSemi + 1).trim();
    if (unparsed.length === 0) {
      return c2;
    }
    var cookie_avs = unparsed.split(";");
    while (cookie_avs.length) {
      var av = cookie_avs.shift().trim();
      if (av.length === 0) {
        continue;
      }
      var av_sep = av.indexOf("=");
      var av_key, av_value;
      if (av_sep === -1) {
        av_key = av;
        av_value = null;
      } else {
        av_key = av.substr(0, av_sep);
        av_value = av.substr(av_sep + 1);
      }
      av_key = av_key.trim().toLowerCase();
      if (av_value) {
        av_value = av_value.trim();
      }
      switch (av_key) {
        case "expires":
          if (av_value) {
            var exp = parseDate(av_value);
            if (exp) {
              c2.expires = exp;
            }
          }
          break;
        case "max-age":
          if (av_value) {
            if (/^-?[0-9]+$/.test(av_value)) {
              var delta = parseInt(av_value, 10);
              c2.setMaxAge(delta);
            }
          }
          break;
        case "domain":
          if (av_value) {
            var domain = av_value.trim().replace(/^\./, "");
            if (domain) {
              c2.domain = domain.toLowerCase();
            }
          }
          break;
        case "path":
          c2.path = av_value && av_value[0] === "/" ? av_value : null;
          break;
        case "secure":
          c2.secure = true;
          break;
        case "httponly":
          c2.httpOnly = true;
          break;
        default:
          c2.extensions = c2.extensions || [];
          c2.extensions.push(av);
          break;
      }
    }
    return c2;
  }
  function jsonParse(str) {
    var obj;
    try {
      obj = JSON.parse(str);
    } catch (e) {
      return e;
    }
    return obj;
  }
  function fromJSON(str) {
    if (!str) {
      return null;
    }
    var obj;
    if (typeof str === "string") {
      obj = jsonParse(str);
      if (obj instanceof Error) {
        return null;
      }
    } else {
      obj = str;
    }
    var c2 = new Cookie$1();
    for (var i2 = 0; i2 < Cookie$1.serializableProperties.length; i2++) {
      var prop = Cookie$1.serializableProperties[i2];
      if (obj[prop] === void 0 || obj[prop] === Cookie$1.prototype[prop]) {
        continue;
      }
      if (prop === "expires" || prop === "creation" || prop === "lastAccessed") {
        if (obj[prop] === null) {
          c2[prop] = null;
        } else {
          c2[prop] = obj[prop] == "Infinity" ? "Infinity" : new Date(obj[prop]);
        }
      } else {
        c2[prop] = obj[prop];
      }
    }
    return c2;
  }
  function cookieCompare(a2, b2) {
    var cmp = 0;
    var aPathLen = a2.path ? a2.path.length : 0;
    var bPathLen = b2.path ? b2.path.length : 0;
    cmp = bPathLen - aPathLen;
    if (cmp !== 0) {
      return cmp;
    }
    var aTime = a2.creation ? a2.creation.getTime() : MAX_TIME;
    var bTime = b2.creation ? b2.creation.getTime() : MAX_TIME;
    cmp = aTime - bTime;
    if (cmp !== 0) {
      return cmp;
    }
    cmp = a2.creationIndex - b2.creationIndex;
    return cmp;
  }
  function permutePath(path) {
    if (path === "/") {
      return ["/"];
    }
    if (path.lastIndexOf("/") === path.length - 1) {
      path = path.substr(0, path.length - 1);
    }
    var permutations = [path];
    while (path.length > 1) {
      var lindex = path.lastIndexOf("/");
      if (lindex === 0) {
        break;
      }
      path = path.substr(0, lindex);
      permutations.push(path);
    }
    permutations.push("/");
    return permutations;
  }
  function getCookieContext(url) {
    if (url instanceof Object) {
      return url;
    }
    try {
      url = decodeURI(url);
    } catch (err) {
    }
    return urlParse(url);
  }
  function Cookie$1(options) {
    options = options || {};
    Object.keys(options).forEach(function(prop) {
      if (Cookie$1.prototype.hasOwnProperty(prop) && Cookie$1.prototype[prop] !== options[prop] && prop.substr(0, 1) !== "_") {
        this[prop] = options[prop];
      }
    }, this);
    this.creation = this.creation || /* @__PURE__ */ new Date();
    Object.defineProperty(this, "creationIndex", {
      configurable: false,
      enumerable: false,
      // important for assert.deepEqual checks
      writable: true,
      value: ++Cookie$1.cookiesCreated
    });
  }
  Cookie$1.cookiesCreated = 0;
  Cookie$1.parse = parse$1;
  Cookie$1.fromJSON = fromJSON;
  Cookie$1.prototype.key = "";
  Cookie$1.prototype.value = "";
  Cookie$1.prototype.expires = "Infinity";
  Cookie$1.prototype.maxAge = null;
  Cookie$1.prototype.domain = null;
  Cookie$1.prototype.path = null;
  Cookie$1.prototype.secure = false;
  Cookie$1.prototype.httpOnly = false;
  Cookie$1.prototype.extensions = null;
  Cookie$1.prototype.hostOnly = null;
  Cookie$1.prototype.pathIsDefault = null;
  Cookie$1.prototype.creation = null;
  Cookie$1.prototype.lastAccessed = null;
  Object.defineProperty(Cookie$1.prototype, "creationIndex", {
    configurable: true,
    enumerable: false,
    writable: true,
    value: 0
  });
  Cookie$1.serializableProperties = Object.keys(Cookie$1.prototype).filter(function(prop) {
    return !(Cookie$1.prototype[prop] instanceof Function || prop === "creationIndex" || prop.substr(0, 1) === "_");
  });
  Cookie$1.prototype.inspect = function inspect() {
    var now = Date.now();
    return 'Cookie="' + this.toString() + "; hostOnly=" + (this.hostOnly != null ? this.hostOnly : "?") + "; aAge=" + (this.lastAccessed ? now - this.lastAccessed.getTime() + "ms" : "?") + "; cAge=" + (this.creation ? now - this.creation.getTime() + "ms" : "?") + '"';
  };
  if (util$2.inspect.custom) {
    Cookie$1.prototype[util$2.inspect.custom] = Cookie$1.prototype.inspect;
  }
  Cookie$1.prototype.toJSON = function() {
    var obj = {};
    var props = Cookie$1.serializableProperties;
    for (var i2 = 0; i2 < props.length; i2++) {
      var prop = props[i2];
      if (this[prop] === Cookie$1.prototype[prop]) {
        continue;
      }
      if (prop === "expires" || prop === "creation" || prop === "lastAccessed") {
        if (this[prop] === null) {
          obj[prop] = null;
        } else {
          obj[prop] = this[prop] == "Infinity" ? (
            // intentionally not ===
            "Infinity"
          ) : this[prop].toISOString();
        }
      } else if (prop === "maxAge") {
        if (this[prop] !== null) {
          obj[prop] = this[prop] == Infinity || this[prop] == -Infinity ? this[prop].toString() : this[prop];
        }
      } else {
        if (this[prop] !== Cookie$1.prototype[prop]) {
          obj[prop] = this[prop];
        }
      }
    }
    return obj;
  };
  Cookie$1.prototype.clone = function() {
    return fromJSON(this.toJSON());
  };
  Cookie$1.prototype.validate = function validate() {
    if (!COOKIE_OCTETS.test(this.value)) {
      return false;
    }
    if (this.expires != Infinity && !(this.expires instanceof Date) && !parseDate(this.expires)) {
      return false;
    }
    if (this.maxAge != null && this.maxAge <= 0) {
      return false;
    }
    if (this.path != null && !PATH_VALUE.test(this.path)) {
      return false;
    }
    var cdomain = this.cdomain();
    if (cdomain) {
      if (cdomain.match(/\.$/)) {
        return false;
      }
      var suffix = pubsuffix.getPublicSuffix(cdomain);
      if (suffix == null) {
        return false;
      }
    }
    return true;
  };
  Cookie$1.prototype.setExpires = function setExpires(exp) {
    if (exp instanceof Date) {
      this.expires = exp;
    } else {
      this.expires = parseDate(exp) || "Infinity";
    }
  };
  Cookie$1.prototype.setMaxAge = function setMaxAge(age) {
    if (age === Infinity || age === -Infinity) {
      this.maxAge = age.toString();
    } else {
      this.maxAge = age;
    }
  };
  Cookie$1.prototype.cookieString = function cookieString() {
    var val = this.value;
    if (val == null) {
      val = "";
    }
    if (this.key === "") {
      return val;
    }
    return this.key + "=" + val;
  };
  Cookie$1.prototype.toString = function toString() {
    var str = this.cookieString();
    if (this.expires != Infinity) {
      if (this.expires instanceof Date) {
        str += "; Expires=" + formatDate(this.expires);
      } else {
        str += "; Expires=" + this.expires;
      }
    }
    if (this.maxAge != null && this.maxAge != Infinity) {
      str += "; Max-Age=" + this.maxAge;
    }
    if (this.domain && !this.hostOnly) {
      str += "; Domain=" + this.domain;
    }
    if (this.path) {
      str += "; Path=" + this.path;
    }
    if (this.secure) {
      str += "; Secure";
    }
    if (this.httpOnly) {
      str += "; HttpOnly";
    }
    if (this.extensions) {
      this.extensions.forEach(function(ext) {
        str += "; " + ext;
      });
    }
    return str;
  };
  Cookie$1.prototype.TTL = function TTL(now) {
    if (this.maxAge != null) {
      return this.maxAge <= 0 ? 0 : this.maxAge * 1e3;
    }
    var expires = this.expires;
    if (expires != Infinity) {
      if (!(expires instanceof Date)) {
        expires = parseDate(expires) || Infinity;
      }
      if (expires == Infinity) {
        return Infinity;
      }
      return expires.getTime() - (now || Date.now());
    }
    return Infinity;
  };
  Cookie$1.prototype.expiryTime = function expiryTime(now) {
    if (this.maxAge != null) {
      var relativeTo = now || this.creation || /* @__PURE__ */ new Date();
      var age = this.maxAge <= 0 ? -Infinity : this.maxAge * 1e3;
      return relativeTo.getTime() + age;
    }
    if (this.expires == Infinity) {
      return Infinity;
    }
    return this.expires.getTime();
  };
  Cookie$1.prototype.expiryDate = function expiryDate(now) {
    var millisec = this.expiryTime(now);
    if (millisec == Infinity) {
      return new Date(MAX_TIME);
    } else if (millisec == -Infinity) {
      return new Date(MIN_TIME);
    } else {
      return new Date(millisec);
    }
  };
  Cookie$1.prototype.isPersistent = function isPersistent() {
    return this.maxAge != null || this.expires != Infinity;
  };
  Cookie$1.prototype.cdomain = Cookie$1.prototype.canonicalizedDomain = function canonicalizedDomain() {
    if (this.domain == null) {
      return null;
    }
    return canonicalDomain(this.domain);
  };
  function CookieJar$1(store2, options) {
    if (typeof options === "boolean") {
      options = { rejectPublicSuffixes: options };
    } else if (options == null) {
      options = {};
    }
    if (options.rejectPublicSuffixes != null) {
      this.rejectPublicSuffixes = options.rejectPublicSuffixes;
    }
    if (options.looseMode != null) {
      this.enableLooseMode = options.looseMode;
    }
    if (!store2) {
      store2 = new MemoryCookieStore();
    }
    this.store = store2;
  }
  CookieJar$1.prototype.store = null;
  CookieJar$1.prototype.rejectPublicSuffixes = true;
  CookieJar$1.prototype.enableLooseMode = false;
  var CAN_BE_SYNC = [];
  CAN_BE_SYNC.push("setCookie");
  CookieJar$1.prototype.setCookie = function(cookie2, url, options, cb) {
    var err;
    var context = getCookieContext(url);
    if (options instanceof Function) {
      cb = options;
      options = {};
    }
    var host = canonicalDomain(context.hostname);
    var loose = this.enableLooseMode;
    if (options.loose != null) {
      loose = options.loose;
    }
    if (!(cookie2 instanceof Cookie$1)) {
      cookie2 = Cookie$1.parse(cookie2, { loose });
    }
    if (!cookie2) {
      err = new Error("Cookie failed to parse");
      return cb(options.ignoreError ? null : err);
    }
    var now = options.now || /* @__PURE__ */ new Date();
    if (this.rejectPublicSuffixes && cookie2.domain) {
      var suffix = pubsuffix.getPublicSuffix(cookie2.cdomain());
      if (suffix == null) {
        err = new Error("Cookie has domain set to a public suffix");
        return cb(options.ignoreError ? null : err);
      }
    }
    if (cookie2.domain) {
      if (!domainMatch(host, cookie2.cdomain(), false)) {
        err = new Error("Cookie not in this host's domain. Cookie:" + cookie2.cdomain() + " Request:" + host);
        return cb(options.ignoreError ? null : err);
      }
      if (cookie2.hostOnly == null) {
        cookie2.hostOnly = false;
      }
    } else {
      cookie2.hostOnly = true;
      cookie2.domain = host;
    }
    if (!cookie2.path || cookie2.path[0] !== "/") {
      cookie2.path = defaultPath(context.pathname);
      cookie2.pathIsDefault = true;
    }
    if (options.http === false && cookie2.httpOnly) {
      err = new Error("Cookie is HttpOnly and this isn't an HTTP API");
      return cb(options.ignoreError ? null : err);
    }
    var store2 = this.store;
    if (!store2.updateCookie) {
      store2.updateCookie = function(oldCookie, newCookie, cb2) {
        this.putCookie(newCookie, cb2);
      };
    }
    function withCookie(err2, oldCookie) {
      if (err2) {
        return cb(err2);
      }
      var next = function(err3) {
        if (err3) {
          return cb(err3);
        } else {
          cb(null, cookie2);
        }
      };
      if (oldCookie) {
        if (options.http === false && oldCookie.httpOnly) {
          err2 = new Error("old Cookie is HttpOnly and this isn't an HTTP API");
          return cb(options.ignoreError ? null : err2);
        }
        cookie2.creation = oldCookie.creation;
        cookie2.creationIndex = oldCookie.creationIndex;
        cookie2.lastAccessed = now;
        store2.updateCookie(oldCookie, cookie2, next);
      } else {
        cookie2.creation = cookie2.lastAccessed = now;
        store2.putCookie(cookie2, next);
      }
    }
    store2.findCookie(cookie2.domain, cookie2.path, cookie2.key, withCookie);
  };
  CAN_BE_SYNC.push("getCookies");
  CookieJar$1.prototype.getCookies = function(url, options, cb) {
    var context = getCookieContext(url);
    if (options instanceof Function) {
      cb = options;
      options = {};
    }
    var host = canonicalDomain(context.hostname);
    var path = context.pathname || "/";
    var secure = options.secure;
    if (secure == null && context.protocol && (context.protocol == "https:" || context.protocol == "wss:")) {
      secure = true;
    }
    var http = options.http;
    if (http == null) {
      http = true;
    }
    var now = options.now || Date.now();
    var expireCheck = options.expire !== false;
    var allPaths = !!options.allPaths;
    var store2 = this.store;
    function matchingCookie(c2) {
      if (c2.hostOnly) {
        if (c2.domain != host) {
          return false;
        }
      } else {
        if (!domainMatch(host, c2.domain, false)) {
          return false;
        }
      }
      if (!allPaths && !pathMatch(path, c2.path)) {
        return false;
      }
      if (c2.secure && !secure) {
        return false;
      }
      if (c2.httpOnly && !http) {
        return false;
      }
      if (expireCheck && c2.expiryTime() <= now) {
        store2.removeCookie(c2.domain, c2.path, c2.key, function() {
        });
        return false;
      }
      return true;
    }
    store2.findCookies(host, allPaths ? null : path, function(err, cookies2) {
      if (err) {
        return cb(err);
      }
      cookies2 = cookies2.filter(matchingCookie);
      if (options.sort !== false) {
        cookies2 = cookies2.sort(cookieCompare);
      }
      var now2 = /* @__PURE__ */ new Date();
      cookies2.forEach(function(c2) {
        c2.lastAccessed = now2;
      });
      cb(null, cookies2);
    });
  };
  CAN_BE_SYNC.push("getCookieString");
  CookieJar$1.prototype.getCookieString = function() {
    var args = Array.prototype.slice.call(arguments, 0);
    var cb = args.pop();
    var next = function(err, cookies2) {
      if (err) {
        cb(err);
      } else {
        cb(null, cookies2.sort(cookieCompare).map(function(c2) {
          return c2.cookieString();
        }).join("; "));
      }
    };
    args.push(next);
    this.getCookies.apply(this, args);
  };
  CAN_BE_SYNC.push("getSetCookieStrings");
  CookieJar$1.prototype.getSetCookieStrings = function() {
    var args = Array.prototype.slice.call(arguments, 0);
    var cb = args.pop();
    var next = function(err, cookies2) {
      if (err) {
        cb(err);
      } else {
        cb(null, cookies2.map(function(c2) {
          return c2.toString();
        }));
      }
    };
    args.push(next);
    this.getCookies.apply(this, args);
  };
  CAN_BE_SYNC.push("serialize");
  CookieJar$1.prototype.serialize = function(cb) {
    var type2 = this.store.constructor.name;
    if (type2 === "Object") {
      type2 = null;
    }
    var serialized = {
      // The version of tough-cookie that serialized this jar. Generally a good
      // practice since future versions can make data import decisions based on
      // known past behavior. When/if this matters, use `semver`.
      version: "tough-cookie@" + VERSION,
      // add the store type, to make humans happy:
      storeType: type2,
      // CookieJar configuration:
      rejectPublicSuffixes: !!this.rejectPublicSuffixes,
      // this gets filled from getAllCookies:
      cookies: []
    };
    if (!(this.store.getAllCookies && typeof this.store.getAllCookies === "function")) {
      return cb(new Error("store does not support getAllCookies and cannot be serialized"));
    }
    this.store.getAllCookies(function(err, cookies2) {
      if (err) {
        return cb(err);
      }
      serialized.cookies = cookies2.map(function(cookie2) {
        cookie2 = cookie2 instanceof Cookie$1 ? cookie2.toJSON() : cookie2;
        delete cookie2.creationIndex;
        return cookie2;
      });
      return cb(null, serialized);
    });
  };
  CookieJar$1.prototype.toJSON = function() {
    return this.serializeSync();
  };
  CAN_BE_SYNC.push("_importCookies");
  CookieJar$1.prototype._importCookies = function(serialized, cb) {
    var jar = this;
    var cookies2 = serialized.cookies;
    if (!cookies2 || !Array.isArray(cookies2)) {
      return cb(new Error("serialized jar has no cookies array"));
    }
    cookies2 = cookies2.slice();
    function putNext(err) {
      if (err) {
        return cb(err);
      }
      if (!cookies2.length) {
        return cb(err, jar);
      }
      var cookie2;
      try {
        cookie2 = fromJSON(cookies2.shift());
      } catch (e) {
        return cb(e);
      }
      if (cookie2 === null) {
        return putNext(null);
      }
      jar.store.putCookie(cookie2, putNext);
    }
    putNext();
  };
  CookieJar$1.deserialize = function(strOrObj, store2, cb) {
    if (arguments.length !== 3) {
      cb = store2;
      store2 = null;
    }
    var serialized;
    if (typeof strOrObj === "string") {
      serialized = jsonParse(strOrObj);
      if (serialized instanceof Error) {
        return cb(serialized);
      }
    } else {
      serialized = strOrObj;
    }
    var jar = new CookieJar$1(store2, serialized.rejectPublicSuffixes);
    jar._importCookies(serialized, function(err) {
      if (err) {
        return cb(err);
      }
      cb(null, jar);
    });
  };
  CookieJar$1.deserializeSync = function(strOrObj, store2) {
    var serialized = typeof strOrObj === "string" ? JSON.parse(strOrObj) : strOrObj;
    var jar = new CookieJar$1(store2, serialized.rejectPublicSuffixes);
    if (!jar.store.synchronous) {
      throw new Error("CookieJar store is not synchronous; use async API instead.");
    }
    jar._importCookiesSync(serialized);
    return jar;
  };
  CookieJar$1.fromJSON = CookieJar$1.deserializeSync;
  CookieJar$1.prototype.clone = function(newStore, cb) {
    if (arguments.length === 1) {
      cb = newStore;
      newStore = null;
    }
    this.serialize(function(err, serialized) {
      if (err) {
        return cb(err);
      }
      CookieJar$1.deserialize(serialized, newStore, cb);
    });
  };
  CAN_BE_SYNC.push("removeAllCookies");
  CookieJar$1.prototype.removeAllCookies = function(cb) {
    var store2 = this.store;
    if (store2.removeAllCookies instanceof Function && store2.removeAllCookies !== Store.prototype.removeAllCookies) {
      return store2.removeAllCookies(cb);
    }
    store2.getAllCookies(function(err, cookies2) {
      if (err) {
        return cb(err);
      }
      if (cookies2.length === 0) {
        return cb(null);
      }
      var completedCount = 0;
      var removeErrors = [];
      function removeCookieCb(removeErr) {
        if (removeErr) {
          removeErrors.push(removeErr);
        }
        completedCount++;
        if (completedCount === cookies2.length) {
          return cb(removeErrors.length ? removeErrors[0] : null);
        }
      }
      cookies2.forEach(function(cookie2) {
        store2.removeCookie(cookie2.domain, cookie2.path, cookie2.key, removeCookieCb);
      });
    });
  };
  CookieJar$1.prototype._cloneSync = syncWrap("clone");
  CookieJar$1.prototype.cloneSync = function(newStore) {
    if (!newStore.synchronous) {
      throw new Error("CookieJar clone destination store is not synchronous; use async API instead.");
    }
    return this._cloneSync(newStore);
  };
  function syncWrap(method) {
    return function() {
      if (!this.store.synchronous) {
        throw new Error("CookieJar store is not synchronous; use async API instead.");
      }
      var args = Array.prototype.slice.call(arguments);
      var syncErr, syncResult;
      args.push(function syncCb(err, result2) {
        syncErr = err;
        syncResult = result2;
      });
      this[method].apply(this, args);
      if (syncErr) {
        throw syncErr;
      }
      return syncResult;
    };
  }
  CAN_BE_SYNC.forEach(function(method) {
    CookieJar$1.prototype[method + "Sync"] = syncWrap(method);
  });
  cookie.version = VERSION;
  cookie.CookieJar = CookieJar$1;
  cookie.Cookie = Cookie$1;
  cookie.Store = Store;
  cookie.MemoryCookieStore = MemoryCookieStore;
  cookie.parseDate = parseDate;
  cookie.formatDate = formatDate;
  cookie.parse = parse$1;
  cookie.fromJSON = fromJSON;
  cookie.domainMatch = domainMatch;
  cookie.defaultPath = defaultPath;
  cookie.pathMatch = pathMatch;
  cookie.getPublicSuffix = pubsuffix.getPublicSuffix;
  cookie.cookieCompare = cookieCompare;
  cookie.permuteDomain = permuteDomain$2.permuteDomain;
  cookie.permutePath = permutePath;
  cookie.canonicalDomain = canonicalDomain;
  var tough = cookie;
  var Cookie = tough.Cookie;
  var CookieJar = tough.CookieJar;
  cookies$1.parse = function(str) {
    if (str && str.uri) {
      str = str.uri;
    }
    if (typeof str !== "string") {
      throw new Error("The cookie function only accepts STRING as param");
    }
    return Cookie.parse(str, { loose: true });
  };
  function RequestJar(store2) {
    var self2 = this;
    self2._jar = new CookieJar(store2, { looseMode: true });
  }
  RequestJar.prototype.setCookie = function(cookieOrStr, uri, options) {
    var self2 = this;
    return self2._jar.setCookieSync(cookieOrStr, uri, options || {});
  };
  RequestJar.prototype.getCookieString = function(uri) {
    var self2 = this;
    return self2._jar.getCookieStringSync(uri);
  };
  RequestJar.prototype.getCookies = function(uri) {
    var self2 = this;
    return self2._jar.getCookiesSync(uri);
  };
  cookies$1.jar = function(store2) {
    return new RequestJar(store2);
  };
  var helpers$1 = {};
  var stringify = { exports: {} };
  (function(module, exports) {
    exports = module.exports = stringify2;
    exports.getSerialize = serializer;
    function stringify2(obj, replacer, spaces, cycleReplacer) {
      return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
    }
    function serializer(replacer, cycleReplacer) {
      var stack = [], keys = [];
      if (cycleReplacer == null)
        cycleReplacer = function(key2, value) {
          if (stack[0] === value)
            return "[Circular ~]";
          return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
        };
      return function(key2, value) {
        if (stack.length > 0) {
          var thisPos = stack.indexOf(this);
          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
          ~thisPos ? keys.splice(thisPos, Infinity, key2) : keys.push(key2);
          if (~stack.indexOf(value))
            value = cycleReplacer.call(this, key2, value);
        } else
          stack.push(value);
        return replacer == null ? value : replacer.call(this, key2, value);
      };
    }
  })(stringify, stringify.exports);
  var stringifyExports = stringify.exports;
  var safeBuffer = { exports: {} };
  /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
  (function(module, exports) {
    var buffer = require$$0$2;
    var Buffer2 = buffer.Buffer;
    function copyProps(src, dst) {
      for (var key2 in src) {
        dst[key2] = src[key2];
      }
    }
    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
      module.exports = buffer;
    } else {
      copyProps(buffer, exports);
      exports.Buffer = SafeBuffer;
    }
    function SafeBuffer(arg, encodingOrOffset, length) {
      return Buffer2(arg, encodingOrOffset, length);
    }
    SafeBuffer.prototype = Object.create(Buffer2.prototype);
    copyProps(Buffer2, SafeBuffer);
    SafeBuffer.from = function(arg, encodingOrOffset, length) {
      if (typeof arg === "number") {
        throw new TypeError("Argument must not be a number");
      }
      return Buffer2(arg, encodingOrOffset, length);
    };
    SafeBuffer.alloc = function(size, fill, encoding) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      var buf = Buffer2(size);
      if (fill !== void 0) {
        if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
      } else {
        buf.fill(0);
      }
      return buf;
    };
    SafeBuffer.allocUnsafe = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return Buffer2(size);
    };
    SafeBuffer.allocUnsafeSlow = function(size) {
      if (typeof size !== "number") {
        throw new TypeError("Argument must be a number");
      }
      return buffer.SlowBuffer(size);
    };
  })(safeBuffer, safeBuffer.exports);
  var safeBufferExports = safeBuffer.exports;
  var jsonSafeStringify = stringifyExports;
  var crypto$1 = require$$0$2;
  var Buffer$1 = safeBufferExports.Buffer;
  var defer = typeof setImmediate === "undefined" ? process.nextTick : setImmediate;
  function paramsHaveRequestBody$1(params) {
    return params.body || params.requestBodyStream || params.json && typeof params.json !== "boolean" || params.multipart;
  }
  function safeStringify(obj, replacer) {
    var ret;
    try {
      ret = JSON.stringify(obj, replacer);
    } catch (e) {
      ret = jsonSafeStringify(obj, replacer);
    }
    return ret;
  }
  function md5$1(str) {
    return crypto$1.createHash("md5").update(str).digest("hex");
  }
  function isReadStream(rs) {
    return rs.readable && rs.path && rs.mode;
  }
  function toBase64(str) {
    return Buffer$1.from(str || "", "utf8").toString("base64");
  }
  function copy(obj) {
    var o = {};
    Object.keys(obj).forEach(function(i2) {
      o[i2] = obj[i2];
    });
    return o;
  }
  function version() {
    var numbers = process.version.replace("v", "").split(".");
    return {
      major: parseInt(numbers[0], 10),
      minor: parseInt(numbers[1], 10),
      patch: parseInt(numbers[2], 10)
    };
  }
  helpers$1.paramsHaveRequestBody = paramsHaveRequestBody$1;
  helpers$1.safeStringify = safeStringify;
  helpers$1.md5 = md5$1;
  helpers$1.isReadStream = isReadStream;
  helpers$1.toBase64 = toBase64;
  helpers$1.copy = copy;
  helpers$1.version = version;
  helpers$1.defer = defer;
  var awsSign2 = { exports: {} };
  var hasRequiredAwsSign2;
  function requireAwsSign2() {
    if (hasRequiredAwsSign2)
      return awsSign2.exports;
    hasRequiredAwsSign2 = 1;
    /*!
     *  Copyright 2010 LearnBoost <[email protected]>
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    var crypto2 = require$$0$2, parse2 = require$$0$2.parse;
    var keys = [
      "acl",
      "location",
      "logging",
      "notification",
      "partNumber",
      "policy",
      "requestPayment",
      "torrent",
      "uploadId",
      "uploads",
      "versionId",
      "versioning",
      "versions",
      "website"
    ];
    function authorization(options) {
      return "AWS " + options.key + ":" + sign(options);
    }
    awsSign2.exports = authorization;
    awsSign2.exports.authorization = authorization;
    function hmacSha1(options) {
      return crypto2.createHmac("sha1", options.secret).update(options.message).digest("base64");
    }
    awsSign2.exports.hmacSha1 = hmacSha1;
    function sign(options) {
      options.message = stringToSign(options);
      return hmacSha1(options);
    }
    awsSign2.exports.sign = sign;
    function signQuery(options) {
      options.message = queryStringToSign(options);
      return hmacSha1(options);
    }
    awsSign2.exports.signQuery = signQuery;
    function stringToSign(options) {
      var headers = options.amazonHeaders || "";
      if (headers)
        headers += "\n";
      var r = [
        options.verb,
        options.md5,
        options.contentType,
        options.date ? options.date.toUTCString() : "",
        headers + options.resource
      ];
      return r.join("\n");
    }
    awsSign2.exports.stringToSign = stringToSign;
    function queryStringToSign(options) {
      return "GET\n\n\n" + options.date + "\n" + options.resource;
    }
    awsSign2.exports.queryStringToSign = queryStringToSign;
    function canonicalizeHeaders(headers) {
      var buf = [], fields = Object.keys(headers);
      for (var i2 = 0, len = fields.length; i2 < len; ++i2) {
        var field = fields[i2], val = headers[field], field = field.toLowerCase();
        if (0 !== field.indexOf("x-amz"))
          continue;
        buf.push(field + ":" + val);
      }
      return buf.sort().join("\n");
    }
    awsSign2.exports.canonicalizeHeaders = canonicalizeHeaders;
    function canonicalizeResource(resource) {
      var url = parse2(resource, true), path = url.pathname, buf = [];
      Object.keys(url.query).forEach(function(key2) {
        if (!~keys.indexOf(key2))
          return;
        var val = "" == url.query[key2] ? "" : "=" + encodeURIComponent(url.query[key2]);
        buf.push(key2 + val);
      });
      return path + (buf.length ? "?" + buf.sort().join("&") : "");
    }
    awsSign2.exports.canonicalizeResource = canonicalizeResource;
    return awsSign2.exports;
  }
  var aws4 = {};
  var lru;
  var hasRequiredLru;
  function requireLru() {
    if (hasRequiredLru)
      return lru;
    hasRequiredLru = 1;
    lru = function(size) {
      return new LruCache(size);
    };
    function LruCache(size) {
      this.capacity = size | 0;
      this.map = /* @__PURE__ */ Object.create(null);
      this.list = new DoublyLinkedList();
    }
    LruCache.prototype.get = function(key2) {
      var node = this.map[key2];
      if (node == null)
        return void 0;
      this.used(node);
      return node.val;
    };
    LruCache.prototype.set = function(key2, val) {
      var node = this.map[key2];
      if (node != null) {
        node.val = val;
      } else {
        if (!this.capacity)
          this.prune();
        if (!this.capacity)
          return false;
        node = new DoublyLinkedNode(key2, val);
        this.map[key2] = node;
        this.capacity--;
      }
      this.used(node);
      return true;
    };
    LruCache.prototype.used = function(node) {
      this.list.moveToFront(node);
    };
    LruCache.prototype.prune = function() {
      var node = this.list.pop();
      if (node != null) {
        delete this.map[node.key];
        this.capacity++;
      }
    };
    function DoublyLinkedList() {
      this.firstNode = null;
      this.lastNode = null;
    }
    DoublyLinkedList.prototype.moveToFront = function(node) {
      if (this.firstNode == node)
        return;
      this.remove(node);
      if (this.firstNode == null) {
        this.firstNode = node;
        this.lastNode = node;
        node.prev = null;
        node.next = null;
      } else {
        node.prev = null;
        node.next = this.firstNode;
        node.next.prev = node;
        this.firstNode = node;
      }
    };
    DoublyLinkedList.prototype.pop = function() {
      var lastNode = this.lastNode;
      if (lastNode != null) {
        this.remove(lastNode);
      }
      return lastNode;
    };
    DoublyLinkedList.prototype.remove = function(node) {
      if (this.firstNode == node) {
        this.firstNode = node.next;
      } else if (node.prev != null) {
        node.prev.next = node.next;
      }
      if (this.lastNode == node) {
        this.lastNode = node.prev;
      } else if (node.next != null) {
        node.next.prev = node.prev;
      }
    };
    function DoublyLinkedNode(key2, val) {
      this.key = key2;
      this.val = val;
      this.prev = null;
      this.next = null;
    }
    return lru;
  }
  var hasRequiredAws4;
  function requireAws4() {
    if (hasRequiredAws4)
      return aws4;
    hasRequiredAws4 = 1;
    (function(exports) {
      var aws42 = exports, url = require$$0$2, querystring2 = require$$0$2, crypto2 = require$$0$2, lru2 = requireLru(), credentialsCache = lru2(1e3);
      function hmac2(key2, string, encoding) {
        return crypto2.createHmac("sha256", key2).update(string, "utf8").digest(encoding);
      }
      function hash(string, encoding) {
        return crypto2.createHash("sha256").update(string, "utf8").digest(encoding);
      }
      function encodeRfc3986(urlEncodedString) {
        return urlEncodedString.replace(/[!'()*]/g, function(c2) {
          return "%" + c2.charCodeAt(0).toString(16).toUpperCase();
        });
      }
      function encodeRfc3986Full(str) {
        return encodeRfc3986(encodeURIComponent(str));
      }
      var HEADERS_TO_IGNORE = {
        "authorization": true,
        "connection": true,
        "x-amzn-trace-id": true,
        "user-agent": true,
        "expect": true,
        "presigned-expires": true,
        "range": true
      };
      function RequestSigner(request2, credentials) {
        if (typeof request2 === "string")
          request2 = url.parse(request2);
        var headers = request2.headers = request2.headers || {}, hostParts = (!this.service || !this.region) && this.matchHost(request2.hostname || request2.host || headers.Host || headers.host);
        this.request = request2;
        this.credentials = credentials || this.defaultCredentials();
        this.service = request2.service || hostParts[0] || "";
        this.region = request2.region || hostParts[1] || "us-east-1";
        if (this.service === "email")
          this.service = "ses";
        if (!request2.method && request2.body)
          request2.method = "POST";
        if (!headers.Host && !headers.host) {
          headers.Host = request2.hostname || request2.host || this.createHost();
          if (request2.port)
            headers.Host += ":" + request2.port;
        }
        if (!request2.hostname && !request2.host)
          request2.hostname = headers.Host || headers.host;
        this.isCodeCommitGit = this.service === "codecommit" && request2.method === "GIT";
        this.extraHeadersToIgnore = request2.extraHeadersToIgnore || /* @__PURE__ */ Object.create(null);
        this.extraHeadersToInclude = request2.extraHeadersToInclude || /* @__PURE__ */ Object.create(null);
      }
      RequestSigner.prototype.matchHost = function(host) {
        var match = (host || "").match(/([^\.]+)\.(?:([^\.]*)\.)?amazonaws\.com(\.cn)?$/);
        var hostParts = (match || []).slice(1, 3);
        if (hostParts[1] === "es" || hostParts[1] === "aoss")
          hostParts = hostParts.reverse();
        if (hostParts[1] == "s3") {
          hostParts[0] = "s3";
          hostParts[1] = "us-east-1";
        } else {
          for (var i2 = 0; i2 < 2; i2++) {
            if (/^s3-/.test(hostParts[i2])) {
              hostParts[1] = hostParts[i2].slice(3);
              hostParts[0] = "s3";
              break;
            }
          }
        }
        return hostParts;
      };
      RequestSigner.prototype.isSingleRegion = function() {
        if (["s3", "sdb"].indexOf(this.service) >= 0 && this.region === "us-east-1")
          return true;
        return ["cloudfront", "ls", "route53", "iam", "importexport", "sts"].indexOf(this.service) >= 0;
      };
      RequestSigner.prototype.createHost = function() {
        var region = this.isSingleRegion() ? "" : "." + this.region, subdomain = this.service === "ses" ? "email" : this.service;
        return subdomain + region + ".amazonaws.com";
      };
      RequestSigner.prototype.prepareRequest = function() {
        this.parsePath();
        var request2 = this.request, headers = request2.headers, query;
        if (request2.signQuery) {
          this.parsedPath.query = query = this.parsedPath.query || {};
          if (this.credentials.sessionToken)
            query["X-Amz-Security-Token"] = this.credentials.sessionToken;
          if (this.service === "s3" && !query["X-Amz-Expires"])
            query["X-Amz-Expires"] = 86400;
          if (query["X-Amz-Date"])
            this.datetime = query["X-Amz-Date"];
          else
            query["X-Amz-Date"] = this.getDateTime();
          query["X-Amz-Algorithm"] = "AWS4-HMAC-SHA256";
          query["X-Amz-Credential"] = this.credentials.accessKeyId + "/" + this.credentialString();
          query["X-Amz-SignedHeaders"] = this.signedHeaders();
        } else {
          if (!request2.doNotModifyHeaders && !this.isCodeCommitGit) {
            if (request2.body && !headers["Content-Type"] && !headers["content-type"])
              headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8";
            if (request2.body && !headers["Content-Length"] && !headers["content-length"])
              headers["Content-Length"] = Buffer.byteLength(request2.body);
            if (this.credentials.sessionToken && !headers["X-Amz-Security-Token"] && !headers["x-amz-security-token"])
              headers["X-Amz-Security-Token"] = this.credentials.sessionToken;
            if (this.service === "s3" && !headers["X-Amz-Content-Sha256"] && !headers["x-amz-content-sha256"])
              headers["X-Amz-Content-Sha256"] = hash(this.request.body || "", "hex");
            if (headers["X-Amz-Date"] || headers["x-amz-date"])
              this.datetime = headers["X-Amz-Date"] || headers["x-amz-date"];
            else
              headers["X-Amz-Date"] = this.getDateTime();
          }
          delete headers.Authorization;
          delete headers.authorization;
        }
      };
      RequestSigner.prototype.sign = function() {
        if (!this.parsedPath)
          this.prepareRequest();
        if (this.request.signQuery) {
          this.parsedPath.query["X-Amz-Signature"] = this.signature();
        } else {
          this.request.headers.Authorization = this.authHeader();
        }
        this.request.path = this.formatPath();
        return this.request;
      };
      RequestSigner.prototype.getDateTime = function() {
        if (!this.datetime) {
          var headers = this.request.headers, date = new Date(headers.Date || headers.date || /* @__PURE__ */ new Date());
          this.datetime = date.toISOString().replace(/[:\-]|\.\d{3}/g, "");
          if (this.isCodeCommitGit)
            this.datetime = this.datetime.slice(0, -1);
        }
        return this.datetime;
      };
      RequestSigner.prototype.getDate = function() {
        return this.getDateTime().substr(0, 8);
      };
      RequestSigner.prototype.authHeader = function() {
        return [
          "AWS4-HMAC-SHA256 Credential=" + this.credentials.accessKeyId + "/" + this.credentialString(),
          "SignedHeaders=" + this.signedHeaders(),
          "Signature=" + this.signature()
        ].join(", ");
      };
      RequestSigner.prototype.signature = function() {
        var date = this.getDate(), cacheKey = [this.credentials.secretAccessKey, date, this.region, this.service].join(), kDate, kRegion, kService, kCredentials = credentialsCache.get(cacheKey);
        if (!kCredentials) {
          kDate = hmac2("AWS4" + this.credentials.secretAccessKey, date);
          kRegion = hmac2(kDate, this.region);
          kService = hmac2(kRegion, this.service);
          kCredentials = hmac2(kService, "aws4_request");
          credentialsCache.set(cacheKey, kCredentials);
        }
        return hmac2(kCredentials, this.stringToSign(), "hex");
      };
      RequestSigner.prototype.stringToSign = function() {
        return [
          "AWS4-HMAC-SHA256",
          this.getDateTime(),
          this.credentialString(),
          hash(this.canonicalString(), "hex")
        ].join("\n");
      };
      RequestSigner.prototype.canonicalString = function() {
        if (!this.parsedPath)
          this.prepareRequest();
        var pathStr = this.parsedPath.path, query = this.parsedPath.query, headers = this.request.headers, queryStr = "", normalizePath = this.service !== "s3", decodePath = this.service === "s3" || this.request.doNotEncodePath, decodeSlashesInPath = this.service === "s3", firstValOnly = this.service === "s3", bodyHash;
        if (this.service === "s3" && this.request.signQuery) {
          bodyHash = "UNSIGNED-PAYLOAD";
        } else if (this.isCodeCommitGit) {
          bodyHash = "";
        } else {
          bodyHash = headers["X-Amz-Content-Sha256"] || headers["x-amz-content-sha256"] || hash(this.request.body || "", "hex");
        }
        if (query) {
          var reducedQuery = Object.keys(query).reduce(function(obj, key2) {
            if (!key2)
              return obj;
            obj[encodeRfc3986Full(key2)] = !Array.isArray(query[key2]) ? query[key2] : firstValOnly ? query[key2][0] : query[key2];
            return obj;
          }, {});
          var encodedQueryPieces = [];
          Object.keys(reducedQuery).sort().forEach(function(key2) {
            if (!Array.isArray(reducedQuery[key2])) {
              encodedQueryPieces.push(key2 + "=" + encodeRfc3986Full(reducedQuery[key2]));
            } else {
              reducedQuery[key2].map(encodeRfc3986Full).sort().forEach(function(val) {
                encodedQueryPieces.push(key2 + "=" + val);
              });
            }
          });
          queryStr = encodedQueryPieces.join("&");
        }
        if (pathStr !== "/") {
          if (normalizePath)
            pathStr = pathStr.replace(/\/{2,}/g, "/");
          pathStr = pathStr.split("/").reduce(function(path, piece) {
            if (normalizePath && piece === "..") {
              path.pop();
            } else if (!normalizePath || piece !== ".") {
              if (decodePath)
                piece = decodeURIComponent(piece.replace(/\+/g, " "));
              path.push(encodeRfc3986Full(piece));
            }
            return path;
          }, []).join("/");
          if (pathStr[0] !== "/")
            pathStr = "/" + pathStr;
          if (decodeSlashesInPath)
            pathStr = pathStr.replace(/%2F/g, "/");
        }
        return [
          this.request.method || "GET",
          pathStr,
          queryStr,
          this.canonicalHeaders() + "\n",
          this.signedHeaders(),
          bodyHash
        ].join("\n");
      };
      RequestSigner.prototype.canonicalHeaders = function() {
        var headers = this.request.headers;
        function trimAll(header) {
          return header.toString().trim().replace(/\s+/g, " ");
        }
        return Object.keys(headers).filter(function(key2) {
          return HEADERS_TO_IGNORE[key2.toLowerCase()] == null;
        }).sort(function(a2, b2) {
          return a2.toLowerCase() < b2.toLowerCase() ? -1 : 1;
        }).map(function(key2) {
          return key2.toLowerCase() + ":" + trimAll(headers[key2]);
        }).join("\n");
      };
      RequestSigner.prototype.signedHeaders = function() {
        var extraHeadersToInclude = this.extraHeadersToInclude, extraHeadersToIgnore = this.extraHeadersToIgnore;
        return Object.keys(this.request.headers).map(function(key2) {
          return key2.toLowerCase();
        }).filter(function(key2) {
          return extraHeadersToInclude[key2] || HEADERS_TO_IGNORE[key2] == null && !extraHeadersToIgnore[key2];
        }).sort().join(";");
      };
      RequestSigner.prototype.credentialString = function() {
        return [
          this.getDate(),
          this.region,
          this.service,
          "aws4_request"
        ].join("/");
      };
      RequestSigner.prototype.defaultCredentials = function() {
        var env = process.env;
        return {
          accessKeyId: env.AWS_ACCESS_KEY_ID || env.AWS_ACCESS_KEY,
          secretAccessKey: env.AWS_SECRET_ACCESS_KEY || env.AWS_SECRET_KEY,
          sessionToken: env.AWS_SESSION_TOKEN
        };
      };
      RequestSigner.prototype.parsePath = function() {
        var path = this.request.path || "/";
        if (/[^0-9A-Za-z;,/?:@&=+$\-_.!~*'()#%]/.test(path)) {
          path = encodeURI(decodeURI(path));
        }
        var queryIx = path.indexOf("?"), query = null;
        if (queryIx >= 0) {
          query = querystring2.parse(path.slice(queryIx + 1));
          path = path.slice(0, queryIx);
        }
        this.parsedPath = {
          path,
          query
        };
      };
      RequestSigner.prototype.formatPath = function() {
        var path = this.parsedPath.path, query = this.parsedPath.query;
        if (!query)
          return path;
        if (query[""] != null)
          delete query[""];
        return path + "?" + encodeRfc3986(querystring2.stringify(query));
      };
      aws42.RequestSigner = RequestSigner;
      aws42.sign = function(request2, credentials) {
        return new RequestSigner(request2, credentials).sign();
      };
    })(aws4);
    return aws4;
  }
  var assert_1;
  var hasRequiredAssert;
  function requireAssert() {
    if (hasRequiredAssert)
      return assert_1;
    hasRequiredAssert = 1;
    var assert = require$$0$2;
    var Stream = require$$0$2.Stream;
    var util2 = require$$0$2;
    var UUID_REGEXP = /^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/;
    function _capitalize(str) {
      return str.charAt(0).toUpperCase() + str.slice(1);
    }
    function _toss(name, expected, oper, arg, actual) {
      throw new assert.AssertionError({
        message: util2.format("%s (%s) is required", name, expected),
        actual: actual === void 0 ? typeof arg : actual(arg),
        expected,
        operator: oper || "===",
        stackStartFunction: _toss.caller
      });
    }
    function _getClass(arg) {
      return Object.prototype.toString.call(arg).slice(8, -1);
    }
    function noop() {
    }
    var types2 = {
      bool: {
        check: function(arg) {
          return typeof arg === "boolean";
        }
      },
      func: {
        check: function(arg) {
          return typeof arg === "function";
        }
      },
      string: {
        check: function(arg) {
          return typeof arg === "string";
        }
      },
      object: {
        check: function(arg) {
          return typeof arg === "object" && arg !== null;
        }
      },
      number: {
        check: function(arg) {
          return typeof arg === "number" && !isNaN(arg);
        }
      },
      finite: {
        check: function(arg) {
          return typeof arg === "number" && !isNaN(arg) && isFinite(arg);
        }
      },
      buffer: {
        check: function(arg) {
          return Buffer.isBuffer(arg);
        },
        operator: "Buffer.isBuffer"
      },
      array: {
        check: function(arg) {
          return Array.isArray(arg);
        },
        operator: "Array.isArray"
      },
      stream: {
        check: function(arg) {
          return arg instanceof Stream;
        },
        operator: "instanceof",
        actual: _getClass
      },
      date: {
        check: function(arg) {
          return arg instanceof Date;
        },
        operator: "instanceof",
        actual: _getClass
      },
      regexp: {
        check: function(arg) {
          return arg instanceof RegExp;
        },
        operator: "instanceof",
        actual: _getClass
      },
      uuid: {
        check: function(arg) {
          return typeof arg === "string" && UUID_REGEXP.test(arg);
        },
        operator: "isUUID"
      }
    };
    function _setExports(ndebug) {
      var keys = Object.keys(types2);
      var out;
      if ({}.NODE_NDEBUG) {
        out = noop;
      } else {
        out = function(arg, msg) {
          if (!arg) {
            _toss(msg, "true", arg);
          }
        };
      }
      keys.forEach(function(k) {
        if (ndebug) {
          out[k] = noop;
          return;
        }
        var type2 = types2[k];
        out[k] = function(arg, msg) {
          if (!type2.check(arg)) {
            _toss(msg, k, type2.operator, arg, type2.actual);
          }
        };
      });
      keys.forEach(function(k) {
        var name = "optional" + _capitalize(k);
        if (ndebug) {
          out[name] = noop;
          return;
        }
        var type2 = types2[k];
        out[name] = function(arg, msg) {
          if (arg === void 0 || arg === null) {
            return;
          }
          if (!type2.check(arg)) {
            _toss(msg, k, type2.operator, arg, type2.actual);
          }
        };
      });
      keys.forEach(function(k) {
        var name = "arrayOf" + _capitalize(k);
        if (ndebug) {
          out[name] = noop;
          return;
        }
        var type2 = types2[k];
        var expected = "[" + k + "]";
        out[name] = function(arg, msg) {
          if (!Array.isArray(arg)) {
            _toss(msg, expected, type2.operator, arg, type2.actual);
          }
          var i2;
          for (i2 = 0; i2 < arg.length; i2++) {
            if (!type2.check(arg[i2])) {
              _toss(msg, expected, type2.operator, arg, type2.actual);
            }
          }
        };
      });
      keys.forEach(function(k) {
        var name = "optionalArrayOf" + _capitalize(k);
        if (ndebug) {
          out[name] = noop;
          return;
        }
        var type2 = types2[k];
        var expected = "[" + k + "]";
        out[name] = function(arg, msg) {
          if (arg === void 0 || arg === null) {
            return;
          }
          if (!Array.isArray(arg)) {
            _toss(msg, expected, type2.operator, arg, type2.actual);
          }
          var i2;
          for (i2 = 0; i2 < arg.length; i2++) {
            if (!type2.check(arg[i2])) {
              _toss(msg, expected, type2.operator, arg, type2.actual);
            }
          }
        };
      });
      Object.keys(assert).forEach(function(k) {
        if (k === "AssertionError") {
          out[k] = assert[k];
          return;
        }
        if (ndebug) {
          out[k] = noop;
          return;
        }
        out[k] = assert[k];
      });
      out._setExports = _setExports;
      return out;
    }
    assert_1 = _setExports({}.NODE_NDEBUG);
    return assert_1;
  }
  var safer_1;
  var hasRequiredSafer;
  function requireSafer() {
    if (hasRequiredSafer)
      return safer_1;
    hasRequiredSafer = 1;
    var buffer = require$$0$2;
    var Buffer2 = buffer.Buffer;
    var safer = {};
    var key2;
    for (key2 in buffer) {
      if (!buffer.hasOwnProperty(key2))
        continue;
      if (key2 === "SlowBuffer" || key2 === "Buffer")
        continue;
      safer[key2] = buffer[key2];
    }
    var Safer = safer.Buffer = {};
    for (key2 in Buffer2) {
      if (!Buffer2.hasOwnProperty(key2))
        continue;
      if (key2 === "allocUnsafe" || key2 === "allocUnsafeSlow")
        continue;
      Safer[key2] = Buffer2[key2];
    }
    safer.Buffer.prototype = Buffer2.prototype;
    if (!Safer.from || Safer.from === Uint8Array.from) {
      Safer.from = function(value, encodingOrOffset, length) {
        if (typeof value === "number") {
          throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
        }
        if (value && typeof value.length === "undefined") {
          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
        }
        return Buffer2(value, encodingOrOffset, length);
      };
    }
    if (!Safer.alloc) {
      Safer.alloc = function(size, fill, encoding) {
        if (typeof size !== "number") {
          throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
        }
        if (size < 0 || size >= 2 * (1 << 30)) {
          throw new RangeError('The value "' + size + '" is invalid for option "size"');
        }
        var buf = Buffer2(size);
        if (!fill || fill.length === 0) {
          buf.fill(0);
        } else if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
        return buf;
      };
    }
    if (!safer.kStringMaxLength) {
      try {
        safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
      } catch (e) {
      }
    }
    if (!safer.constants) {
      safer.constants = {
        MAX_LENGTH: safer.kMaxLength
      };
      if (safer.kStringMaxLength) {
        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
      }
    }
    safer_1 = safer;
    return safer_1;
  }
  var algs;
  var hasRequiredAlgs;
  function requireAlgs() {
    if (hasRequiredAlgs)
      return algs;
    hasRequiredAlgs = 1;
    var Buffer2 = requireSafer().Buffer;
    var algInfo = {
      "dsa": {
        parts: ["p", "q", "g", "y"],
        sizePart: "p"
      },
      "rsa": {
        parts: ["e", "n"],
        sizePart: "n"
      },
      "ecdsa": {
        parts: ["curve", "Q"],
        sizePart: "Q"
      },
      "ed25519": {
        parts: ["A"],
        sizePart: "A"
      }
    };
    algInfo["curve25519"] = algInfo["ed25519"];
    var algPrivInfo = {
      "dsa": {
        parts: ["p", "q", "g", "y", "x"]
      },
      "rsa": {
        parts: ["n", "e", "d", "iqmp", "p", "q"]
      },
      "ecdsa": {
        parts: ["curve", "Q", "d"]
      },
      "ed25519": {
        parts: ["A", "k"]
      }
    };
    algPrivInfo["curve25519"] = algPrivInfo["ed25519"];
    var hashAlgs = {
      "md5": true,
      "sha1": true,
      "sha256": true,
      "sha384": true,
      "sha512": true
    };
    var curves = {
      "nistp256": {
        size: 256,
        pkcs8oid: "1.2.840.10045.3.1.7",
        p: Buffer2.from("00ffffffff 00000001 00000000 0000000000000000 ffffffff ffffffff ffffffff".replace(/ /g, ""), "hex"),
        a: Buffer2.from("00FFFFFFFF 00000001 00000000 0000000000000000 FFFFFFFF FFFFFFFF FFFFFFFC".replace(/ /g, ""), "hex"),
        b: Buffer2.from("5ac635d8 aa3a93e7 b3ebbd55 769886bc651d06b0 cc53b0f6 3bce3c3e 27d2604b".replace(/ /g, ""), "hex"),
        s: Buffer2.from("00c49d3608 86e70493 6a6678e1 139d26b7819f7e90".replace(/ /g, ""), "hex"),
        n: Buffer2.from("00ffffffff 00000000 ffffffff ffffffffbce6faad a7179e84 f3b9cac2 fc632551".replace(/ /g, ""), "hex"),
        G: Buffer2.from("046b17d1f2 e12c4247 f8bce6e5 63a440f277037d81 2deb33a0 f4a13945 d898c2964fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e162bce3357 6b315ece cbb64068 37bf51f5".replace(/ /g, ""), "hex")
      },
      "nistp384": {
        size: 384,
        pkcs8oid: "1.3.132.0.34",
        p: Buffer2.from("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff fffffffeffffffff 00000000 00000000 ffffffff".replace(/ /g, ""), "hex"),
        a: Buffer2.from("00FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFEFFFFFFFF 00000000 00000000 FFFFFFFC".replace(/ /g, ""), "hex"),
        b: Buffer2.from("b3312fa7 e23ee7e4 988e056b e3f82d19181d9c6e fe814112 0314088f 5013875ac656398d 8a2ed19d 2a85c8ed d3ec2aef".replace(/ /g, ""), "hex"),
        s: Buffer2.from("00a335926a a319a27a 1d00896a 6773a4827acdac73".replace(/ /g, ""), "hex"),
        n: Buffer2.from("00ffffffff ffffffff ffffffff ffffffffffffffff ffffffff c7634d81 f4372ddf581a0db2 48b0a77a ecec196a ccc52973".replace(/ /g, ""), "hex"),
        G: Buffer2.from("04aa87ca22 be8b0537 8eb1c71e f320ad746e1d3b62 8ba79b98 59f741e0 82542a385502f25d bf55296c 3a545e38 72760ab73617de4a 96262c6f 5d9e98bf 9292dc29f8f41dbd 289a147c e9da3113 b5f0b8c00a60b1ce 1d7e819d 7a431d7c 90ea0e5f".replace(/ /g, ""), "hex")
      },
      "nistp521": {
        size: 521,
        pkcs8oid: "1.3.132.0.35",
        p: Buffer2.from("01ffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff ffffffffffff".replace(/ /g, ""), "hex"),
        a: Buffer2.from("01FFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFC".replace(/ /g, ""), "hex"),
        b: Buffer2.from("51953eb961 8e1c9a1f 929a21a0 b68540eea2da725b 99b315f3 b8b48991 8ef109e156193951 ec7e937b 1652c0bd 3bb1bf073573df88 3d2c34f1 ef451fd4 6b503f00".replace(/ /g, ""), "hex"),
        s: Buffer2.from("00d09e8800 291cb853 96cc6717 393284aaa0da64ba".replace(/ /g, ""), "hex"),
        n: Buffer2.from("01ffffffffff ffffffff ffffffff ffffffffffffffff ffffffff ffffffff fffffffa51868783 bf2f966b 7fcc0148 f709a5d03bb5c9b8 899c47ae bb6fb71e 91386409".replace(/ /g, ""), "hex"),
        G: Buffer2.from("0400c6 858e06b7 0404e9cd 9e3ecb66 2395b4429c648139 053fb521 f828af60 6b4d3dbaa14b5e77 efe75928 fe1dc127 a2ffa8de3348b3c1 856a429b f97e7e31 c2e5bd660118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd998f54449 579b4468 17afbd17 273e662c97ee7299 5ef42640 c550b901 3fad0761353c7086 a272c240 88be9476 9fd16650".replace(/ /g, ""), "hex")
      }
    };
    algs = {
      info: algInfo,
      privInfo: algPrivInfo,
      hashAlgs,
      curves
    };
    return algs;
  }
  var errors$1;
  var hasRequiredErrors$1;
  function requireErrors$1() {
    if (hasRequiredErrors$1)
      return errors$1;
    hasRequiredErrors$1 = 1;
    requireAssert();
    var util2 = require$$0$2;
    function FingerprintFormatError(fp, format2) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, FingerprintFormatError);
      this.name = "FingerprintFormatError";
      this.fingerprint = fp;
      this.format = format2;
      this.message = "Fingerprint format is not supported, or is invalid: ";
      if (fp !== void 0)
        this.message += " fingerprint = " + fp;
      if (format2 !== void 0)
        this.message += " format = " + format2;
    }
    util2.inherits(FingerprintFormatError, Error);
    function InvalidAlgorithmError(alg) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, InvalidAlgorithmError);
      this.name = "InvalidAlgorithmError";
      this.algorithm = alg;
      this.message = 'Algorithm "' + alg + '" is not supported';
    }
    util2.inherits(InvalidAlgorithmError, Error);
    function KeyParseError(name, format2, innerErr) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, KeyParseError);
      this.name = "KeyParseError";
      this.format = format2;
      this.keyName = name;
      this.innerErr = innerErr;
      this.message = "Failed to parse " + name + " as a valid " + format2 + " format key: " + innerErr.message;
    }
    util2.inherits(KeyParseError, Error);
    function SignatureParseError(type2, format2, innerErr) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, SignatureParseError);
      this.name = "SignatureParseError";
      this.type = type2;
      this.format = format2;
      this.innerErr = innerErr;
      this.message = "Failed to parse the given data as a " + type2 + " signature in " + format2 + " format: " + innerErr.message;
    }
    util2.inherits(SignatureParseError, Error);
    function CertificateParseError(name, format2, innerErr) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, CertificateParseError);
      this.name = "CertificateParseError";
      this.format = format2;
      this.certName = name;
      this.innerErr = innerErr;
      this.message = "Failed to parse " + name + " as a valid " + format2 + " format certificate: " + innerErr.message;
    }
    util2.inherits(CertificateParseError, Error);
    function KeyEncryptedError(name, format2) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, KeyEncryptedError);
      this.name = "KeyEncryptedError";
      this.format = format2;
      this.keyName = name;
      this.message = "The " + format2 + " format key " + name + " is encrypted (password-protected), and no passphrase was provided in `options`";
    }
    util2.inherits(KeyEncryptedError, Error);
    errors$1 = {
      FingerprintFormatError,
      InvalidAlgorithmError,
      KeyParseError,
      SignatureParseError,
      KeyEncryptedError,
      CertificateParseError
    };
    return errors$1;
  }
  var ber = { exports: {} };
  var errors;
  var hasRequiredErrors;
  function requireErrors() {
    if (hasRequiredErrors)
      return errors;
    hasRequiredErrors = 1;
    errors = {
      newInvalidAsn1Error: function(msg) {
        var e = new Error();
        e.name = "InvalidAsn1Error";
        e.message = msg || "";
        return e;
      }
    };
    return errors;
  }
  var types;
  var hasRequiredTypes;
  function requireTypes() {
    if (hasRequiredTypes)
      return types;
    hasRequiredTypes = 1;
    types = {
      EOC: 0,
      Boolean: 1,
      Integer: 2,
      BitString: 3,
      OctetString: 4,
      Null: 5,
      OID: 6,
      ObjectDescriptor: 7,
      External: 8,
      Real: 9,
      // float
      Enumeration: 10,
      PDV: 11,
      Utf8String: 12,
      RelativeOID: 13,
      Sequence: 16,
      Set: 17,
      NumericString: 18,
      PrintableString: 19,
      T61String: 20,
      VideotexString: 21,
      IA5String: 22,
      UTCTime: 23,
      GeneralizedTime: 24,
      GraphicString: 25,
      VisibleString: 26,
      GeneralString: 28,
      UniversalString: 29,
      CharacterString: 30,
      BMPString: 31,
      Constructor: 32,
      Context: 128
    };
    return types;
  }
  var reader;
  var hasRequiredReader;
  function requireReader() {
    if (hasRequiredReader)
      return reader;
    hasRequiredReader = 1;
    var assert = require$$0$2;
    var Buffer2 = requireSafer().Buffer;
    var ASN1 = requireTypes();
    var errors2 = requireErrors();
    var newInvalidAsn1Error = errors2.newInvalidAsn1Error;
    function Reader(data2) {
      if (!data2 || !Buffer2.isBuffer(data2))
        throw new TypeError("data must be a node Buffer");
      this._buf = data2;
      this._size = data2.length;
      this._len = 0;
      this._offset = 0;
    }
    Object.defineProperty(Reader.prototype, "length", {
      enumerable: true,
      get: function() {
        return this._len;
      }
    });
    Object.defineProperty(Reader.prototype, "offset", {
      enumerable: true,
      get: function() {
        return this._offset;
      }
    });
    Object.defineProperty(Reader.prototype, "remain", {
      get: function() {
        return this._size - this._offset;
      }
    });
    Object.defineProperty(Reader.prototype, "buffer", {
      get: function() {
        return this._buf.slice(this._offset);
      }
    });
    Reader.prototype.readByte = function(peek) {
      if (this._size - this._offset < 1)
        return null;
      var b2 = this._buf[this._offset] & 255;
      if (!peek)
        this._offset += 1;
      return b2;
    };
    Reader.prototype.peek = function() {
      return this.readByte(true);
    };
    Reader.prototype.readLength = function(offset) {
      if (offset === void 0)
        offset = this._offset;
      if (offset >= this._size)
        return null;
      var lenB = this._buf[offset++] & 255;
      if (lenB === null)
        return null;
      if ((lenB & 128) === 128) {
        lenB &= 127;
        if (lenB === 0)
          throw newInvalidAsn1Error("Indefinite length not supported");
        if (lenB > 4)
          throw newInvalidAsn1Error("encoding too long");
        if (this._size - offset < lenB)
          return null;
        this._len = 0;
        for (var i2 = 0; i2 < lenB; i2++)
          this._len = (this._len << 8) + (this._buf[offset++] & 255);
      } else {
        this._len = lenB;
      }
      return offset;
    };
    Reader.prototype.readSequence = function(tag) {
      var seq = this.peek();
      if (seq === null)
        return null;
      if (tag !== void 0 && tag !== seq)
        throw newInvalidAsn1Error("Expected 0x" + tag.toString(16) + ": got 0x" + seq.toString(16));
      var o = this.readLength(this._offset + 1);
      if (o === null)
        return null;
      this._offset = o;
      return seq;
    };
    Reader.prototype.readInt = function() {
      return this._readTag(ASN1.Integer);
    };
    Reader.prototype.readBoolean = function() {
      return this._readTag(ASN1.Boolean) === 0 ? false : true;
    };
    Reader.prototype.readEnumeration = function() {
      return this._readTag(ASN1.Enumeration);
    };
    Reader.prototype.readString = function(tag, retbuf) {
      if (!tag)
        tag = ASN1.OctetString;
      var b2 = this.peek();
      if (b2 === null)
        return null;
      if (b2 !== tag)
        throw newInvalidAsn1Error("Expected 0x" + tag.toString(16) + ": got 0x" + b2.toString(16));
      var o = this.readLength(this._offset + 1);
      if (o === null)
        return null;
      if (this.length > this._size - o)
        return null;
      this._offset = o;
      if (this.length === 0)
        return retbuf ? Buffer2.alloc(0) : "";
      var str = this._buf.slice(this._offset, this._offset + this.length);
      this._offset += this.length;
      return retbuf ? str : str.toString("utf8");
    };
    Reader.prototype.readOID = function(tag) {
      if (!tag)
        tag = ASN1.OID;
      var b2 = this.readString(tag, true);
      if (b2 === null)
        return null;
      var values = [];
      var value = 0;
      for (var i2 = 0; i2 < b2.length; i2++) {
        var byte = b2[i2] & 255;
        value <<= 7;
        value += byte & 127;
        if ((byte & 128) === 0) {
          values.push(value);
          value = 0;
        }
      }
      value = values.shift();
      values.unshift(value % 40);
      values.unshift(value / 40 >> 0);
      return values.join(".");
    };
    Reader.prototype._readTag = function(tag) {
      assert.ok(tag !== void 0);
      var b2 = this.peek();
      if (b2 === null)
        return null;
      if (b2 !== tag)
        throw newInvalidAsn1Error("Expected 0x" + tag.toString(16) + ": got 0x" + b2.toString(16));
      var o = this.readLength(this._offset + 1);
      if (o === null)
        return null;
      if (this.length > 4)
        throw newInvalidAsn1Error("Integer too long: " + this.length);
      if (this.length > this._size - o)
        return null;
      this._offset = o;
      var fb = this._buf[this._offset];
      var value = 0;
      for (var i2 = 0; i2 < this.length; i2++) {
        value <<= 8;
        value |= this._buf[this._offset++] & 255;
      }
      if ((fb & 128) === 128 && i2 !== 4)
        value -= 1 << i2 * 8;
      return value >> 0;
    };
    reader = Reader;
    return reader;
  }
  var writer;
  var hasRequiredWriter;
  function requireWriter() {
    if (hasRequiredWriter)
      return writer;
    hasRequiredWriter = 1;
    var assert = require$$0$2;
    var Buffer2 = requireSafer().Buffer;
    var ASN1 = requireTypes();
    var errors2 = requireErrors();
    var newInvalidAsn1Error = errors2.newInvalidAsn1Error;
    var DEFAULT_OPTS = {
      size: 1024,
      growthFactor: 8
    };
    function merge(from, to) {
      assert.ok(from);
      assert.equal(typeof from, "object");
      assert.ok(to);
      assert.equal(typeof to, "object");
      var keys = Object.getOwnPropertyNames(from);
      keys.forEach(function(key2) {
        if (to[key2])
          return;
        var value = Object.getOwnPropertyDescriptor(from, key2);
        Object.defineProperty(to, key2, value);
      });
      return to;
    }
    function Writer(options) {
      options = merge(DEFAULT_OPTS, options || {});
      this._buf = Buffer2.alloc(options.size || 1024);
      this._size = this._buf.length;
      this._offset = 0;
      this._options = options;
      this._seq = [];
    }
    Object.defineProperty(Writer.prototype, "buffer", {
      get: function() {
        if (this._seq.length)
          throw newInvalidAsn1Error(this._seq.length + " unended sequence(s)");
        return this._buf.slice(0, this._offset);
      }
    });
    Writer.prototype.writeByte = function(b2) {
      if (typeof b2 !== "number")
        throw new TypeError("argument must be a Number");
      this._ensure(1);
      this._buf[this._offset++] = b2;
    };
    Writer.prototype.writeInt = function(i2, tag) {
      if (typeof i2 !== "number")
        throw new TypeError("argument must be a Number");
      if (typeof tag !== "number")
        tag = ASN1.Integer;
      var sz = 4;
      while (((i2 & 4286578688) === 0 || (i2 & 4286578688) === 4286578688 >> 0) && sz > 1) {
        sz--;
        i2 <<= 8;
      }
      if (sz > 4)
        throw newInvalidAsn1Error("BER ints cannot be > 0xffffffff");
      this._ensure(2 + sz);
      this._buf[this._offset++] = tag;
      this._buf[this._offset++] = sz;
      while (sz-- > 0) {
        this._buf[this._offset++] = (i2 & 4278190080) >>> 24;
        i2 <<= 8;
      }
    };
    Writer.prototype.writeNull = function() {
      this.writeByte(ASN1.Null);
      this.writeByte(0);
    };
    Writer.prototype.writeEnumeration = function(i2, tag) {
      if (typeof i2 !== "number")
        throw new TypeError("argument must be a Number");
      if (typeof tag !== "number")
        tag = ASN1.Enumeration;
      return this.writeInt(i2, tag);
    };
    Writer.prototype.writeBoolean = function(b2, tag) {
      if (typeof b2 !== "boolean")
        throw new TypeError("argument must be a Boolean");
      if (typeof tag !== "number")
        tag = ASN1.Boolean;
      this._ensure(3);
      this._buf[this._offset++] = tag;
      this._buf[this._offset++] = 1;
      this._buf[this._offset++] = b2 ? 255 : 0;
    };
    Writer.prototype.writeString = function(s, tag) {
      if (typeof s !== "string")
        throw new TypeError("argument must be a string (was: " + typeof s + ")");
      if (typeof tag !== "number")
        tag = ASN1.OctetString;
      var len = Buffer2.byteLength(s);
      this.writeByte(tag);
      this.writeLength(len);
      if (len) {
        this._ensure(len);
        this._buf.write(s, this._offset);
        this._offset += len;
      }
    };
    Writer.prototype.writeBuffer = function(buf, tag) {
      if (typeof tag !== "number")
        throw new TypeError("tag must be a number");
      if (!Buffer2.isBuffer(buf))
        throw new TypeError("argument must be a buffer");
      this.writeByte(tag);
      this.writeLength(buf.length);
      this._ensure(buf.length);
      buf.copy(this._buf, this._offset, 0, buf.length);
      this._offset += buf.length;
    };
    Writer.prototype.writeStringArray = function(strings) {
      if (!strings instanceof Array)
        throw new TypeError("argument must be an Array[String]");
      var self2 = this;
      strings.forEach(function(s) {
        self2.writeString(s);
      });
    };
    Writer.prototype.writeOID = function(s, tag) {
      if (typeof s !== "string")
        throw new TypeError("argument must be a string");
      if (typeof tag !== "number")
        tag = ASN1.OID;
      if (!/^([0-9]+\.){3,}[0-9]+$/.test(s))
        throw new Error("argument is not a valid OID string");
      function encodeOctet(bytes2, octet) {
        if (octet < 128) {
          bytes2.push(octet);
        } else if (octet < 16384) {
          bytes2.push(octet >>> 7 | 128);
          bytes2.push(octet & 127);
        } else if (octet < 2097152) {
          bytes2.push(octet >>> 14 | 128);
          bytes2.push((octet >>> 7 | 128) & 255);
          bytes2.push(octet & 127);
        } else if (octet < 268435456) {
          bytes2.push(octet >>> 21 | 128);
          bytes2.push((octet >>> 14 | 128) & 255);
          bytes2.push((octet >>> 7 | 128) & 255);
          bytes2.push(octet & 127);
        } else {
          bytes2.push((octet >>> 28 | 128) & 255);
          bytes2.push((octet >>> 21 | 128) & 255);
          bytes2.push((octet >>> 14 | 128) & 255);
          bytes2.push((octet >>> 7 | 128) & 255);
          bytes2.push(octet & 127);
        }
      }
      var tmp = s.split(".");
      var bytes = [];
      bytes.push(parseInt(tmp[0], 10) * 40 + parseInt(tmp[1], 10));
      tmp.slice(2).forEach(function(b2) {
        encodeOctet(bytes, parseInt(b2, 10));
      });
      var self2 = this;
      this._ensure(2 + bytes.length);
      this.writeByte(tag);
      this.writeLength(bytes.length);
      bytes.forEach(function(b2) {
        self2.writeByte(b2);
      });
    };
    Writer.prototype.writeLength = function(len) {
      if (typeof len !== "number")
        throw new TypeError("argument must be a Number");
      this._ensure(4);
      if (len <= 127) {
        this._buf[this._offset++] = len;
      } else if (len <= 255) {
        this._buf[this._offset++] = 129;
        this._buf[this._offset++] = len;
      } else if (len <= 65535) {
        this._buf[this._offset++] = 130;
        this._buf[this._offset++] = len >> 8;
        this._buf[this._offset++] = len;
      } else if (len <= 16777215) {
        this._buf[this._offset++] = 131;
        this._buf[this._offset++] = len >> 16;
        this._buf[this._offset++] = len >> 8;
        this._buf[this._offset++] = len;
      } else {
        throw newInvalidAsn1Error("Length too long (> 4 bytes)");
      }
    };
    Writer.prototype.startSequence = function(tag) {
      if (typeof tag !== "number")
        tag = ASN1.Sequence | ASN1.Constructor;
      this.writeByte(tag);
      this._seq.push(this._offset);
      this._ensure(3);
      this._offset += 3;
    };
    Writer.prototype.endSequence = function() {
      var seq = this._seq.pop();
      var start = seq + 3;
      var len = this._offset - start;
      if (len <= 127) {
        this._shift(start, len, -2);
        this._buf[seq] = len;
      } else if (len <= 255) {
        this._shift(start, len, -1);
        this._buf[seq] = 129;
        this._buf[seq + 1] = len;
      } else if (len <= 65535) {
        this._buf[seq] = 130;
        this._buf[seq + 1] = len >> 8;
        this._buf[seq + 2] = len;
      } else if (len <= 16777215) {
        this._shift(start, len, 1);
        this._buf[seq] = 131;
        this._buf[seq + 1] = len >> 16;
        this._buf[seq + 2] = len >> 8;
        this._buf[seq + 3] = len;
      } else {
        throw newInvalidAsn1Error("Sequence too long");
      }
    };
    Writer.prototype._shift = function(start, len, shift) {
      assert.ok(start !== void 0);
      assert.ok(len !== void 0);
      assert.ok(shift);
      this._buf.copy(this._buf, start + shift, start, start + len);
      this._offset += shift;
    };
    Writer.prototype._ensure = function(len) {
      assert.ok(len);
      if (this._size - this._offset < len) {
        var sz = this._size * this._options.growthFactor;
        if (sz - this._offset < len)
          sz += len;
        var buf = Buffer2.alloc(sz);
        this._buf.copy(buf, 0, 0, this._offset);
        this._buf = buf;
        this._size = sz;
      }
    };
    writer = Writer;
    return writer;
  }
  var hasRequiredBer;
  function requireBer() {
    if (hasRequiredBer)
      return ber.exports;
    hasRequiredBer = 1;
    (function(module) {
      var errors2 = requireErrors();
      var types2 = requireTypes();
      var Reader = requireReader();
      var Writer = requireWriter();
      module.exports = {
        Reader,
        Writer
      };
      for (var t in types2) {
        if (types2.hasOwnProperty(t))
          module.exports[t] = types2[t];
      }
      for (var e in errors2) {
        if (errors2.hasOwnProperty(e))
          module.exports[e] = errors2[e];
      }
    })(ber);
    return ber.exports;
  }
  var lib$4;
  var hasRequiredLib$4;
  function requireLib$4() {
    if (hasRequiredLib$4)
      return lib$4;
    hasRequiredLib$4 = 1;
    var Ber = requireBer();
    lib$4 = {
      Ber,
      BerReader: Ber.Reader,
      BerWriter: Ber.Writer
    };
    return lib$4;
  }
  var jsbn = { exports: {} };
  var hasRequiredJsbn;
  function requireJsbn() {
    if (hasRequiredJsbn)
      return jsbn.exports;
    hasRequiredJsbn = 1;
    (function(module, exports) {
      (function() {
        var dbits;
        var canary = 244837814094590;
        var j_lm = (canary & 16777215) == 15715070;
        function BigInteger(a2, b2, c2) {
          if (a2 != null)
            if ("number" == typeof a2)
              this.fromNumber(a2, b2, c2);
            else if (b2 == null && "string" != typeof a2)
              this.fromString(a2, 256);
            else
              this.fromString(a2, b2);
        }
        function nbi() {
          return new BigInteger(null);
        }
        function am1(i2, x, w, j2, c2, n) {
          while (--n >= 0) {
            var v = x * this[i2++] + w[j2] + c2;
            c2 = Math.floor(v / 67108864);
            w[j2++] = v & 67108863;
          }
          return c2;
        }
        function am2(i2, x, w, j2, c2, n) {
          var xl = x & 32767, xh = x >> 15;
          while (--n >= 0) {
            var l = this[i2] & 32767;
            var h = this[i2++] >> 15;
            var m = xh * l + h * xl;
            l = xl * l + ((m & 32767) << 15) + w[j2] + (c2 & 1073741823);
            c2 = (l >>> 30) + (m >>> 15) + xh * h + (c2 >>> 30);
            w[j2++] = l & 1073741823;
          }
          return c2;
        }
        function am3(i2, x, w, j2, c2, n) {
          var xl = x & 16383, xh = x >> 14;
          while (--n >= 0) {
            var l = this[i2] & 16383;
            var h = this[i2++] >> 14;
            var m = xh * l + h * xl;
            l = xl * l + ((m & 16383) << 14) + w[j2] + c2;
            c2 = (l >> 28) + (m >> 14) + xh * h;
            w[j2++] = l & 268435455;
          }
          return c2;
        }
        var inBrowser = typeof navigator !== "undefined";
        if (inBrowser && j_lm && navigator.appName == "Microsoft Internet Explorer") {
          BigInteger.prototype.am = am2;
          dbits = 30;
        } else if (inBrowser && j_lm && navigator.appName != "Netscape") {
          BigInteger.prototype.am = am1;
          dbits = 26;
        } else {
          BigInteger.prototype.am = am3;
          dbits = 28;
        }
        BigInteger.prototype.DB = dbits;
        BigInteger.prototype.DM = (1 << dbits) - 1;
        BigInteger.prototype.DV = 1 << dbits;
        var BI_FP = 52;
        BigInteger.prototype.FV = Math.pow(2, BI_FP);
        BigInteger.prototype.F1 = BI_FP - dbits;
        BigInteger.prototype.F2 = 2 * dbits - BI_FP;
        var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";
        var BI_RC = new Array();
        var rr, vv;
        rr = "0".charCodeAt(0);
        for (vv = 0; vv <= 9; ++vv)
          BI_RC[rr++] = vv;
        rr = "a".charCodeAt(0);
        for (vv = 10; vv < 36; ++vv)
          BI_RC[rr++] = vv;
        rr = "A".charCodeAt(0);
        for (vv = 10; vv < 36; ++vv)
          BI_RC[rr++] = vv;
        function int2char(n) {
          return BI_RM.charAt(n);
        }
        function intAt(s, i2) {
          var c2 = BI_RC[s.charCodeAt(i2)];
          return c2 == null ? -1 : c2;
        }
        function bnpCopyTo(r) {
          for (var i2 = this.t - 1; i2 >= 0; --i2)
            r[i2] = this[i2];
          r.t = this.t;
          r.s = this.s;
        }
        function bnpFromInt(x) {
          this.t = 1;
          this.s = x < 0 ? -1 : 0;
          if (x > 0)
            this[0] = x;
          else if (x < -1)
            this[0] = x + this.DV;
          else
            this.t = 0;
        }
        function nbv(i2) {
          var r = nbi();
          r.fromInt(i2);
          return r;
        }
        function bnpFromString(s, b2) {
          var k;
          if (b2 == 16)
            k = 4;
          else if (b2 == 8)
            k = 3;
          else if (b2 == 256)
            k = 8;
          else if (b2 == 2)
            k = 1;
          else if (b2 == 32)
            k = 5;
          else if (b2 == 4)
            k = 2;
          else {
            this.fromRadix(s, b2);
            return;
          }
          this.t = 0;
          this.s = 0;
          var i2 = s.length, mi = false, sh = 0;
          while (--i2 >= 0) {
            var x = k == 8 ? s[i2] & 255 : intAt(s, i2);
            if (x < 0) {
              if (s.charAt(i2) == "-")
                mi = true;
              continue;
            }
            mi = false;
            if (sh == 0)
              this[this.t++] = x;
            else if (sh + k > this.DB) {
              this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;
              this[this.t++] = x >> this.DB - sh;
            } else
              this[this.t - 1] |= x << sh;
            sh += k;
            if (sh >= this.DB)
              sh -= this.DB;
          }
          if (k == 8 && (s[0] & 128) != 0) {
            this.s = -1;
            if (sh > 0)
              this[this.t - 1] |= (1 << this.DB - sh) - 1 << sh;
          }
          this.clamp();
          if (mi)
            BigInteger.ZERO.subTo(this, this);
        }
        function bnpClamp() {
          var c2 = this.s & this.DM;
          while (this.t > 0 && this[this.t - 1] == c2)
            --this.t;
        }
        function bnToString(b2) {
          if (this.s < 0)
            return "-" + this.negate().toString(b2);
          var k;
          if (b2 == 16)
            k = 4;
          else if (b2 == 8)
            k = 3;
          else if (b2 == 2)
            k = 1;
          else if (b2 == 32)
            k = 5;
          else if (b2 == 4)
            k = 2;
          else
            return this.toRadix(b2);
          var km = (1 << k) - 1, d2, m = false, r = "", i2 = this.t;
          var p = this.DB - i2 * this.DB % k;
          if (i2-- > 0) {
            if (p < this.DB && (d2 = this[i2] >> p) > 0) {
              m = true;
              r = int2char(d2);
            }
            while (i2 >= 0) {
              if (p < k) {
                d2 = (this[i2] & (1 << p) - 1) << k - p;
                d2 |= this[--i2] >> (p += this.DB - k);
              } else {
                d2 = this[i2] >> (p -= k) & km;
                if (p <= 0) {
                  p += this.DB;
                  --i2;
                }
              }
              if (d2 > 0)
                m = true;
              if (m)
                r += int2char(d2);
            }
          }
          return m ? r : "0";
        }
        function bnNegate() {
          var r = nbi();
          BigInteger.ZERO.subTo(this, r);
          return r;
        }
        function bnAbs() {
          return this.s < 0 ? this.negate() : this;
        }
        function bnCompareTo(a2) {
          var r = this.s - a2.s;
          if (r != 0)
            return r;
          var i2 = this.t;
          r = i2 - a2.t;
          if (r != 0)
            return this.s < 0 ? -r : r;
          while (--i2 >= 0)
            if ((r = this[i2] - a2[i2]) != 0)
              return r;
          return 0;
        }
        function nbits(x) {
          var r = 1, t2;
          if ((t2 = x >>> 16) != 0) {
            x = t2;
            r += 16;
          }
          if ((t2 = x >> 8) != 0) {
            x = t2;
            r += 8;
          }
          if ((t2 = x >> 4) != 0) {
            x = t2;
            r += 4;
          }
          if ((t2 = x >> 2) != 0) {
            x = t2;
            r += 2;
          }
          if ((t2 = x >> 1) != 0) {
            x = t2;
            r += 1;
          }
          return r;
        }
        function bnBitLength() {
          if (this.t <= 0)
            return 0;
          return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
        }
        function bnpDLShiftTo(n, r) {
          var i2;
          for (i2 = this.t - 1; i2 >= 0; --i2)
            r[i2 + n] = this[i2];
          for (i2 = n - 1; i2 >= 0; --i2)
            r[i2] = 0;
          r.t = this.t + n;
          r.s = this.s;
        }
        function bnpDRShiftTo(n, r) {
          for (var i2 = n; i2 < this.t; ++i2)
            r[i2 - n] = this[i2];
          r.t = Math.max(this.t - n, 0);
          r.s = this.s;
        }
        function bnpLShiftTo(n, r) {
          var bs = n % this.DB;
          var cbs = this.DB - bs;
          var bm = (1 << cbs) - 1;
          var ds = Math.floor(n / this.DB), c2 = this.s << bs & this.DM, i2;
          for (i2 = this.t - 1; i2 >= 0; --i2) {
            r[i2 + ds + 1] = this[i2] >> cbs | c2;
            c2 = (this[i2] & bm) << bs;
          }
          for (i2 = ds - 1; i2 >= 0; --i2)
            r[i2] = 0;
          r[ds] = c2;
          r.t = this.t + ds + 1;
          r.s = this.s;
          r.clamp();
        }
        function bnpRShiftTo(n, r) {
          r.s = this.s;
          var ds = Math.floor(n / this.DB);
          if (ds >= this.t) {
            r.t = 0;
            return;
          }
          var bs = n % this.DB;
          var cbs = this.DB - bs;
          var bm = (1 << bs) - 1;
          r[0] = this[ds] >> bs;
          for (var i2 = ds + 1; i2 < this.t; ++i2) {
            r[i2 - ds - 1] |= (this[i2] & bm) << cbs;
            r[i2 - ds] = this[i2] >> bs;
          }
          if (bs > 0)
            r[this.t - ds - 1] |= (this.s & bm) << cbs;
          r.t = this.t - ds;
          r.clamp();
        }
        function bnpSubTo(a2, r) {
          var i2 = 0, c2 = 0, m = Math.min(a2.t, this.t);
          while (i2 < m) {
            c2 += this[i2] - a2[i2];
            r[i2++] = c2 & this.DM;
            c2 >>= this.DB;
          }
          if (a2.t < this.t) {
            c2 -= a2.s;
            while (i2 < this.t) {
              c2 += this[i2];
              r[i2++] = c2 & this.DM;
              c2 >>= this.DB;
            }
            c2 += this.s;
          } else {
            c2 += this.s;
            while (i2 < a2.t) {
              c2 -= a2[i2];
              r[i2++] = c2 & this.DM;
              c2 >>= this.DB;
            }
            c2 -= a2.s;
          }
          r.s = c2 < 0 ? -1 : 0;
          if (c2 < -1)
            r[i2++] = this.DV + c2;
          else if (c2 > 0)
            r[i2++] = c2;
          r.t = i2;
          r.clamp();
        }
        function bnpMultiplyTo(a2, r) {
          var x = this.abs(), y = a2.abs();
          var i2 = x.t;
          r.t = i2 + y.t;
          while (--i2 >= 0)
            r[i2] = 0;
          for (i2 = 0; i2 < y.t; ++i2)
            r[i2 + x.t] = x.am(0, y[i2], r, i2, 0, x.t);
          r.s = 0;
          r.clamp();
          if (this.s != a2.s)
            BigInteger.ZERO.subTo(r, r);
        }
        function bnpSquareTo(r) {
          var x = this.abs();
          var i2 = r.t = 2 * x.t;
          while (--i2 >= 0)
            r[i2] = 0;
          for (i2 = 0; i2 < x.t - 1; ++i2) {
            var c2 = x.am(i2, x[i2], r, 2 * i2, 0, 1);
            if ((r[i2 + x.t] += x.am(i2 + 1, 2 * x[i2], r, 2 * i2 + 1, c2, x.t - i2 - 1)) >= x.DV) {
              r[i2 + x.t] -= x.DV;
              r[i2 + x.t + 1] = 1;
            }
          }
          if (r.t > 0)
            r[r.t - 1] += x.am(i2, x[i2], r, 2 * i2, 0, 1);
          r.s = 0;
          r.clamp();
        }
        function bnpDivRemTo(m, q2, r) {
          var pm = m.abs();
          if (pm.t <= 0)
            return;
          var pt = this.abs();
          if (pt.t < pm.t) {
            if (q2 != null)
              q2.fromInt(0);
            if (r != null)
              this.copyTo(r);
            return;
          }
          if (r == null)
            r = nbi();
          var y = nbi(), ts = this.s, ms = m.s;
          var nsh = this.DB - nbits(pm[pm.t - 1]);
          if (nsh > 0) {
            pm.lShiftTo(nsh, y);
            pt.lShiftTo(nsh, r);
          } else {
            pm.copyTo(y);
            pt.copyTo(r);
          }
          var ys = y.t;
          var y0 = y[ys - 1];
          if (y0 == 0)
            return;
          var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);
          var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;
          var i2 = r.t, j2 = i2 - ys, t2 = q2 == null ? nbi() : q2;
          y.dlShiftTo(j2, t2);
          if (r.compareTo(t2) >= 0) {
            r[r.t++] = 1;
            r.subTo(t2, r);
          }
          BigInteger.ONE.dlShiftTo(ys, t2);
          t2.subTo(y, y);
          while (y.t < ys)
            y[y.t++] = 0;
          while (--j2 >= 0) {
            var qd = r[--i2] == y0 ? this.DM : Math.floor(r[i2] * d1 + (r[i2 - 1] + e) * d2);
            if ((r[i2] += y.am(0, qd, r, j2, 0, ys)) < qd) {
              y.dlShiftTo(j2, t2);
              r.subTo(t2, r);
              while (r[i2] < --qd)
                r.subTo(t2, r);
            }
          }
          if (q2 != null) {
            r.drShiftTo(ys, q2);
            if (ts != ms)
              BigInteger.ZERO.subTo(q2, q2);
          }
          r.t = ys;
          r.clamp();
          if (nsh > 0)
            r.rShiftTo(nsh, r);
          if (ts < 0)
            BigInteger.ZERO.subTo(r, r);
        }
        function bnMod(a2) {
          var r = nbi();
          this.abs().divRemTo(a2, null, r);
          if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
            a2.subTo(r, r);
          return r;
        }
        function Classic(m) {
          this.m = m;
        }
        function cConvert(x) {
          if (x.s < 0 || x.compareTo(this.m) >= 0)
            return x.mod(this.m);
          else
            return x;
        }
        function cRevert(x) {
          return x;
        }
        function cReduce(x) {
          x.divRemTo(this.m, null, x);
        }
        function cMulTo(x, y, r) {
          x.multiplyTo(y, r);
          this.reduce(r);
        }
        function cSqrTo(x, r) {
          x.squareTo(r);
          this.reduce(r);
        }
        Classic.prototype.convert = cConvert;
        Classic.prototype.revert = cRevert;
        Classic.prototype.reduce = cReduce;
        Classic.prototype.mulTo = cMulTo;
        Classic.prototype.sqrTo = cSqrTo;
        function bnpInvDigit() {
          if (this.t < 1)
            return 0;
          var x = this[0];
          if ((x & 1) == 0)
            return 0;
          var y = x & 3;
          y = y * (2 - (x & 15) * y) & 15;
          y = y * (2 - (x & 255) * y) & 255;
          y = y * (2 - ((x & 65535) * y & 65535)) & 65535;
          y = y * (2 - x * y % this.DV) % this.DV;
          return y > 0 ? this.DV - y : -y;
        }
        function Montgomery(m) {
          this.m = m;
          this.mp = m.invDigit();
          this.mpl = this.mp & 32767;
          this.mph = this.mp >> 15;
          this.um = (1 << m.DB - 15) - 1;
          this.mt2 = 2 * m.t;
        }
        function montConvert(x) {
          var r = nbi();
          x.abs().dlShiftTo(this.m.t, r);
          r.divRemTo(this.m, null, r);
          if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0)
            this.m.subTo(r, r);
          return r;
        }
        function montRevert(x) {
          var r = nbi();
          x.copyTo(r);
          this.reduce(r);
          return r;
        }
        function montReduce(x) {
          while (x.t <= this.mt2)
            x[x.t++] = 0;
          for (var i2 = 0; i2 < this.m.t; ++i2) {
            var j2 = x[i2] & 32767;
            var u0 = j2 * this.mpl + ((j2 * this.mph + (x[i2] >> 15) * this.mpl & this.um) << 15) & x.DM;
            j2 = i2 + this.m.t;
            x[j2] += this.m.am(0, u0, x, i2, 0, this.m.t);
            while (x[j2] >= x.DV) {
              x[j2] -= x.DV;
              x[++j2]++;
            }
          }
          x.clamp();
          x.drShiftTo(this.m.t, x);
          if (x.compareTo(this.m) >= 0)
            x.subTo(this.m, x);
        }
        function montSqrTo(x, r) {
          x.squareTo(r);
          this.reduce(r);
        }
        function montMulTo(x, y, r) {
          x.multiplyTo(y, r);
          this.reduce(r);
        }
        Montgomery.prototype.convert = montConvert;
        Montgomery.prototype.revert = montRevert;
        Montgomery.prototype.reduce = montReduce;
        Montgomery.prototype.mulTo = montMulTo;
        Montgomery.prototype.sqrTo = montSqrTo;
        function bnpIsEven() {
          return (this.t > 0 ? this[0] & 1 : this.s) == 0;
        }
        function bnpExp(e, z2) {
          if (e > 4294967295 || e < 1)
            return BigInteger.ONE;
          var r = nbi(), r2 = nbi(), g = z2.convert(this), i2 = nbits(e) - 1;
          g.copyTo(r);
          while (--i2 >= 0) {
            z2.sqrTo(r, r2);
            if ((e & 1 << i2) > 0)
              z2.mulTo(r2, g, r);
            else {
              var t2 = r;
              r = r2;
              r2 = t2;
            }
          }
          return z2.revert(r);
        }
        function bnModPowInt(e, m) {
          var z2;
          if (e < 256 || m.isEven())
            z2 = new Classic(m);
          else
            z2 = new Montgomery(m);
          return this.exp(e, z2);
        }
        BigInteger.prototype.copyTo = bnpCopyTo;
        BigInteger.prototype.fromInt = bnpFromInt;
        BigInteger.prototype.fromString = bnpFromString;
        BigInteger.prototype.clamp = bnpClamp;
        BigInteger.prototype.dlShiftTo = bnpDLShiftTo;
        BigInteger.prototype.drShiftTo = bnpDRShiftTo;
        BigInteger.prototype.lShiftTo = bnpLShiftTo;
        BigInteger.prototype.rShiftTo = bnpRShiftTo;
        BigInteger.prototype.subTo = bnpSubTo;
        BigInteger.prototype.multiplyTo = bnpMultiplyTo;
        BigInteger.prototype.squareTo = bnpSquareTo;
        BigInteger.prototype.divRemTo = bnpDivRemTo;
        BigInteger.prototype.invDigit = bnpInvDigit;
        BigInteger.prototype.isEven = bnpIsEven;
        BigInteger.prototype.exp = bnpExp;
        BigInteger.prototype.toString = bnToString;
        BigInteger.prototype.negate = bnNegate;
        BigInteger.prototype.abs = bnAbs;
        BigInteger.prototype.compareTo = bnCompareTo;
        BigInteger.prototype.bitLength = bnBitLength;
        BigInteger.prototype.mod = bnMod;
        BigInteger.prototype.modPowInt = bnModPowInt;
        BigInteger.ZERO = nbv(0);
        BigInteger.ONE = nbv(1);
        function bnClone() {
          var r = nbi();
          this.copyTo(r);
          return r;
        }
        function bnIntValue() {
          if (this.s < 0) {
            if (this.t == 1)
              return this[0] - this.DV;
            else if (this.t == 0)
              return -1;
          } else if (this.t == 1)
            return this[0];
          else if (this.t == 0)
            return 0;
          return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
        }
        function bnByteValue() {
          return this.t == 0 ? this.s : this[0] << 24 >> 24;
        }
        function bnShortValue() {
          return this.t == 0 ? this.s : this[0] << 16 >> 16;
        }
        function bnpChunkSize(r) {
          return Math.floor(Math.LN2 * this.DB / Math.log(r));
        }
        function bnSigNum() {
          if (this.s < 0)
            return -1;
          else if (this.t <= 0 || this.t == 1 && this[0] <= 0)
            return 0;
          else
            return 1;
        }
        function bnpToRadix(b2) {
          if (b2 == null)
            b2 = 10;
          if (this.signum() == 0 || b2 < 2 || b2 > 36)
            return "0";
          var cs = this.chunkSize(b2);
          var a2 = Math.pow(b2, cs);
          var d2 = nbv(a2), y = nbi(), z2 = nbi(), r = "";
          this.divRemTo(d2, y, z2);
          while (y.signum() > 0) {
            r = (a2 + z2.intValue()).toString(b2).substr(1) + r;
            y.divRemTo(d2, y, z2);
          }
          return z2.intValue().toString(b2) + r;
        }
        function bnpFromRadix(s, b2) {
          this.fromInt(0);
          if (b2 == null)
            b2 = 10;
          var cs = this.chunkSize(b2);
          var d2 = Math.pow(b2, cs), mi = false, j2 = 0, w = 0;
          for (var i2 = 0; i2 < s.length; ++i2) {
            var x = intAt(s, i2);
            if (x < 0) {
              if (s.charAt(i2) == "-" && this.signum() == 0)
                mi = true;
              continue;
            }
            w = b2 * w + x;
            if (++j2 >= cs) {
              this.dMultiply(d2);
              this.dAddOffset(w, 0);
              j2 = 0;
              w = 0;
            }
          }
          if (j2 > 0) {
            this.dMultiply(Math.pow(b2, j2));
            this.dAddOffset(w, 0);
          }
          if (mi)
            BigInteger.ZERO.subTo(this, this);
        }
        function bnpFromNumber(a2, b2, c2) {
          if ("number" == typeof b2) {
            if (a2 < 2)
              this.fromInt(1);
            else {
              this.fromNumber(a2, c2);
              if (!this.testBit(a2 - 1))
                this.bitwiseTo(BigInteger.ONE.shiftLeft(a2 - 1), op_or, this);
              if (this.isEven())
                this.dAddOffset(1, 0);
              while (!this.isProbablePrime(b2)) {
                this.dAddOffset(2, 0);
                if (this.bitLength() > a2)
                  this.subTo(BigInteger.ONE.shiftLeft(a2 - 1), this);
              }
            }
          } else {
            var x = new Array(), t2 = a2 & 7;
            x.length = (a2 >> 3) + 1;
            b2.nextBytes(x);
            if (t2 > 0)
              x[0] &= (1 << t2) - 1;
            else
              x[0] = 0;
            this.fromString(x, 256);
          }
        }
        function bnToByteArray() {
          var i2 = this.t, r = new Array();
          r[0] = this.s;
          var p = this.DB - i2 * this.DB % 8, d2, k = 0;
          if (i2-- > 0) {
            if (p < this.DB && (d2 = this[i2] >> p) != (this.s & this.DM) >> p)
              r[k++] = d2 | this.s << this.DB - p;
            while (i2 >= 0) {
              if (p < 8) {
                d2 = (this[i2] & (1 << p) - 1) << 8 - p;
                d2 |= this[--i2] >> (p += this.DB - 8);
              } else {
                d2 = this[i2] >> (p -= 8) & 255;
                if (p <= 0) {
                  p += this.DB;
                  --i2;
                }
              }
              if ((d2 & 128) != 0)
                d2 |= -256;
              if (k == 0 && (this.s & 128) != (d2 & 128))
                ++k;
              if (k > 0 || d2 != this.s)
                r[k++] = d2;
            }
          }
          return r;
        }
        function bnEquals(a2) {
          return this.compareTo(a2) == 0;
        }
        function bnMin(a2) {
          return this.compareTo(a2) < 0 ? this : a2;
        }
        function bnMax(a2) {
          return this.compareTo(a2) > 0 ? this : a2;
        }
        function bnpBitwiseTo(a2, op, r) {
          var i2, f, m = Math.min(a2.t, this.t);
          for (i2 = 0; i2 < m; ++i2)
            r[i2] = op(this[i2], a2[i2]);
          if (a2.t < this.t) {
            f = a2.s & this.DM;
            for (i2 = m; i2 < this.t; ++i2)
              r[i2] = op(this[i2], f);
            r.t = this.t;
          } else {
            f = this.s & this.DM;
            for (i2 = m; i2 < a2.t; ++i2)
              r[i2] = op(f, a2[i2]);
            r.t = a2.t;
          }
          r.s = op(this.s, a2.s);
          r.clamp();
        }
        function op_and(x, y) {
          return x & y;
        }
        function bnAnd(a2) {
          var r = nbi();
          this.bitwiseTo(a2, op_and, r);
          return r;
        }
        function op_or(x, y) {
          return x | y;
        }
        function bnOr(a2) {
          var r = nbi();
          this.bitwiseTo(a2, op_or, r);
          return r;
        }
        function op_xor(x, y) {
          return x ^ y;
        }
        function bnXor(a2) {
          var r = nbi();
          this.bitwiseTo(a2, op_xor, r);
          return r;
        }
        function op_andnot(x, y) {
          return x & ~y;
        }
        function bnAndNot(a2) {
          var r = nbi();
          this.bitwiseTo(a2, op_andnot, r);
          return r;
        }
        function bnNot() {
          var r = nbi();
          for (var i2 = 0; i2 < this.t; ++i2)
            r[i2] = this.DM & ~this[i2];
          r.t = this.t;
          r.s = ~this.s;
          return r;
        }
        function bnShiftLeft(n) {
          var r = nbi();
          if (n < 0)
            this.rShiftTo(-n, r);
          else
            this.lShiftTo(n, r);
          return r;
        }
        function bnShiftRight(n) {
          var r = nbi();
          if (n < 0)
            this.lShiftTo(-n, r);
          else
            this.rShiftTo(n, r);
          return r;
        }
        function lbit(x) {
          if (x == 0)
            return -1;
          var r = 0;
          if ((x & 65535) == 0) {
            x >>= 16;
            r += 16;
          }
          if ((x & 255) == 0) {
            x >>= 8;
            r += 8;
          }
          if ((x & 15) == 0) {
            x >>= 4;
            r += 4;
          }
          if ((x & 3) == 0) {
            x >>= 2;
            r += 2;
          }
          if ((x & 1) == 0)
            ++r;
          return r;
        }
        function bnGetLowestSetBit() {
          for (var i2 = 0; i2 < this.t; ++i2)
            if (this[i2] != 0)
              return i2 * this.DB + lbit(this[i2]);
          if (this.s < 0)
            return this.t * this.DB;
          return -1;
        }
        function cbit(x) {
          var r = 0;
          while (x != 0) {
            x &= x - 1;
            ++r;
          }
          return r;
        }
        function bnBitCount() {
          var r = 0, x = this.s & this.DM;
          for (var i2 = 0; i2 < this.t; ++i2)
            r += cbit(this[i2] ^ x);
          return r;
        }
        function bnTestBit(n) {
          var j2 = Math.floor(n / this.DB);
          if (j2 >= this.t)
            return this.s != 0;
          return (this[j2] & 1 << n % this.DB) != 0;
        }
        function bnpChangeBit(n, op) {
          var r = BigInteger.ONE.shiftLeft(n);
          this.bitwiseTo(r, op, r);
          return r;
        }
        function bnSetBit(n) {
          return this.changeBit(n, op_or);
        }
        function bnClearBit(n) {
          return this.changeBit(n, op_andnot);
        }
        function bnFlipBit(n) {
          return this.changeBit(n, op_xor);
        }
        function bnpAddTo(a2, r) {
          var i2 = 0, c2 = 0, m = Math.min(a2.t, this.t);
          while (i2 < m) {
            c2 += this[i2] + a2[i2];
            r[i2++] = c2 & this.DM;
            c2 >>= this.DB;
          }
          if (a2.t < this.t) {
            c2 += a2.s;
            while (i2 < this.t) {
              c2 += this[i2];
              r[i2++] = c2 & this.DM;
              c2 >>= this.DB;
            }
            c2 += this.s;
          } else {
            c2 += this.s;
            while (i2 < a2.t) {
              c2 += a2[i2];
              r[i2++] = c2 & this.DM;
              c2 >>= this.DB;
            }
            c2 += a2.s;
          }
          r.s = c2 < 0 ? -1 : 0;
          if (c2 > 0)
            r[i2++] = c2;
          else if (c2 < -1)
            r[i2++] = this.DV + c2;
          r.t = i2;
          r.clamp();
        }
        function bnAdd(a2) {
          var r = nbi();
          this.addTo(a2, r);
          return r;
        }
        function bnSubtract(a2) {
          var r = nbi();
          this.subTo(a2, r);
          return r;
        }
        function bnMultiply(a2) {
          var r = nbi();
          this.multiplyTo(a2, r);
          return r;
        }
        function bnSquare() {
          var r = nbi();
          this.squareTo(r);
          return r;
        }
        function bnDivide(a2) {
          var r = nbi();
          this.divRemTo(a2, r, null);
          return r;
        }
        function bnRemainder(a2) {
          var r = nbi();
          this.divRemTo(a2, null, r);
          return r;
        }
        function bnDivideAndRemainder(a2) {
          var q2 = nbi(), r = nbi();
          this.divRemTo(a2, q2, r);
          return new Array(q2, r);
        }
        function bnpDMultiply(n) {
          this[this.t] = this.am(0, n - 1, this, 0, 0, this.t);
          ++this.t;
          this.clamp();
        }
        function bnpDAddOffset(n, w) {
          if (n == 0)
            return;
          while (this.t <= w)
            this[this.t++] = 0;
          this[w] += n;
          while (this[w] >= this.DV) {
            this[w] -= this.DV;
            if (++w >= this.t)
              this[this.t++] = 0;
            ++this[w];
          }
        }
        function NullExp() {
        }
        function nNop(x) {
          return x;
        }
        function nMulTo(x, y, r) {
          x.multiplyTo(y, r);
        }
        function nSqrTo(x, r) {
          x.squareTo(r);
        }
        NullExp.prototype.convert = nNop;
        NullExp.prototype.revert = nNop;
        NullExp.prototype.mulTo = nMulTo;
        NullExp.prototype.sqrTo = nSqrTo;
        function bnPow(e) {
          return this.exp(e, new NullExp());
        }
        function bnpMultiplyLowerTo(a2, n, r) {
          var i2 = Math.min(this.t + a2.t, n);
          r.s = 0;
          r.t = i2;
          while (i2 > 0)
            r[--i2] = 0;
          var j2;
          for (j2 = r.t - this.t; i2 < j2; ++i2)
            r[i2 + this.t] = this.am(0, a2[i2], r, i2, 0, this.t);
          for (j2 = Math.min(a2.t, n); i2 < j2; ++i2)
            this.am(0, a2[i2], r, i2, 0, n - i2);
          r.clamp();
        }
        function bnpMultiplyUpperTo(a2, n, r) {
          --n;
          var i2 = r.t = this.t + a2.t - n;
          r.s = 0;
          while (--i2 >= 0)
            r[i2] = 0;
          for (i2 = Math.max(n - this.t, 0); i2 < a2.t; ++i2)
            r[this.t + i2 - n] = this.am(n - i2, a2[i2], r, 0, 0, this.t + i2 - n);
          r.clamp();
          r.drShiftTo(1, r);
        }
        function Barrett(m) {
          this.r2 = nbi();
          this.q3 = nbi();
          BigInteger.ONE.dlShiftTo(2 * m.t, this.r2);
          this.mu = this.r2.divide(m);
          this.m = m;
        }
        function barrettConvert(x) {
          if (x.s < 0 || x.t > 2 * this.m.t)
            return x.mod(this.m);
          else if (x.compareTo(this.m) < 0)
            return x;
          else {
            var r = nbi();
            x.copyTo(r);
            this.reduce(r);
            return r;
          }
        }
        function barrettRevert(x) {
          return x;
        }
        function barrettReduce(x) {
          x.drShiftTo(this.m.t - 1, this.r2);
          if (x.t > this.m.t + 1) {
            x.t = this.m.t + 1;
            x.clamp();
          }
          this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);
          this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);
          while (x.compareTo(this.r2) < 0)
            x.dAddOffset(1, this.m.t + 1);
          x.subTo(this.r2, x);
          while (x.compareTo(this.m) >= 0)
            x.subTo(this.m, x);
        }
        function barrettSqrTo(x, r) {
          x.squareTo(r);
          this.reduce(r);
        }
        function barrettMulTo(x, y, r) {
          x.multiplyTo(y, r);
          this.reduce(r);
        }
        Barrett.prototype.convert = barrettConvert;
        Barrett.prototype.revert = barrettRevert;
        Barrett.prototype.reduce = barrettReduce;
        Barrett.prototype.mulTo = barrettMulTo;
        Barrett.prototype.sqrTo = barrettSqrTo;
        function bnModPow(e, m) {
          var i2 = e.bitLength(), k, r = nbv(1), z2;
          if (i2 <= 0)
            return r;
          else if (i2 < 18)
            k = 1;
          else if (i2 < 48)
            k = 3;
          else if (i2 < 144)
            k = 4;
          else if (i2 < 768)
            k = 5;
          else
            k = 6;
          if (i2 < 8)
            z2 = new Classic(m);
          else if (m.isEven())
            z2 = new Barrett(m);
          else
            z2 = new Montgomery(m);
          var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1;
          g[1] = z2.convert(this);
          if (k > 1) {
            var g2 = nbi();
            z2.sqrTo(g[1], g2);
            while (n <= km) {
              g[n] = nbi();
              z2.mulTo(g2, g[n - 2], g[n]);
              n += 2;
            }
          }
          var j2 = e.t - 1, w, is1 = true, r2 = nbi(), t2;
          i2 = nbits(e[j2]) - 1;
          while (j2 >= 0) {
            if (i2 >= k1)
              w = e[j2] >> i2 - k1 & km;
            else {
              w = (e[j2] & (1 << i2 + 1) - 1) << k1 - i2;
              if (j2 > 0)
                w |= e[j2 - 1] >> this.DB + i2 - k1;
            }
            n = k;
            while ((w & 1) == 0) {
              w >>= 1;
              --n;
            }
            if ((i2 -= n) < 0) {
              i2 += this.DB;
              --j2;
            }
            if (is1) {
              g[w].copyTo(r);
              is1 = false;
            } else {
              while (n > 1) {
                z2.sqrTo(r, r2);
                z2.sqrTo(r2, r);
                n -= 2;
              }
              if (n > 0)
                z2.sqrTo(r, r2);
              else {
                t2 = r;
                r = r2;
                r2 = t2;
              }
              z2.mulTo(r2, g[w], r);
            }
            while (j2 >= 0 && (e[j2] & 1 << i2) == 0) {
              z2.sqrTo(r, r2);
              t2 = r;
              r = r2;
              r2 = t2;
              if (--i2 < 0) {
                i2 = this.DB - 1;
                --j2;
              }
            }
          }
          return z2.revert(r);
        }
        function bnGCD(a2) {
          var x = this.s < 0 ? this.negate() : this.clone();
          var y = a2.s < 0 ? a2.negate() : a2.clone();
          if (x.compareTo(y) < 0) {
            var t2 = x;
            x = y;
            y = t2;
          }
          var i2 = x.getLowestSetBit(), g = y.getLowestSetBit();
          if (g < 0)
            return x;
          if (i2 < g)
            g = i2;
          if (g > 0) {
            x.rShiftTo(g, x);
            y.rShiftTo(g, y);
          }
          while (x.signum() > 0) {
            if ((i2 = x.getLowestSetBit()) > 0)
              x.rShiftTo(i2, x);
            if ((i2 = y.getLowestSetBit()) > 0)
              y.rShiftTo(i2, y);
            if (x.compareTo(y) >= 0) {
              x.subTo(y, x);
              x.rShiftTo(1, x);
            } else {
              y.subTo(x, y);
              y.rShiftTo(1, y);
            }
          }
          if (g > 0)
            y.lShiftTo(g, y);
          return y;
        }
        function bnpModInt(n) {
          if (n <= 0)
            return 0;
          var d2 = this.DV % n, r = this.s < 0 ? n - 1 : 0;
          if (this.t > 0)
            if (d2 == 0)
              r = this[0] % n;
            else
              for (var i2 = this.t - 1; i2 >= 0; --i2)
                r = (d2 * r + this[i2]) % n;
          return r;
        }
        function bnModInverse(m) {
          var ac = m.isEven();
          if (this.isEven() && ac || m.signum() == 0)
            return BigInteger.ZERO;
          var u = m.clone(), v = this.clone();
          var a2 = nbv(1), b2 = nbv(0), c2 = nbv(0), d2 = nbv(1);
          while (u.signum() != 0) {
            while (u.isEven()) {
              u.rShiftTo(1, u);
              if (ac) {
                if (!a2.isEven() || !b2.isEven()) {
                  a2.addTo(this, a2);
                  b2.subTo(m, b2);
                }
                a2.rShiftTo(1, a2);
              } else if (!b2.isEven())
                b2.subTo(m, b2);
              b2.rShiftTo(1, b2);
            }
            while (v.isEven()) {
              v.rShiftTo(1, v);
              if (ac) {
                if (!c2.isEven() || !d2.isEven()) {
                  c2.addTo(this, c2);
                  d2.subTo(m, d2);
                }
                c2.rShiftTo(1, c2);
              } else if (!d2.isEven())
                d2.subTo(m, d2);
              d2.rShiftTo(1, d2);
            }
            if (u.compareTo(v) >= 0) {
              u.subTo(v, u);
              if (ac)
                a2.subTo(c2, a2);
              b2.subTo(d2, b2);
            } else {
              v.subTo(u, v);
              if (ac)
                c2.subTo(a2, c2);
              d2.subTo(b2, d2);
            }
          }
          if (v.compareTo(BigInteger.ONE) != 0)
            return BigInteger.ZERO;
          if (d2.compareTo(m) >= 0)
            return d2.subtract(m);
          if (d2.signum() < 0)
            d2.addTo(m, d2);
          else
            return d2;
          if (d2.signum() < 0)
            return d2.add(m);
          else
            return d2;
        }
        var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];
        var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];
        function bnIsProbablePrime(t2) {
          var i2, x = this.abs();
          if (x.t == 1 && x[0] <= lowprimes[lowprimes.length - 1]) {
            for (i2 = 0; i2 < lowprimes.length; ++i2)
              if (x[0] == lowprimes[i2])
                return true;
            return false;
          }
          if (x.isEven())
            return false;
          i2 = 1;
          while (i2 < lowprimes.length) {
            var m = lowprimes[i2], j2 = i2 + 1;
            while (j2 < lowprimes.length && m < lplim)
              m *= lowprimes[j2++];
            m = x.modInt(m);
            while (i2 < j2)
              if (m % lowprimes[i2++] == 0)
                return false;
          }
          return x.millerRabin(t2);
        }
        function bnpMillerRabin(t2) {
          var n1 = this.subtract(BigInteger.ONE);
          var k = n1.getLowestSetBit();
          if (k <= 0)
            return false;
          var r = n1.shiftRight(k);
          t2 = t2 + 1 >> 1;
          if (t2 > lowprimes.length)
            t2 = lowprimes.length;
          var a2 = nbi();
          for (var i2 = 0; i2 < t2; ++i2) {
            a2.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);
            var y = a2.modPow(r, this);
            if (y.compareTo(BigInteger.ONE) != 0 && y.compareTo(n1) != 0) {
              var j2 = 1;
              while (j2++ < k && y.compareTo(n1) != 0) {
                y = y.modPowInt(2, this);
                if (y.compareTo(BigInteger.ONE) == 0)
                  return false;
              }
              if (y.compareTo(n1) != 0)
                return false;
            }
          }
          return true;
        }
        BigInteger.prototype.chunkSize = bnpChunkSize;
        BigInteger.prototype.toRadix = bnpToRadix;
        BigInteger.prototype.fromRadix = bnpFromRadix;
        BigInteger.prototype.fromNumber = bnpFromNumber;
        BigInteger.prototype.bitwiseTo = bnpBitwiseTo;
        BigInteger.prototype.changeBit = bnpChangeBit;
        BigInteger.prototype.addTo = bnpAddTo;
        BigInteger.prototype.dMultiply = bnpDMultiply;
        BigInteger.prototype.dAddOffset = bnpDAddOffset;
        BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;
        BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;
        BigInteger.prototype.modInt = bnpModInt;
        BigInteger.prototype.millerRabin = bnpMillerRabin;
        BigInteger.prototype.clone = bnClone;
        BigInteger.prototype.intValue = bnIntValue;
        BigInteger.prototype.byteValue = bnByteValue;
        BigInteger.prototype.shortValue = bnShortValue;
        BigInteger.prototype.signum = bnSigNum;
        BigInteger.prototype.toByteArray = bnToByteArray;
        BigInteger.prototype.equals = bnEquals;
        BigInteger.prototype.min = bnMin;
        BigInteger.prototype.max = bnMax;
        BigInteger.prototype.and = bnAnd;
        BigInteger.prototype.or = bnOr;
        BigInteger.prototype.xor = bnXor;
        BigInteger.prototype.andNot = bnAndNot;
        BigInteger.prototype.not = bnNot;
        BigInteger.prototype.shiftLeft = bnShiftLeft;
        BigInteger.prototype.shiftRight = bnShiftRight;
        BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;
        BigInteger.prototype.bitCount = bnBitCount;
        BigInteger.prototype.testBit = bnTestBit;
        BigInteger.prototype.setBit = bnSetBit;
        BigInteger.prototype.clearBit = bnClearBit;
        BigInteger.prototype.flipBit = bnFlipBit;
        BigInteger.prototype.add = bnAdd;
        BigInteger.prototype.subtract = bnSubtract;
        BigInteger.prototype.multiply = bnMultiply;
        BigInteger.prototype.divide = bnDivide;
        BigInteger.prototype.remainder = bnRemainder;
        BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;
        BigInteger.prototype.modPow = bnModPow;
        BigInteger.prototype.modInverse = bnModInverse;
        BigInteger.prototype.pow = bnPow;
        BigInteger.prototype.gcd = bnGCD;
        BigInteger.prototype.isProbablePrime = bnIsProbablePrime;
        BigInteger.prototype.square = bnSquare;
        BigInteger.prototype.Barrett = Barrett;
        var rng_state;
        var rng_pool;
        var rng_pptr;
        function rng_seed_int(x) {
          rng_pool[rng_pptr++] ^= x & 255;
          rng_pool[rng_pptr++] ^= x >> 8 & 255;
          rng_pool[rng_pptr++] ^= x >> 16 & 255;
          rng_pool[rng_pptr++] ^= x >> 24 & 255;
          if (rng_pptr >= rng_psize)
            rng_pptr -= rng_psize;
        }
        function rng_seed_time() {
          rng_seed_int((/* @__PURE__ */ new Date()).getTime());
        }
        if (rng_pool == null) {
          rng_pool = new Array();
          rng_pptr = 0;
          var t;
          if (typeof window !== "undefined" && window.crypto) {
            if (window.crypto.getRandomValues) {
              var ua = new Uint8Array(32);
              window.crypto.getRandomValues(ua);
              for (t = 0; t < 32; ++t)
                rng_pool[rng_pptr++] = ua[t];
            } else if (navigator.appName == "Netscape" && navigator.appVersion < "5") {
              var z = window.crypto.random(32);
              for (t = 0; t < z.length; ++t)
                rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
            }
          }
          while (rng_pptr < rng_psize) {
            t = Math.floor(65536 * Math.random());
            rng_pool[rng_pptr++] = t >>> 8;
            rng_pool[rng_pptr++] = t & 255;
          }
          rng_pptr = 0;
          rng_seed_time();
        }
        function rng_get_byte() {
          if (rng_state == null) {
            rng_seed_time();
            rng_state = prng_newstate();
            rng_state.init(rng_pool);
            for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr)
              rng_pool[rng_pptr] = 0;
            rng_pptr = 0;
          }
          return rng_state.next();
        }
        function rng_get_bytes(ba) {
          var i2;
          for (i2 = 0; i2 < ba.length; ++i2)
            ba[i2] = rng_get_byte();
        }
        function SecureRandom2() {
        }
        SecureRandom2.prototype.nextBytes = rng_get_bytes;
        function Arcfour() {
          this.i = 0;
          this.j = 0;
          this.S = new Array();
        }
        function ARC4init(key2) {
          var i2, j2, t2;
          for (i2 = 0; i2 < 256; ++i2)
            this.S[i2] = i2;
          j2 = 0;
          for (i2 = 0; i2 < 256; ++i2) {
            j2 = j2 + this.S[i2] + key2[i2 % key2.length] & 255;
            t2 = this.S[i2];
            this.S[i2] = this.S[j2];
            this.S[j2] = t2;
          }
          this.i = 0;
          this.j = 0;
        }
        function ARC4next() {
          var t2;
          this.i = this.i + 1 & 255;
          this.j = this.j + this.S[this.i] & 255;
          t2 = this.S[this.i];
          this.S[this.i] = this.S[this.j];
          this.S[this.j] = t2;
          return this.S[t2 + this.S[this.i] & 255];
        }
        Arcfour.prototype.init = ARC4init;
        Arcfour.prototype.next = ARC4next;
        function prng_newstate() {
          return new Arcfour();
        }
        var rng_psize = 256;
        BigInteger.SecureRandom = SecureRandom2;
        BigInteger.BigInteger = BigInteger;
        {
          module.exports = BigInteger;
        }
      }).call(commonjsGlobal);
    })(jsbn);
    return jsbn.exports;
  }
  var ec;
  var hasRequiredEc;
  function requireEc() {
    if (hasRequiredEc)
      return ec;
    hasRequiredEc = 1;
    var BigInteger = requireJsbn().BigInteger;
    var Barrett = BigInteger.prototype.Barrett;
    function ECFieldElementFp(q2, x) {
      this.x = x;
      this.q = q2;
    }
    function feFpEquals(other) {
      if (other == this)
        return true;
      return this.q.equals(other.q) && this.x.equals(other.x);
    }
    function feFpToBigInteger() {
      return this.x;
    }
    function feFpNegate() {
      return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
    }
    function feFpAdd(b2) {
      return new ECFieldElementFp(this.q, this.x.add(b2.toBigInteger()).mod(this.q));
    }
    function feFpSubtract(b2) {
      return new ECFieldElementFp(this.q, this.x.subtract(b2.toBigInteger()).mod(this.q));
    }
    function feFpMultiply(b2) {
      return new ECFieldElementFp(this.q, this.x.multiply(b2.toBigInteger()).mod(this.q));
    }
    function feFpSquare() {
      return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
    }
    function feFpDivide(b2) {
      return new ECFieldElementFp(this.q, this.x.multiply(b2.toBigInteger().modInverse(this.q)).mod(this.q));
    }
    ECFieldElementFp.prototype.equals = feFpEquals;
    ECFieldElementFp.prototype.toBigInteger = feFpToBigInteger;
    ECFieldElementFp.prototype.negate = feFpNegate;
    ECFieldElementFp.prototype.add = feFpAdd;
    ECFieldElementFp.prototype.subtract = feFpSubtract;
    ECFieldElementFp.prototype.multiply = feFpMultiply;
    ECFieldElementFp.prototype.square = feFpSquare;
    ECFieldElementFp.prototype.divide = feFpDivide;
    function ECPointFp(curve, x, y, z) {
      this.curve = curve;
      this.x = x;
      this.y = y;
      if (z == null) {
        this.z = BigInteger.ONE;
      } else {
        this.z = z;
      }
      this.zinv = null;
    }
    function pointFpGetX() {
      if (this.zinv == null) {
        this.zinv = this.z.modInverse(this.curve.q);
      }
      var r = this.x.toBigInteger().multiply(this.zinv);
      this.curve.reduce(r);
      return this.curve.fromBigInteger(r);
    }
    function pointFpGetY() {
      if (this.zinv == null) {
        this.zinv = this.z.modInverse(this.curve.q);
      }
      var r = this.y.toBigInteger().multiply(this.zinv);
      this.curve.reduce(r);
      return this.curve.fromBigInteger(r);
    }
    function pointFpEquals(other) {
      if (other == this)
        return true;
      if (this.isInfinity())
        return other.isInfinity();
      if (other.isInfinity())
        return this.isInfinity();
      var u, v;
      u = other.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(other.z)).mod(this.curve.q);
      if (!u.equals(BigInteger.ZERO))
        return false;
      v = other.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(other.z)).mod(this.curve.q);
      return v.equals(BigInteger.ZERO);
    }
    function pointFpIsInfinity() {
      if (this.x == null && this.y == null)
        return true;
      return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO);
    }
    function pointFpNegate() {
      return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
    }
    function pointFpAdd(b2) {
      if (this.isInfinity())
        return b2;
      if (b2.isInfinity())
        return this;
      var u = b2.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(b2.z)).mod(this.curve.q);
      var v = b2.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(b2.z)).mod(this.curve.q);
      if (BigInteger.ZERO.equals(v)) {
        if (BigInteger.ZERO.equals(u)) {
          return this.twice();
        }
        return this.curve.getInfinity();
      }
      var THREE = new BigInteger("3");
      var x1 = this.x.toBigInteger();
      var y1 = this.y.toBigInteger();
      b2.x.toBigInteger();
      b2.y.toBigInteger();
      var v2 = v.square();
      var v3 = v2.multiply(v);
      var x1v2 = x1.multiply(v2);
      var zu2 = u.square().multiply(this.z);
      var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b2.z).subtract(v3).multiply(v).mod(this.curve.q);
      var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b2.z).add(u.multiply(v3)).mod(this.curve.q);
      var z3 = v3.multiply(this.z).multiply(b2.z).mod(this.curve.q);
      return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
    }
    function pointFpTwice() {
      if (this.isInfinity())
        return this;
      if (this.y.toBigInteger().signum() == 0)
        return this.curve.getInfinity();
      var THREE = new BigInteger("3");
      var x1 = this.x.toBigInteger();
      var y1 = this.y.toBigInteger();
      var y1z1 = y1.multiply(this.z);
      var y1sqz1 = y1z1.multiply(y1).mod(this.curve.q);
      var a2 = this.curve.a.toBigInteger();
      var w = x1.square().multiply(THREE);
      if (!BigInteger.ZERO.equals(a2)) {
        w = w.add(this.z.square().multiply(a2));
      }
      w = w.mod(this.curve.q);
      var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.q);
      var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.square().multiply(w)).mod(this.curve.q);
      var z3 = y1z1.square().multiply(y1z1).shiftLeft(3).mod(this.curve.q);
      return new ECPointFp(this.curve, this.curve.fromBigInteger(x3), this.curve.fromBigInteger(y3), z3);
    }
    function pointFpMultiply(k) {
      if (this.isInfinity())
        return this;
      if (k.signum() == 0)
        return this.curve.getInfinity();
      var e = k;
      var h = e.multiply(new BigInteger("3"));
      var neg = this.negate();
      var R = this;
      var i2;
      for (i2 = h.bitLength() - 2; i2 > 0; --i2) {
        R = R.twice();
        var hBit = h.testBit(i2);
        var eBit = e.testBit(i2);
        if (hBit != eBit) {
          R = R.add(hBit ? this : neg);
        }
      }
      return R;
    }
    function pointFpMultiplyTwo(j2, x, k) {
      var i2;
      if (j2.bitLength() > k.bitLength())
        i2 = j2.bitLength() - 1;
      else
        i2 = k.bitLength() - 1;
      var R = this.curve.getInfinity();
      var both = this.add(x);
      while (i2 >= 0) {
        R = R.twice();
        if (j2.testBit(i2)) {
          if (k.testBit(i2)) {
            R = R.add(both);
          } else {
            R = R.add(this);
          }
        } else {
          if (k.testBit(i2)) {
            R = R.add(x);
          }
        }
        --i2;
      }
      return R;
    }
    ECPointFp.prototype.getX = pointFpGetX;
    ECPointFp.prototype.getY = pointFpGetY;
    ECPointFp.prototype.equals = pointFpEquals;
    ECPointFp.prototype.isInfinity = pointFpIsInfinity;
    ECPointFp.prototype.negate = pointFpNegate;
    ECPointFp.prototype.add = pointFpAdd;
    ECPointFp.prototype.twice = pointFpTwice;
    ECPointFp.prototype.multiply = pointFpMultiply;
    ECPointFp.prototype.multiplyTwo = pointFpMultiplyTwo;
    function ECCurveFp(q2, a2, b2) {
      this.q = q2;
      this.a = this.fromBigInteger(a2);
      this.b = this.fromBigInteger(b2);
      this.infinity = new ECPointFp(this, null, null);
      this.reducer = new Barrett(this.q);
    }
    function curveFpGetQ() {
      return this.q;
    }
    function curveFpGetA() {
      return this.a;
    }
    function curveFpGetB() {
      return this.b;
    }
    function curveFpEquals(other) {
      if (other == this)
        return true;
      return this.q.equals(other.q) && this.a.equals(other.a) && this.b.equals(other.b);
    }
    function curveFpGetInfinity() {
      return this.infinity;
    }
    function curveFpFromBigInteger(x) {
      return new ECFieldElementFp(this.q, x);
    }
    function curveReduce(x) {
      this.reducer.reduce(x);
    }
    function curveFpEncodePointHex(p) {
      if (p.isInfinity())
        return "00";
      var xHex = p.getX().toBigInteger().toString(16);
      var yHex = p.getY().toBigInteger().toString(16);
      var oLen = this.getQ().toString(16).length;
      if (oLen % 2 != 0)
        oLen++;
      while (xHex.length < oLen) {
        xHex = "0" + xHex;
      }
      while (yHex.length < oLen) {
        yHex = "0" + yHex;
      }
      return "04" + xHex + yHex;
    }
    ECCurveFp.prototype.getQ = curveFpGetQ;
    ECCurveFp.prototype.getA = curveFpGetA;
    ECCurveFp.prototype.getB = curveFpGetB;
    ECCurveFp.prototype.equals = curveFpEquals;
    ECCurveFp.prototype.getInfinity = curveFpGetInfinity;
    ECCurveFp.prototype.fromBigInteger = curveFpFromBigInteger;
    ECCurveFp.prototype.reduce = curveReduce;
    ECCurveFp.prototype.encodePointHex = curveFpEncodePointHex;
    ECCurveFp.prototype.decodePointHex = function(s) {
      var yIsEven;
      switch (parseInt(s.substr(0, 2), 16)) {
        case 0:
          return this.infinity;
        case 2:
          yIsEven = false;
        case 3:
          if (yIsEven == void 0)
            yIsEven = true;
          var len = s.length - 2;
          var xHex = s.substr(2, len);
          var x = this.fromBigInteger(new BigInteger(xHex, 16));
          var alpha = x.multiply(x.square().add(this.getA())).add(this.getB());
          var beta = alpha.sqrt();
          if (beta == null)
            throw "Invalid point compression";
          var betaValue = beta.toBigInteger();
          if (betaValue.testBit(0) != yIsEven) {
            beta = this.fromBigInteger(this.getQ().subtract(betaValue));
          }
          return new ECPointFp(this, x, beta);
        case 4:
        case 6:
        case 7:
          var len = (s.length - 2) / 2;
          var xHex = s.substr(2, len);
          var yHex = s.substr(len + 2, len);
          return new ECPointFp(
            this,
            this.fromBigInteger(new BigInteger(xHex, 16)),
            this.fromBigInteger(new BigInteger(yHex, 16))
          );
        default:
          return null;
      }
    };
    ECCurveFp.prototype.encodeCompressedPointHex = function(p) {
      if (p.isInfinity())
        return "00";
      var xHex = p.getX().toBigInteger().toString(16);
      var oLen = this.getQ().toString(16).length;
      if (oLen % 2 != 0)
        oLen++;
      while (xHex.length < oLen)
        xHex = "0" + xHex;
      var yPrefix;
      if (p.getY().toBigInteger().isEven())
        yPrefix = "02";
      else
        yPrefix = "03";
      return yPrefix + xHex;
    };
    ECFieldElementFp.prototype.getR = function() {
      if (this.r != void 0)
        return this.r;
      this.r = null;
      var bitLength = this.q.bitLength();
      if (bitLength > 128) {
        var firstWord = this.q.shiftRight(bitLength - 64);
        if (firstWord.intValue() == -1) {
          this.r = BigInteger.ONE.shiftLeft(bitLength).subtract(this.q);
        }
      }
      return this.r;
    };
    ECFieldElementFp.prototype.modMult = function(x1, x2) {
      return this.modReduce(x1.multiply(x2));
    };
    ECFieldElementFp.prototype.modReduce = function(x) {
      if (this.getR() != null) {
        var qLen = q.bitLength();
        while (x.bitLength() > qLen + 1) {
          var u = x.shiftRight(qLen);
          var v = x.subtract(u.shiftLeft(qLen));
          if (!this.getR().equals(BigInteger.ONE)) {
            u = u.multiply(this.getR());
          }
          x = u.add(v);
        }
        while (x.compareTo(q) >= 0) {
          x = x.subtract(q);
        }
      } else {
        x = x.mod(q);
      }
      return x;
    };
    ECFieldElementFp.prototype.sqrt = function() {
      if (!this.q.testBit(0))
        throw "unsupported";
      if (this.q.testBit(1)) {
        var z = new ECFieldElementFp(this.q, this.x.modPow(this.q.shiftRight(2).add(BigInteger.ONE), this.q));
        return z.square().equals(this) ? z : null;
      }
      var qMinusOne = this.q.subtract(BigInteger.ONE);
      var legendreExponent = qMinusOne.shiftRight(1);
      if (!this.x.modPow(legendreExponent, this.q).equals(BigInteger.ONE)) {
        return null;
      }
      var u = qMinusOne.shiftRight(2);
      var k = u.shiftLeft(1).add(BigInteger.ONE);
      var Q = this.x;
      var fourQ = modDouble(modDouble(Q));
      var U, V;
      do {
        var P;
        do {
          P = new BigInteger(this.q.bitLength(), new SecureRandom());
        } while (P.compareTo(this.q) >= 0 || !P.multiply(P).subtract(fourQ).modPow(legendreExponent, this.q).equals(qMinusOne));
        var result2 = this.lucasSequence(P, Q, k);
        U = result2[0];
        V = result2[1];
        if (this.modMult(V, V).equals(fourQ)) {
          if (V.testBit(0)) {
            V = V.add(q);
          }
          V = V.shiftRight(1);
          return new ECFieldElementFp(q, V);
        }
      } while (U.equals(BigInteger.ONE) || U.equals(qMinusOne));
      return null;
    };
    ECFieldElementFp.prototype.lucasSequence = function(P, Q, k) {
      var n = k.bitLength();
      var s = k.getLowestSetBit();
      var Uh = BigInteger.ONE;
      var Vl = BigInteger.TWO;
      var Vh = P;
      var Ql = BigInteger.ONE;
      var Qh = BigInteger.ONE;
      for (var j2 = n - 1; j2 >= s + 1; --j2) {
        Ql = this.modMult(Ql, Qh);
        if (k.testBit(j2)) {
          Qh = this.modMult(Ql, Q);
          Uh = this.modMult(Uh, Vh);
          Vl = this.modReduce(Vh.multiply(Vl).subtract(P.multiply(Ql)));
          Vh = this.modReduce(Vh.multiply(Vh).subtract(Qh.shiftLeft(1)));
        } else {
          Qh = Ql;
          Uh = this.modReduce(Uh.multiply(Vl).subtract(Ql));
          Vh = this.modReduce(Vh.multiply(Vl).subtract(P.multiply(Ql)));
          Vl = this.modReduce(Vl.multiply(Vl).subtract(Ql.shiftLeft(1)));
        }
      }
      Ql = this.modMult(Ql, Qh);
      Qh = this.modMult(Ql, Q);
      Uh = this.modReduce(Uh.multiply(Vl).subtract(Ql));
      Vl = this.modReduce(Vh.multiply(Vl).subtract(P.multiply(Ql)));
      Ql = this.modMult(Ql, Qh);
      for (var j2 = 1; j2 <= s; ++j2) {
        Uh = this.modMult(Uh, Vl);
        Vl = this.modReduce(Vl.multiply(Vl).subtract(Ql.shiftLeft(1)));
        Ql = this.modMult(Ql, Ql);
      }
      return [Uh, Vl];
    };
    var exports = {
      ECCurveFp,
      ECPointFp,
      ECFieldElementFp
    };
    ec = exports;
    return ec;
  }
  function commonjsRequire(path) {
    throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
  }
  var naclFast = { exports: {} };
  var hasRequiredNaclFast;
  function requireNaclFast() {
    if (hasRequiredNaclFast)
      return naclFast.exports;
    hasRequiredNaclFast = 1;
    (function(module) {
      (function(nacl) {
        var gf = function(init) {
          var i2, r = new Float64Array(16);
          if (init)
            for (i2 = 0; i2 < init.length; i2++)
              r[i2] = init[i2];
          return r;
        };
        var randombytes = function() {
          throw new Error("no PRNG");
        };
        var _0 = new Uint8Array(16);
        var _9 = new Uint8Array(32);
        _9[0] = 9;
        var gf0 = gf(), gf1 = gf([1]), _121665 = gf([56129, 1]), D = gf([30883, 4953, 19914, 30187, 55467, 16705, 2637, 112, 59544, 30585, 16505, 36039, 65139, 11119, 27886, 20995]), D2 = gf([61785, 9906, 39828, 60374, 45398, 33411, 5274, 224, 53552, 61171, 33010, 6542, 64743, 22239, 55772, 9222]), X = gf([54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412, 64982, 57905, 49316, 21502, 52590, 14035, 8553]), Y = gf([26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214]), I = gf([41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207, 15867, 153, 11085, 57099, 20417, 9344, 11139]);
        function ts64(x, i2, h, l) {
          x[i2] = h >> 24 & 255;
          x[i2 + 1] = h >> 16 & 255;
          x[i2 + 2] = h >> 8 & 255;
          x[i2 + 3] = h & 255;
          x[i2 + 4] = l >> 24 & 255;
          x[i2 + 5] = l >> 16 & 255;
          x[i2 + 6] = l >> 8 & 255;
          x[i2 + 7] = l & 255;
        }
        function vn(x, xi, y, yi, n) {
          var i2, d2 = 0;
          for (i2 = 0; i2 < n; i2++)
            d2 |= x[xi + i2] ^ y[yi + i2];
          return (1 & d2 - 1 >>> 8) - 1;
        }
        function crypto_verify_16(x, xi, y, yi) {
          return vn(x, xi, y, yi, 16);
        }
        function crypto_verify_32(x, xi, y, yi) {
          return vn(x, xi, y, yi, 32);
        }
        function core_salsa20(o, p, k, c2) {
          var j0 = c2[0] & 255 | (c2[1] & 255) << 8 | (c2[2] & 255) << 16 | (c2[3] & 255) << 24, j1 = k[0] & 255 | (k[1] & 255) << 8 | (k[2] & 255) << 16 | (k[3] & 255) << 24, j2 = k[4] & 255 | (k[5] & 255) << 8 | (k[6] & 255) << 16 | (k[7] & 255) << 24, j3 = k[8] & 255 | (k[9] & 255) << 8 | (k[10] & 255) << 16 | (k[11] & 255) << 24, j4 = k[12] & 255 | (k[13] & 255) << 8 | (k[14] & 255) << 16 | (k[15] & 255) << 24, j5 = c2[4] & 255 | (c2[5] & 255) << 8 | (c2[6] & 255) << 16 | (c2[7] & 255) << 24, j6 = p[0] & 255 | (p[1] & 255) << 8 | (p[2] & 255) << 16 | (p[3] & 255) << 24, j7 = p[4] & 255 | (p[5] & 255) << 8 | (p[6] & 255) << 16 | (p[7] & 255) << 24, j8 = p[8] & 255 | (p[9] & 255) << 8 | (p[10] & 255) << 16 | (p[11] & 255) << 24, j9 = p[12] & 255 | (p[13] & 255) << 8 | (p[14] & 255) << 16 | (p[15] & 255) << 24, j10 = c2[8] & 255 | (c2[9] & 255) << 8 | (c2[10] & 255) << 16 | (c2[11] & 255) << 24, j11 = k[16] & 255 | (k[17] & 255) << 8 | (k[18] & 255) << 16 | (k[19] & 255) << 24, j12 = k[20] & 255 | (k[21] & 255) << 8 | (k[22] & 255) << 16 | (k[23] & 255) << 24, j13 = k[24] & 255 | (k[25] & 255) << 8 | (k[26] & 255) << 16 | (k[27] & 255) << 24, j14 = k[28] & 255 | (k[29] & 255) << 8 | (k[30] & 255) << 16 | (k[31] & 255) << 24, j15 = c2[12] & 255 | (c2[13] & 255) << 8 | (c2[14] & 255) << 16 | (c2[15] & 255) << 24;
          var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u;
          for (var i2 = 0; i2 < 20; i2 += 2) {
            u = x0 + x12 | 0;
            x4 ^= u << 7 | u >>> 32 - 7;
            u = x4 + x0 | 0;
            x8 ^= u << 9 | u >>> 32 - 9;
            u = x8 + x4 | 0;
            x12 ^= u << 13 | u >>> 32 - 13;
            u = x12 + x8 | 0;
            x0 ^= u << 18 | u >>> 32 - 18;
            u = x5 + x1 | 0;
            x9 ^= u << 7 | u >>> 32 - 7;
            u = x9 + x5 | 0;
            x13 ^= u << 9 | u >>> 32 - 9;
            u = x13 + x9 | 0;
            x1 ^= u << 13 | u >>> 32 - 13;
            u = x1 + x13 | 0;
            x5 ^= u << 18 | u >>> 32 - 18;
            u = x10 + x6 | 0;
            x14 ^= u << 7 | u >>> 32 - 7;
            u = x14 + x10 | 0;
            x2 ^= u << 9 | u >>> 32 - 9;
            u = x2 + x14 | 0;
            x6 ^= u << 13 | u >>> 32 - 13;
            u = x6 + x2 | 0;
            x10 ^= u << 18 | u >>> 32 - 18;
            u = x15 + x11 | 0;
            x3 ^= u << 7 | u >>> 32 - 7;
            u = x3 + x15 | 0;
            x7 ^= u << 9 | u >>> 32 - 9;
            u = x7 + x3 | 0;
            x11 ^= u << 13 | u >>> 32 - 13;
            u = x11 + x7 | 0;
            x15 ^= u << 18 | u >>> 32 - 18;
            u = x0 + x3 | 0;
            x1 ^= u << 7 | u >>> 32 - 7;
            u = x1 + x0 | 0;
            x2 ^= u << 9 | u >>> 32 - 9;
            u = x2 + x1 | 0;
            x3 ^= u << 13 | u >>> 32 - 13;
            u = x3 + x2 | 0;
            x0 ^= u << 18 | u >>> 32 - 18;
            u = x5 + x4 | 0;
            x6 ^= u << 7 | u >>> 32 - 7;
            u = x6 + x5 | 0;
            x7 ^= u << 9 | u >>> 32 - 9;
            u = x7 + x6 | 0;
            x4 ^= u << 13 | u >>> 32 - 13;
            u = x4 + x7 | 0;
            x5 ^= u << 18 | u >>> 32 - 18;
            u = x10 + x9 | 0;
            x11 ^= u << 7 | u >>> 32 - 7;
            u = x11 + x10 | 0;
            x8 ^= u << 9 | u >>> 32 - 9;
            u = x8 + x11 | 0;
            x9 ^= u << 13 | u >>> 32 - 13;
            u = x9 + x8 | 0;
            x10 ^= u << 18 | u >>> 32 - 18;
            u = x15 + x14 | 0;
            x12 ^= u << 7 | u >>> 32 - 7;
            u = x12 + x15 | 0;
            x13 ^= u << 9 | u >>> 32 - 9;
            u = x13 + x12 | 0;
            x14 ^= u << 13 | u >>> 32 - 13;
            u = x14 + x13 | 0;
            x15 ^= u << 18 | u >>> 32 - 18;
          }
          x0 = x0 + j0 | 0;
          x1 = x1 + j1 | 0;
          x2 = x2 + j2 | 0;
          x3 = x3 + j3 | 0;
          x4 = x4 + j4 | 0;
          x5 = x5 + j5 | 0;
          x6 = x6 + j6 | 0;
          x7 = x7 + j7 | 0;
          x8 = x8 + j8 | 0;
          x9 = x9 + j9 | 0;
          x10 = x10 + j10 | 0;
          x11 = x11 + j11 | 0;
          x12 = x12 + j12 | 0;
          x13 = x13 + j13 | 0;
          x14 = x14 + j14 | 0;
          x15 = x15 + j15 | 0;
          o[0] = x0 >>> 0 & 255;
          o[1] = x0 >>> 8 & 255;
          o[2] = x0 >>> 16 & 255;
          o[3] = x0 >>> 24 & 255;
          o[4] = x1 >>> 0 & 255;
          o[5] = x1 >>> 8 & 255;
          o[6] = x1 >>> 16 & 255;
          o[7] = x1 >>> 24 & 255;
          o[8] = x2 >>> 0 & 255;
          o[9] = x2 >>> 8 & 255;
          o[10] = x2 >>> 16 & 255;
          o[11] = x2 >>> 24 & 255;
          o[12] = x3 >>> 0 & 255;
          o[13] = x3 >>> 8 & 255;
          o[14] = x3 >>> 16 & 255;
          o[15] = x3 >>> 24 & 255;
          o[16] = x4 >>> 0 & 255;
          o[17] = x4 >>> 8 & 255;
          o[18] = x4 >>> 16 & 255;
          o[19] = x4 >>> 24 & 255;
          o[20] = x5 >>> 0 & 255;
          o[21] = x5 >>> 8 & 255;
          o[22] = x5 >>> 16 & 255;
          o[23] = x5 >>> 24 & 255;
          o[24] = x6 >>> 0 & 255;
          o[25] = x6 >>> 8 & 255;
          o[26] = x6 >>> 16 & 255;
          o[27] = x6 >>> 24 & 255;
          o[28] = x7 >>> 0 & 255;
          o[29] = x7 >>> 8 & 255;
          o[30] = x7 >>> 16 & 255;
          o[31] = x7 >>> 24 & 255;
          o[32] = x8 >>> 0 & 255;
          o[33] = x8 >>> 8 & 255;
          o[34] = x8 >>> 16 & 255;
          o[35] = x8 >>> 24 & 255;
          o[36] = x9 >>> 0 & 255;
          o[37] = x9 >>> 8 & 255;
          o[38] = x9 >>> 16 & 255;
          o[39] = x9 >>> 24 & 255;
          o[40] = x10 >>> 0 & 255;
          o[41] = x10 >>> 8 & 255;
          o[42] = x10 >>> 16 & 255;
          o[43] = x10 >>> 24 & 255;
          o[44] = x11 >>> 0 & 255;
          o[45] = x11 >>> 8 & 255;
          o[46] = x11 >>> 16 & 255;
          o[47] = x11 >>> 24 & 255;
          o[48] = x12 >>> 0 & 255;
          o[49] = x12 >>> 8 & 255;
          o[50] = x12 >>> 16 & 255;
          o[51] = x12 >>> 24 & 255;
          o[52] = x13 >>> 0 & 255;
          o[53] = x13 >>> 8 & 255;
          o[54] = x13 >>> 16 & 255;
          o[55] = x13 >>> 24 & 255;
          o[56] = x14 >>> 0 & 255;
          o[57] = x14 >>> 8 & 255;
          o[58] = x14 >>> 16 & 255;
          o[59] = x14 >>> 24 & 255;
          o[60] = x15 >>> 0 & 255;
          o[61] = x15 >>> 8 & 255;
          o[62] = x15 >>> 16 & 255;
          o[63] = x15 >>> 24 & 255;
        }
        function core_hsalsa20(o, p, k, c2) {
          var j0 = c2[0] & 255 | (c2[1] & 255) << 8 | (c2[2] & 255) << 16 | (c2[3] & 255) << 24, j1 = k[0] & 255 | (k[1] & 255) << 8 | (k[2] & 255) << 16 | (k[3] & 255) << 24, j2 = k[4] & 255 | (k[5] & 255) << 8 | (k[6] & 255) << 16 | (k[7] & 255) << 24, j3 = k[8] & 255 | (k[9] & 255) << 8 | (k[10] & 255) << 16 | (k[11] & 255) << 24, j4 = k[12] & 255 | (k[13] & 255) << 8 | (k[14] & 255) << 16 | (k[15] & 255) << 24, j5 = c2[4] & 255 | (c2[5] & 255) << 8 | (c2[6] & 255) << 16 | (c2[7] & 255) << 24, j6 = p[0] & 255 | (p[1] & 255) << 8 | (p[2] & 255) << 16 | (p[3] & 255) << 24, j7 = p[4] & 255 | (p[5] & 255) << 8 | (p[6] & 255) << 16 | (p[7] & 255) << 24, j8 = p[8] & 255 | (p[9] & 255) << 8 | (p[10] & 255) << 16 | (p[11] & 255) << 24, j9 = p[12] & 255 | (p[13] & 255) << 8 | (p[14] & 255) << 16 | (p[15] & 255) << 24, j10 = c2[8] & 255 | (c2[9] & 255) << 8 | (c2[10] & 255) << 16 | (c2[11] & 255) << 24, j11 = k[16] & 255 | (k[17] & 255) << 8 | (k[18] & 255) << 16 | (k[19] & 255) << 24, j12 = k[20] & 255 | (k[21] & 255) << 8 | (k[22] & 255) << 16 | (k[23] & 255) << 24, j13 = k[24] & 255 | (k[25] & 255) << 8 | (k[26] & 255) << 16 | (k[27] & 255) << 24, j14 = k[28] & 255 | (k[29] & 255) << 8 | (k[30] & 255) << 16 | (k[31] & 255) << 24, j15 = c2[12] & 255 | (c2[13] & 255) << 8 | (c2[14] & 255) << 16 | (c2[15] & 255) << 24;
          var x0 = j0, x1 = j1, x2 = j2, x3 = j3, x4 = j4, x5 = j5, x6 = j6, x7 = j7, x8 = j8, x9 = j9, x10 = j10, x11 = j11, x12 = j12, x13 = j13, x14 = j14, x15 = j15, u;
          for (var i2 = 0; i2 < 20; i2 += 2) {
            u = x0 + x12 | 0;
            x4 ^= u << 7 | u >>> 32 - 7;
            u = x4 + x0 | 0;
            x8 ^= u << 9 | u >>> 32 - 9;
            u = x8 + x4 | 0;
            x12 ^= u << 13 | u >>> 32 - 13;
            u = x12 + x8 | 0;
            x0 ^= u << 18 | u >>> 32 - 18;
            u = x5 + x1 | 0;
            x9 ^= u << 7 | u >>> 32 - 7;
            u = x9 + x5 | 0;
            x13 ^= u << 9 | u >>> 32 - 9;
            u = x13 + x9 | 0;
            x1 ^= u << 13 | u >>> 32 - 13;
            u = x1 + x13 | 0;
            x5 ^= u << 18 | u >>> 32 - 18;
            u = x10 + x6 | 0;
            x14 ^= u << 7 | u >>> 32 - 7;
            u = x14 + x10 | 0;
            x2 ^= u << 9 | u >>> 32 - 9;
            u = x2 + x14 | 0;
            x6 ^= u << 13 | u >>> 32 - 13;
            u = x6 + x2 | 0;
            x10 ^= u << 18 | u >>> 32 - 18;
            u = x15 + x11 | 0;
            x3 ^= u << 7 | u >>> 32 - 7;
            u = x3 + x15 | 0;
            x7 ^= u << 9 | u >>> 32 - 9;
            u = x7 + x3 | 0;
            x11 ^= u << 13 | u >>> 32 - 13;
            u = x11 + x7 | 0;
            x15 ^= u << 18 | u >>> 32 - 18;
            u = x0 + x3 | 0;
            x1 ^= u << 7 | u >>> 32 - 7;
            u = x1 + x0 | 0;
            x2 ^= u << 9 | u >>> 32 - 9;
            u = x2 + x1 | 0;
            x3 ^= u << 13 | u >>> 32 - 13;
            u = x3 + x2 | 0;
            x0 ^= u << 18 | u >>> 32 - 18;
            u = x5 + x4 | 0;
            x6 ^= u << 7 | u >>> 32 - 7;
            u = x6 + x5 | 0;
            x7 ^= u << 9 | u >>> 32 - 9;
            u = x7 + x6 | 0;
            x4 ^= u << 13 | u >>> 32 - 13;
            u = x4 + x7 | 0;
            x5 ^= u << 18 | u >>> 32 - 18;
            u = x10 + x9 | 0;
            x11 ^= u << 7 | u >>> 32 - 7;
            u = x11 + x10 | 0;
            x8 ^= u << 9 | u >>> 32 - 9;
            u = x8 + x11 | 0;
            x9 ^= u << 13 | u >>> 32 - 13;
            u = x9 + x8 | 0;
            x10 ^= u << 18 | u >>> 32 - 18;
            u = x15 + x14 | 0;
            x12 ^= u << 7 | u >>> 32 - 7;
            u = x12 + x15 | 0;
            x13 ^= u << 9 | u >>> 32 - 9;
            u = x13 + x12 | 0;
            x14 ^= u << 13 | u >>> 32 - 13;
            u = x14 + x13 | 0;
            x15 ^= u << 18 | u >>> 32 - 18;
          }
          o[0] = x0 >>> 0 & 255;
          o[1] = x0 >>> 8 & 255;
          o[2] = x0 >>> 16 & 255;
          o[3] = x0 >>> 24 & 255;
          o[4] = x5 >>> 0 & 255;
          o[5] = x5 >>> 8 & 255;
          o[6] = x5 >>> 16 & 255;
          o[7] = x5 >>> 24 & 255;
          o[8] = x10 >>> 0 & 255;
          o[9] = x10 >>> 8 & 255;
          o[10] = x10 >>> 16 & 255;
          o[11] = x10 >>> 24 & 255;
          o[12] = x15 >>> 0 & 255;
          o[13] = x15 >>> 8 & 255;
          o[14] = x15 >>> 16 & 255;
          o[15] = x15 >>> 24 & 255;
          o[16] = x6 >>> 0 & 255;
          o[17] = x6 >>> 8 & 255;
          o[18] = x6 >>> 16 & 255;
          o[19] = x6 >>> 24 & 255;
          o[20] = x7 >>> 0 & 255;
          o[21] = x7 >>> 8 & 255;
          o[22] = x7 >>> 16 & 255;
          o[23] = x7 >>> 24 & 255;
          o[24] = x8 >>> 0 & 255;
          o[25] = x8 >>> 8 & 255;
          o[26] = x8 >>> 16 & 255;
          o[27] = x8 >>> 24 & 255;
          o[28] = x9 >>> 0 & 255;
          o[29] = x9 >>> 8 & 255;
          o[30] = x9 >>> 16 & 255;
          o[31] = x9 >>> 24 & 255;
        }
        function crypto_core_salsa20(out, inp, k, c2) {
          core_salsa20(out, inp, k, c2);
        }
        function crypto_core_hsalsa20(out, inp, k, c2) {
          core_hsalsa20(out, inp, k, c2);
        }
        var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
        function crypto_stream_salsa20_xor(c2, cpos, m, mpos, b2, n, k) {
          var z = new Uint8Array(16), x = new Uint8Array(64);
          var u, i2;
          for (i2 = 0; i2 < 16; i2++)
            z[i2] = 0;
          for (i2 = 0; i2 < 8; i2++)
            z[i2] = n[i2];
          while (b2 >= 64) {
            crypto_core_salsa20(x, z, k, sigma);
            for (i2 = 0; i2 < 64; i2++)
              c2[cpos + i2] = m[mpos + i2] ^ x[i2];
            u = 1;
            for (i2 = 8; i2 < 16; i2++) {
              u = u + (z[i2] & 255) | 0;
              z[i2] = u & 255;
              u >>>= 8;
            }
            b2 -= 64;
            cpos += 64;
            mpos += 64;
          }
          if (b2 > 0) {
            crypto_core_salsa20(x, z, k, sigma);
            for (i2 = 0; i2 < b2; i2++)
              c2[cpos + i2] = m[mpos + i2] ^ x[i2];
          }
          return 0;
        }
        function crypto_stream_salsa20(c2, cpos, b2, n, k) {
          var z = new Uint8Array(16), x = new Uint8Array(64);
          var u, i2;
          for (i2 = 0; i2 < 16; i2++)
            z[i2] = 0;
          for (i2 = 0; i2 < 8; i2++)
            z[i2] = n[i2];
          while (b2 >= 64) {
            crypto_core_salsa20(x, z, k, sigma);
            for (i2 = 0; i2 < 64; i2++)
              c2[cpos + i2] = x[i2];
            u = 1;
            for (i2 = 8; i2 < 16; i2++) {
              u = u + (z[i2] & 255) | 0;
              z[i2] = u & 255;
              u >>>= 8;
            }
            b2 -= 64;
            cpos += 64;
          }
          if (b2 > 0) {
            crypto_core_salsa20(x, z, k, sigma);
            for (i2 = 0; i2 < b2; i2++)
              c2[cpos + i2] = x[i2];
          }
          return 0;
        }
        function crypto_stream(c2, cpos, d2, n, k) {
          var s = new Uint8Array(32);
          crypto_core_hsalsa20(s, n, k, sigma);
          var sn = new Uint8Array(8);
          for (var i2 = 0; i2 < 8; i2++)
            sn[i2] = n[i2 + 16];
          return crypto_stream_salsa20(c2, cpos, d2, sn, s);
        }
        function crypto_stream_xor(c2, cpos, m, mpos, d2, n, k) {
          var s = new Uint8Array(32);
          crypto_core_hsalsa20(s, n, k, sigma);
          var sn = new Uint8Array(8);
          for (var i2 = 0; i2 < 8; i2++)
            sn[i2] = n[i2 + 16];
          return crypto_stream_salsa20_xor(c2, cpos, m, mpos, d2, sn, s);
        }
        var poly1305 = function(key2) {
          this.buffer = new Uint8Array(16);
          this.r = new Uint16Array(10);
          this.h = new Uint16Array(10);
          this.pad = new Uint16Array(8);
          this.leftover = 0;
          this.fin = 0;
          var t0, t1, t2, t3, t4, t5, t6, t7;
          t0 = key2[0] & 255 | (key2[1] & 255) << 8;
          this.r[0] = t0 & 8191;
          t1 = key2[2] & 255 | (key2[3] & 255) << 8;
          this.r[1] = (t0 >>> 13 | t1 << 3) & 8191;
          t2 = key2[4] & 255 | (key2[5] & 255) << 8;
          this.r[2] = (t1 >>> 10 | t2 << 6) & 7939;
          t3 = key2[6] & 255 | (key2[7] & 255) << 8;
          this.r[3] = (t2 >>> 7 | t3 << 9) & 8191;
          t4 = key2[8] & 255 | (key2[9] & 255) << 8;
          this.r[4] = (t3 >>> 4 | t4 << 12) & 255;
          this.r[5] = t4 >>> 1 & 8190;
          t5 = key2[10] & 255 | (key2[11] & 255) << 8;
          this.r[6] = (t4 >>> 14 | t5 << 2) & 8191;
          t6 = key2[12] & 255 | (key2[13] & 255) << 8;
          this.r[7] = (t5 >>> 11 | t6 << 5) & 8065;
          t7 = key2[14] & 255 | (key2[15] & 255) << 8;
          this.r[8] = (t6 >>> 8 | t7 << 8) & 8191;
          this.r[9] = t7 >>> 5 & 127;
          this.pad[0] = key2[16] & 255 | (key2[17] & 255) << 8;
          this.pad[1] = key2[18] & 255 | (key2[19] & 255) << 8;
          this.pad[2] = key2[20] & 255 | (key2[21] & 255) << 8;
          this.pad[3] = key2[22] & 255 | (key2[23] & 255) << 8;
          this.pad[4] = key2[24] & 255 | (key2[25] & 255) << 8;
          this.pad[5] = key2[26] & 255 | (key2[27] & 255) << 8;
          this.pad[6] = key2[28] & 255 | (key2[29] & 255) << 8;
          this.pad[7] = key2[30] & 255 | (key2[31] & 255) << 8;
        };
        poly1305.prototype.blocks = function(m, mpos, bytes) {
          var hibit = this.fin ? 0 : 1 << 11;
          var t0, t1, t2, t3, t4, t5, t6, t7, c2;
          var d0, d1, d2, d3, d4, d5, d6, d7, d8, d9;
          var h0 = this.h[0], h1 = this.h[1], h2 = this.h[2], h3 = this.h[3], h4 = this.h[4], h5 = this.h[5], h6 = this.h[6], h7 = this.h[7], h8 = this.h[8], h9 = this.h[9];
          var r0 = this.r[0], r1 = this.r[1], r2 = this.r[2], r3 = this.r[3], r4 = this.r[4], r5 = this.r[5], r6 = this.r[6], r7 = this.r[7], r8 = this.r[8], r9 = this.r[9];
          while (bytes >= 16) {
            t0 = m[mpos + 0] & 255 | (m[mpos + 1] & 255) << 8;
            h0 += t0 & 8191;
            t1 = m[mpos + 2] & 255 | (m[mpos + 3] & 255) << 8;
            h1 += (t0 >>> 13 | t1 << 3) & 8191;
            t2 = m[mpos + 4] & 255 | (m[mpos + 5] & 255) << 8;
            h2 += (t1 >>> 10 | t2 << 6) & 8191;
            t3 = m[mpos + 6] & 255 | (m[mpos + 7] & 255) << 8;
            h3 += (t2 >>> 7 | t3 << 9) & 8191;
            t4 = m[mpos + 8] & 255 | (m[mpos + 9] & 255) << 8;
            h4 += (t3 >>> 4 | t4 << 12) & 8191;
            h5 += t4 >>> 1 & 8191;
            t5 = m[mpos + 10] & 255 | (m[mpos + 11] & 255) << 8;
            h6 += (t4 >>> 14 | t5 << 2) & 8191;
            t6 = m[mpos + 12] & 255 | (m[mpos + 13] & 255) << 8;
            h7 += (t5 >>> 11 | t6 << 5) & 8191;
            t7 = m[mpos + 14] & 255 | (m[mpos + 15] & 255) << 8;
            h8 += (t6 >>> 8 | t7 << 8) & 8191;
            h9 += t7 >>> 5 | hibit;
            c2 = 0;
            d0 = c2;
            d0 += h0 * r0;
            d0 += h1 * (5 * r9);
            d0 += h2 * (5 * r8);
            d0 += h3 * (5 * r7);
            d0 += h4 * (5 * r6);
            c2 = d0 >>> 13;
            d0 &= 8191;
            d0 += h5 * (5 * r5);
            d0 += h6 * (5 * r4);
            d0 += h7 * (5 * r3);
            d0 += h8 * (5 * r2);
            d0 += h9 * (5 * r1);
            c2 += d0 >>> 13;
            d0 &= 8191;
            d1 = c2;
            d1 += h0 * r1;
            d1 += h1 * r0;
            d1 += h2 * (5 * r9);
            d1 += h3 * (5 * r8);
            d1 += h4 * (5 * r7);
            c2 = d1 >>> 13;
            d1 &= 8191;
            d1 += h5 * (5 * r6);
            d1 += h6 * (5 * r5);
            d1 += h7 * (5 * r4);
            d1 += h8 * (5 * r3);
            d1 += h9 * (5 * r2);
            c2 += d1 >>> 13;
            d1 &= 8191;
            d2 = c2;
            d2 += h0 * r2;
            d2 += h1 * r1;
            d2 += h2 * r0;
            d2 += h3 * (5 * r9);
            d2 += h4 * (5 * r8);
            c2 = d2 >>> 13;
            d2 &= 8191;
            d2 += h5 * (5 * r7);
            d2 += h6 * (5 * r6);
            d2 += h7 * (5 * r5);
            d2 += h8 * (5 * r4);
            d2 += h9 * (5 * r3);
            c2 += d2 >>> 13;
            d2 &= 8191;
            d3 = c2;
            d3 += h0 * r3;
            d3 += h1 * r2;
            d3 += h2 * r1;
            d3 += h3 * r0;
            d3 += h4 * (5 * r9);
            c2 = d3 >>> 13;
            d3 &= 8191;
            d3 += h5 * (5 * r8);
            d3 += h6 * (5 * r7);
            d3 += h7 * (5 * r6);
            d3 += h8 * (5 * r5);
            d3 += h9 * (5 * r4);
            c2 += d3 >>> 13;
            d3 &= 8191;
            d4 = c2;
            d4 += h0 * r4;
            d4 += h1 * r3;
            d4 += h2 * r2;
            d4 += h3 * r1;
            d4 += h4 * r0;
            c2 = d4 >>> 13;
            d4 &= 8191;
            d4 += h5 * (5 * r9);
            d4 += h6 * (5 * r8);
            d4 += h7 * (5 * r7);
            d4 += h8 * (5 * r6);
            d4 += h9 * (5 * r5);
            c2 += d4 >>> 13;
            d4 &= 8191;
            d5 = c2;
            d5 += h0 * r5;
            d5 += h1 * r4;
            d5 += h2 * r3;
            d5 += h3 * r2;
            d5 += h4 * r1;
            c2 = d5 >>> 13;
            d5 &= 8191;
            d5 += h5 * r0;
            d5 += h6 * (5 * r9);
            d5 += h7 * (5 * r8);
            d5 += h8 * (5 * r7);
            d5 += h9 * (5 * r6);
            c2 += d5 >>> 13;
            d5 &= 8191;
            d6 = c2;
            d6 += h0 * r6;
            d6 += h1 * r5;
            d6 += h2 * r4;
            d6 += h3 * r3;
            d6 += h4 * r2;
            c2 = d6 >>> 13;
            d6 &= 8191;
            d6 += h5 * r1;
            d6 += h6 * r0;
            d6 += h7 * (5 * r9);
            d6 += h8 * (5 * r8);
            d6 += h9 * (5 * r7);
            c2 += d6 >>> 13;
            d6 &= 8191;
            d7 = c2;
            d7 += h0 * r7;
            d7 += h1 * r6;
            d7 += h2 * r5;
            d7 += h3 * r4;
            d7 += h4 * r3;
            c2 = d7 >>> 13;
            d7 &= 8191;
            d7 += h5 * r2;
            d7 += h6 * r1;
            d7 += h7 * r0;
            d7 += h8 * (5 * r9);
            d7 += h9 * (5 * r8);
            c2 += d7 >>> 13;
            d7 &= 8191;
            d8 = c2;
            d8 += h0 * r8;
            d8 += h1 * r7;
            d8 += h2 * r6;
            d8 += h3 * r5;
            d8 += h4 * r4;
            c2 = d8 >>> 13;
            d8 &= 8191;
            d8 += h5 * r3;
            d8 += h6 * r2;
            d8 += h7 * r1;
            d8 += h8 * r0;
            d8 += h9 * (5 * r9);
            c2 += d8 >>> 13;
            d8 &= 8191;
            d9 = c2;
            d9 += h0 * r9;
            d9 += h1 * r8;
            d9 += h2 * r7;
            d9 += h3 * r6;
            d9 += h4 * r5;
            c2 = d9 >>> 13;
            d9 &= 8191;
            d9 += h5 * r4;
            d9 += h6 * r3;
            d9 += h7 * r2;
            d9 += h8 * r1;
            d9 += h9 * r0;
            c2 += d9 >>> 13;
            d9 &= 8191;
            c2 = (c2 << 2) + c2 | 0;
            c2 = c2 + d0 | 0;
            d0 = c2 & 8191;
            c2 = c2 >>> 13;
            d1 += c2;
            h0 = d0;
            h1 = d1;
            h2 = d2;
            h3 = d3;
            h4 = d4;
            h5 = d5;
            h6 = d6;
            h7 = d7;
            h8 = d8;
            h9 = d9;
            mpos += 16;
            bytes -= 16;
          }
          this.h[0] = h0;
          this.h[1] = h1;
          this.h[2] = h2;
          this.h[3] = h3;
          this.h[4] = h4;
          this.h[5] = h5;
          this.h[6] = h6;
          this.h[7] = h7;
          this.h[8] = h8;
          this.h[9] = h9;
        };
        poly1305.prototype.finish = function(mac, macpos) {
          var g = new Uint16Array(10);
          var c2, mask, f, i2;
          if (this.leftover) {
            i2 = this.leftover;
            this.buffer[i2++] = 1;
            for (; i2 < 16; i2++)
              this.buffer[i2] = 0;
            this.fin = 1;
            this.blocks(this.buffer, 0, 16);
          }
          c2 = this.h[1] >>> 13;
          this.h[1] &= 8191;
          for (i2 = 2; i2 < 10; i2++) {
            this.h[i2] += c2;
            c2 = this.h[i2] >>> 13;
            this.h[i2] &= 8191;
          }
          this.h[0] += c2 * 5;
          c2 = this.h[0] >>> 13;
          this.h[0] &= 8191;
          this.h[1] += c2;
          c2 = this.h[1] >>> 13;
          this.h[1] &= 8191;
          this.h[2] += c2;
          g[0] = this.h[0] + 5;
          c2 = g[0] >>> 13;
          g[0] &= 8191;
          for (i2 = 1; i2 < 10; i2++) {
            g[i2] = this.h[i2] + c2;
            c2 = g[i2] >>> 13;
            g[i2] &= 8191;
          }
          g[9] -= 1 << 13;
          mask = (c2 ^ 1) - 1;
          for (i2 = 0; i2 < 10; i2++)
            g[i2] &= mask;
          mask = ~mask;
          for (i2 = 0; i2 < 10; i2++)
            this.h[i2] = this.h[i2] & mask | g[i2];
          this.h[0] = (this.h[0] | this.h[1] << 13) & 65535;
          this.h[1] = (this.h[1] >>> 3 | this.h[2] << 10) & 65535;
          this.h[2] = (this.h[2] >>> 6 | this.h[3] << 7) & 65535;
          this.h[3] = (this.h[3] >>> 9 | this.h[4] << 4) & 65535;
          this.h[4] = (this.h[4] >>> 12 | this.h[5] << 1 | this.h[6] << 14) & 65535;
          this.h[5] = (this.h[6] >>> 2 | this.h[7] << 11) & 65535;
          this.h[6] = (this.h[7] >>> 5 | this.h[8] << 8) & 65535;
          this.h[7] = (this.h[8] >>> 8 | this.h[9] << 5) & 65535;
          f = this.h[0] + this.pad[0];
          this.h[0] = f & 65535;
          for (i2 = 1; i2 < 8; i2++) {
            f = (this.h[i2] + this.pad[i2] | 0) + (f >>> 16) | 0;
            this.h[i2] = f & 65535;
          }
          mac[macpos + 0] = this.h[0] >>> 0 & 255;
          mac[macpos + 1] = this.h[0] >>> 8 & 255;
          mac[macpos + 2] = this.h[1] >>> 0 & 255;
          mac[macpos + 3] = this.h[1] >>> 8 & 255;
          mac[macpos + 4] = this.h[2] >>> 0 & 255;
          mac[macpos + 5] = this.h[2] >>> 8 & 255;
          mac[macpos + 6] = this.h[3] >>> 0 & 255;
          mac[macpos + 7] = this.h[3] >>> 8 & 255;
          mac[macpos + 8] = this.h[4] >>> 0 & 255;
          mac[macpos + 9] = this.h[4] >>> 8 & 255;
          mac[macpos + 10] = this.h[5] >>> 0 & 255;
          mac[macpos + 11] = this.h[5] >>> 8 & 255;
          mac[macpos + 12] = this.h[6] >>> 0 & 255;
          mac[macpos + 13] = this.h[6] >>> 8 & 255;
          mac[macpos + 14] = this.h[7] >>> 0 & 255;
          mac[macpos + 15] = this.h[7] >>> 8 & 255;
        };
        poly1305.prototype.update = function(m, mpos, bytes) {
          var i2, want;
          if (this.leftover) {
            want = 16 - this.leftover;
            if (want > bytes)
              want = bytes;
            for (i2 = 0; i2 < want; i2++)
              this.buffer[this.leftover + i2] = m[mpos + i2];
            bytes -= want;
            mpos += want;
            this.leftover += want;
            if (this.leftover < 16)
              return;
            this.blocks(this.buffer, 0, 16);
            this.leftover = 0;
          }
          if (bytes >= 16) {
            want = bytes - bytes % 16;
            this.blocks(m, mpos, want);
            mpos += want;
            bytes -= want;
          }
          if (bytes) {
            for (i2 = 0; i2 < bytes; i2++)
              this.buffer[this.leftover + i2] = m[mpos + i2];
            this.leftover += bytes;
          }
        };
        function crypto_onetimeauth(out, outpos, m, mpos, n, k) {
          var s = new poly1305(k);
          s.update(m, mpos, n);
          s.finish(out, outpos);
          return 0;
        }
        function crypto_onetimeauth_verify(h, hpos, m, mpos, n, k) {
          var x = new Uint8Array(16);
          crypto_onetimeauth(x, 0, m, mpos, n, k);
          return crypto_verify_16(h, hpos, x, 0);
        }
        function crypto_secretbox(c2, m, d2, n, k) {
          var i2;
          if (d2 < 32)
            return -1;
          crypto_stream_xor(c2, 0, m, 0, d2, n, k);
          crypto_onetimeauth(c2, 16, c2, 32, d2 - 32, c2);
          for (i2 = 0; i2 < 16; i2++)
            c2[i2] = 0;
          return 0;
        }
        function crypto_secretbox_open(m, c2, d2, n, k) {
          var i2;
          var x = new Uint8Array(32);
          if (d2 < 32)
            return -1;
          crypto_stream(x, 0, 32, n, k);
          if (crypto_onetimeauth_verify(c2, 16, c2, 32, d2 - 32, x) !== 0)
            return -1;
          crypto_stream_xor(m, 0, c2, 0, d2, n, k);
          for (i2 = 0; i2 < 32; i2++)
            m[i2] = 0;
          return 0;
        }
        function set25519(r, a2) {
          var i2;
          for (i2 = 0; i2 < 16; i2++)
            r[i2] = a2[i2] | 0;
        }
        function car25519(o) {
          var i2, v, c2 = 1;
          for (i2 = 0; i2 < 16; i2++) {
            v = o[i2] + c2 + 65535;
            c2 = Math.floor(v / 65536);
            o[i2] = v - c2 * 65536;
          }
          o[0] += c2 - 1 + 37 * (c2 - 1);
        }
        function sel25519(p, q2, b2) {
          var t, c2 = ~(b2 - 1);
          for (var i2 = 0; i2 < 16; i2++) {
            t = c2 & (p[i2] ^ q2[i2]);
            p[i2] ^= t;
            q2[i2] ^= t;
          }
        }
        function pack25519(o, n) {
          var i2, j2, b2;
          var m = gf(), t = gf();
          for (i2 = 0; i2 < 16; i2++)
            t[i2] = n[i2];
          car25519(t);
          car25519(t);
          car25519(t);
          for (j2 = 0; j2 < 2; j2++) {
            m[0] = t[0] - 65517;
            for (i2 = 1; i2 < 15; i2++) {
              m[i2] = t[i2] - 65535 - (m[i2 - 1] >> 16 & 1);
              m[i2 - 1] &= 65535;
            }
            m[15] = t[15] - 32767 - (m[14] >> 16 & 1);
            b2 = m[15] >> 16 & 1;
            m[14] &= 65535;
            sel25519(t, m, 1 - b2);
          }
          for (i2 = 0; i2 < 16; i2++) {
            o[2 * i2] = t[i2] & 255;
            o[2 * i2 + 1] = t[i2] >> 8;
          }
        }
        function neq25519(a2, b2) {
          var c2 = new Uint8Array(32), d2 = new Uint8Array(32);
          pack25519(c2, a2);
          pack25519(d2, b2);
          return crypto_verify_32(c2, 0, d2, 0);
        }
        function par25519(a2) {
          var d2 = new Uint8Array(32);
          pack25519(d2, a2);
          return d2[0] & 1;
        }
        function unpack25519(o, n) {
          var i2;
          for (i2 = 0; i2 < 16; i2++)
            o[i2] = n[2 * i2] + (n[2 * i2 + 1] << 8);
          o[15] &= 32767;
        }
        function A(o, a2, b2) {
          for (var i2 = 0; i2 < 16; i2++)
            o[i2] = a2[i2] + b2[i2];
        }
        function Z(o, a2, b2) {
          for (var i2 = 0; i2 < 16; i2++)
            o[i2] = a2[i2] - b2[i2];
        }
        function M(o, a2, b2) {
          var v, c2, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3], b4 = b2[4], b5 = b2[5], b6 = b2[6], b7 = b2[7], b8 = b2[8], b9 = b2[9], b10 = b2[10], b11 = b2[11], b12 = b2[12], b13 = b2[13], b14 = b2[14], b15 = b2[15];
          v = a2[0];
          t0 += v * b0;
          t1 += v * b1;
          t2 += v * b22;
          t3 += v * b3;
          t4 += v * b4;
          t5 += v * b5;
          t6 += v * b6;
          t7 += v * b7;
          t8 += v * b8;
          t9 += v * b9;
          t10 += v * b10;
          t11 += v * b11;
          t12 += v * b12;
          t13 += v * b13;
          t14 += v * b14;
          t15 += v * b15;
          v = a2[1];
          t1 += v * b0;
          t2 += v * b1;
          t3 += v * b22;
          t4 += v * b3;
          t5 += v * b4;
          t6 += v * b5;
          t7 += v * b6;
          t8 += v * b7;
          t9 += v * b8;
          t10 += v * b9;
          t11 += v * b10;
          t12 += v * b11;
          t13 += v * b12;
          t14 += v * b13;
          t15 += v * b14;
          t16 += v * b15;
          v = a2[2];
          t2 += v * b0;
          t3 += v * b1;
          t4 += v * b22;
          t5 += v * b3;
          t6 += v * b4;
          t7 += v * b5;
          t8 += v * b6;
          t9 += v * b7;
          t10 += v * b8;
          t11 += v * b9;
          t12 += v * b10;
          t13 += v * b11;
          t14 += v * b12;
          t15 += v * b13;
          t16 += v * b14;
          t17 += v * b15;
          v = a2[3];
          t3 += v * b0;
          t4 += v * b1;
          t5 += v * b22;
          t6 += v * b3;
          t7 += v * b4;
          t8 += v * b5;
          t9 += v * b6;
          t10 += v * b7;
          t11 += v * b8;
          t12 += v * b9;
          t13 += v * b10;
          t14 += v * b11;
          t15 += v * b12;
          t16 += v * b13;
          t17 += v * b14;
          t18 += v * b15;
          v = a2[4];
          t4 += v * b0;
          t5 += v * b1;
          t6 += v * b22;
          t7 += v * b3;
          t8 += v * b4;
          t9 += v * b5;
          t10 += v * b6;
          t11 += v * b7;
          t12 += v * b8;
          t13 += v * b9;
          t14 += v * b10;
          t15 += v * b11;
          t16 += v * b12;
          t17 += v * b13;
          t18 += v * b14;
          t19 += v * b15;
          v = a2[5];
          t5 += v * b0;
          t6 += v * b1;
          t7 += v * b22;
          t8 += v * b3;
          t9 += v * b4;
          t10 += v * b5;
          t11 += v * b6;
          t12 += v * b7;
          t13 += v * b8;
          t14 += v * b9;
          t15 += v * b10;
          t16 += v * b11;
          t17 += v * b12;
          t18 += v * b13;
          t19 += v * b14;
          t20 += v * b15;
          v = a2[6];
          t6 += v * b0;
          t7 += v * b1;
          t8 += v * b22;
          t9 += v * b3;
          t10 += v * b4;
          t11 += v * b5;
          t12 += v * b6;
          t13 += v * b7;
          t14 += v * b8;
          t15 += v * b9;
          t16 += v * b10;
          t17 += v * b11;
          t18 += v * b12;
          t19 += v * b13;
          t20 += v * b14;
          t21 += v * b15;
          v = a2[7];
          t7 += v * b0;
          t8 += v * b1;
          t9 += v * b22;
          t10 += v * b3;
          t11 += v * b4;
          t12 += v * b5;
          t13 += v * b6;
          t14 += v * b7;
          t15 += v * b8;
          t16 += v * b9;
          t17 += v * b10;
          t18 += v * b11;
          t19 += v * b12;
          t20 += v * b13;
          t21 += v * b14;
          t22 += v * b15;
          v = a2[8];
          t8 += v * b0;
          t9 += v * b1;
          t10 += v * b22;
          t11 += v * b3;
          t12 += v * b4;
          t13 += v * b5;
          t14 += v * b6;
          t15 += v * b7;
          t16 += v * b8;
          t17 += v * b9;
          t18 += v * b10;
          t19 += v * b11;
          t20 += v * b12;
          t21 += v * b13;
          t22 += v * b14;
          t23 += v * b15;
          v = a2[9];
          t9 += v * b0;
          t10 += v * b1;
          t11 += v * b22;
          t12 += v * b3;
          t13 += v * b4;
          t14 += v * b5;
          t15 += v * b6;
          t16 += v * b7;
          t17 += v * b8;
          t18 += v * b9;
          t19 += v * b10;
          t20 += v * b11;
          t21 += v * b12;
          t22 += v * b13;
          t23 += v * b14;
          t24 += v * b15;
          v = a2[10];
          t10 += v * b0;
          t11 += v * b1;
          t12 += v * b22;
          t13 += v * b3;
          t14 += v * b4;
          t15 += v * b5;
          t16 += v * b6;
          t17 += v * b7;
          t18 += v * b8;
          t19 += v * b9;
          t20 += v * b10;
          t21 += v * b11;
          t22 += v * b12;
          t23 += v * b13;
          t24 += v * b14;
          t25 += v * b15;
          v = a2[11];
          t11 += v * b0;
          t12 += v * b1;
          t13 += v * b22;
          t14 += v * b3;
          t15 += v * b4;
          t16 += v * b5;
          t17 += v * b6;
          t18 += v * b7;
          t19 += v * b8;
          t20 += v * b9;
          t21 += v * b10;
          t22 += v * b11;
          t23 += v * b12;
          t24 += v * b13;
          t25 += v * b14;
          t26 += v * b15;
          v = a2[12];
          t12 += v * b0;
          t13 += v * b1;
          t14 += v * b22;
          t15 += v * b3;
          t16 += v * b4;
          t17 += v * b5;
          t18 += v * b6;
          t19 += v * b7;
          t20 += v * b8;
          t21 += v * b9;
          t22 += v * b10;
          t23 += v * b11;
          t24 += v * b12;
          t25 += v * b13;
          t26 += v * b14;
          t27 += v * b15;
          v = a2[13];
          t13 += v * b0;
          t14 += v * b1;
          t15 += v * b22;
          t16 += v * b3;
          t17 += v * b4;
          t18 += v * b5;
          t19 += v * b6;
          t20 += v * b7;
          t21 += v * b8;
          t22 += v * b9;
          t23 += v * b10;
          t24 += v * b11;
          t25 += v * b12;
          t26 += v * b13;
          t27 += v * b14;
          t28 += v * b15;
          v = a2[14];
          t14 += v * b0;
          t15 += v * b1;
          t16 += v * b22;
          t17 += v * b3;
          t18 += v * b4;
          t19 += v * b5;
          t20 += v * b6;
          t21 += v * b7;
          t22 += v * b8;
          t23 += v * b9;
          t24 += v * b10;
          t25 += v * b11;
          t26 += v * b12;
          t27 += v * b13;
          t28 += v * b14;
          t29 += v * b15;
          v = a2[15];
          t15 += v * b0;
          t16 += v * b1;
          t17 += v * b22;
          t18 += v * b3;
          t19 += v * b4;
          t20 += v * b5;
          t21 += v * b6;
          t22 += v * b7;
          t23 += v * b8;
          t24 += v * b9;
          t25 += v * b10;
          t26 += v * b11;
          t27 += v * b12;
          t28 += v * b13;
          t29 += v * b14;
          t30 += v * b15;
          t0 += 38 * t16;
          t1 += 38 * t17;
          t2 += 38 * t18;
          t3 += 38 * t19;
          t4 += 38 * t20;
          t5 += 38 * t21;
          t6 += 38 * t22;
          t7 += 38 * t23;
          t8 += 38 * t24;
          t9 += 38 * t25;
          t10 += 38 * t26;
          t11 += 38 * t27;
          t12 += 38 * t28;
          t13 += 38 * t29;
          t14 += 38 * t30;
          c2 = 1;
          v = t0 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t0 = v - c2 * 65536;
          v = t1 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t1 = v - c2 * 65536;
          v = t2 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t2 = v - c2 * 65536;
          v = t3 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t3 = v - c2 * 65536;
          v = t4 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t4 = v - c2 * 65536;
          v = t5 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t5 = v - c2 * 65536;
          v = t6 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t6 = v - c2 * 65536;
          v = t7 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t7 = v - c2 * 65536;
          v = t8 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t8 = v - c2 * 65536;
          v = t9 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t9 = v - c2 * 65536;
          v = t10 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t10 = v - c2 * 65536;
          v = t11 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t11 = v - c2 * 65536;
          v = t12 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t12 = v - c2 * 65536;
          v = t13 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t13 = v - c2 * 65536;
          v = t14 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t14 = v - c2 * 65536;
          v = t15 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t15 = v - c2 * 65536;
          t0 += c2 - 1 + 37 * (c2 - 1);
          c2 = 1;
          v = t0 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t0 = v - c2 * 65536;
          v = t1 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t1 = v - c2 * 65536;
          v = t2 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t2 = v - c2 * 65536;
          v = t3 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t3 = v - c2 * 65536;
          v = t4 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t4 = v - c2 * 65536;
          v = t5 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t5 = v - c2 * 65536;
          v = t6 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t6 = v - c2 * 65536;
          v = t7 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t7 = v - c2 * 65536;
          v = t8 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t8 = v - c2 * 65536;
          v = t9 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t9 = v - c2 * 65536;
          v = t10 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t10 = v - c2 * 65536;
          v = t11 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t11 = v - c2 * 65536;
          v = t12 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t12 = v - c2 * 65536;
          v = t13 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t13 = v - c2 * 65536;
          v = t14 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t14 = v - c2 * 65536;
          v = t15 + c2 + 65535;
          c2 = Math.floor(v / 65536);
          t15 = v - c2 * 65536;
          t0 += c2 - 1 + 37 * (c2 - 1);
          o[0] = t0;
          o[1] = t1;
          o[2] = t2;
          o[3] = t3;
          o[4] = t4;
          o[5] = t5;
          o[6] = t6;
          o[7] = t7;
          o[8] = t8;
          o[9] = t9;
          o[10] = t10;
          o[11] = t11;
          o[12] = t12;
          o[13] = t13;
          o[14] = t14;
          o[15] = t15;
        }
        function S(o, a2) {
          M(o, a2, a2);
        }
        function inv25519(o, i2) {
          var c2 = gf();
          var a2;
          for (a2 = 0; a2 < 16; a2++)
            c2[a2] = i2[a2];
          for (a2 = 253; a2 >= 0; a2--) {
            S(c2, c2);
            if (a2 !== 2 && a2 !== 4)
              M(c2, c2, i2);
          }
          for (a2 = 0; a2 < 16; a2++)
            o[a2] = c2[a2];
        }
        function pow2523(o, i2) {
          var c2 = gf();
          var a2;
          for (a2 = 0; a2 < 16; a2++)
            c2[a2] = i2[a2];
          for (a2 = 250; a2 >= 0; a2--) {
            S(c2, c2);
            if (a2 !== 1)
              M(c2, c2, i2);
          }
          for (a2 = 0; a2 < 16; a2++)
            o[a2] = c2[a2];
        }
        function crypto_scalarmult(q2, n, p) {
          var z = new Uint8Array(32);
          var x = new Float64Array(80), r, i2;
          var a2 = gf(), b2 = gf(), c2 = gf(), d2 = gf(), e = gf(), f = gf();
          for (i2 = 0; i2 < 31; i2++)
            z[i2] = n[i2];
          z[31] = n[31] & 127 | 64;
          z[0] &= 248;
          unpack25519(x, p);
          for (i2 = 0; i2 < 16; i2++) {
            b2[i2] = x[i2];
            d2[i2] = a2[i2] = c2[i2] = 0;
          }
          a2[0] = d2[0] = 1;
          for (i2 = 254; i2 >= 0; --i2) {
            r = z[i2 >>> 3] >>> (i2 & 7) & 1;
            sel25519(a2, b2, r);
            sel25519(c2, d2, r);
            A(e, a2, c2);
            Z(a2, a2, c2);
            A(c2, b2, d2);
            Z(b2, b2, d2);
            S(d2, e);
            S(f, a2);
            M(a2, c2, a2);
            M(c2, b2, e);
            A(e, a2, c2);
            Z(a2, a2, c2);
            S(b2, a2);
            Z(c2, d2, f);
            M(a2, c2, _121665);
            A(a2, a2, d2);
            M(c2, c2, a2);
            M(a2, d2, f);
            M(d2, b2, x);
            S(b2, e);
            sel25519(a2, b2, r);
            sel25519(c2, d2, r);
          }
          for (i2 = 0; i2 < 16; i2++) {
            x[i2 + 16] = a2[i2];
            x[i2 + 32] = c2[i2];
            x[i2 + 48] = b2[i2];
            x[i2 + 64] = d2[i2];
          }
          var x32 = x.subarray(32);
          var x16 = x.subarray(16);
          inv25519(x32, x32);
          M(x16, x16, x32);
          pack25519(q2, x16);
          return 0;
        }
        function crypto_scalarmult_base(q2, n) {
          return crypto_scalarmult(q2, n, _9);
        }
        function crypto_box_keypair(y, x) {
          randombytes(x, 32);
          return crypto_scalarmult_base(y, x);
        }
        function crypto_box_beforenm(k, y, x) {
          var s = new Uint8Array(32);
          crypto_scalarmult(s, x, y);
          return crypto_core_hsalsa20(k, _0, s, sigma);
        }
        var crypto_box_afternm = crypto_secretbox;
        var crypto_box_open_afternm = crypto_secretbox_open;
        function crypto_box(c2, m, d2, n, y, x) {
          var k = new Uint8Array(32);
          crypto_box_beforenm(k, y, x);
          return crypto_box_afternm(c2, m, d2, n, k);
        }
        function crypto_box_open(m, c2, d2, n, y, x) {
          var k = new Uint8Array(32);
          crypto_box_beforenm(k, y, x);
          return crypto_box_open_afternm(m, c2, d2, n, k);
        }
        var K = [
          1116352408,
          3609767458,
          1899447441,
          602891725,
          3049323471,
          3964484399,
          3921009573,
          2173295548,
          961987163,
          4081628472,
          1508970993,
          3053834265,
          2453635748,
          2937671579,
          2870763221,
          3664609560,
          3624381080,
          2734883394,
          310598401,
          1164996542,
          607225278,
          1323610764,
          1426881987,
          3590304994,
          1925078388,
          4068182383,
          2162078206,
          991336113,
          2614888103,
          633803317,
          3248222580,
          3479774868,
          3835390401,
          2666613458,
          4022224774,
          944711139,
          264347078,
          2341262773,
          604807628,
          2007800933,
          770255983,
          1495990901,
          1249150122,
          1856431235,
          1555081692,
          3175218132,
          1996064986,
          2198950837,
          2554220882,
          3999719339,
          2821834349,
          766784016,
          2952996808,
          2566594879,
          3210313671,
          3203337956,
          3336571891,
          1034457026,
          3584528711,
          2466948901,
          113926993,
          3758326383,
          338241895,
          168717936,
          666307205,
          1188179964,
          773529912,
          1546045734,
          1294757372,
          1522805485,
          1396182291,
          2643833823,
          1695183700,
          2343527390,
          1986661051,
          1014477480,
          2177026350,
          1206759142,
          2456956037,
          344077627,
          2730485921,
          1290863460,
          2820302411,
          3158454273,
          3259730800,
          3505952657,
          3345764771,
          106217008,
          3516065817,
          3606008344,
          3600352804,
          1432725776,
          4094571909,
          1467031594,
          275423344,
          851169720,
          430227734,
          3100823752,
          506948616,
          1363258195,
          659060556,
          3750685593,
          883997877,
          3785050280,
          958139571,
          3318307427,
          1322822218,
          3812723403,
          1537002063,
          2003034995,
          1747873779,
          3602036899,
          1955562222,
          1575990012,
          2024104815,
          1125592928,
          2227730452,
          2716904306,
          2361852424,
          442776044,
          2428436474,
          593698344,
          2756734187,
          3733110249,
          3204031479,
          2999351573,
          3329325298,
          3815920427,
          3391569614,
          3928383900,
          3515267271,
          566280711,
          3940187606,
          3454069534,
          4118630271,
          4000239992,
          116418474,
          1914138554,
          174292421,
          2731055270,
          289380356,
          3203993006,
          460393269,
          320620315,
          685471733,
          587496836,
          852142971,
          1086792851,
          1017036298,
          365543100,
          1126000580,
          2618297676,
          1288033470,
          3409855158,
          1501505948,
          4234509866,
          1607167915,
          987167468,
          1816402316,
          1246189591
        ];
        function crypto_hashblocks_hl(hh, hl, m, n) {
          var wh = new Int32Array(16), wl = new Int32Array(16), bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, th, tl, i2, j2, h, l, a2, b2, c2, d2;
          var ah0 = hh[0], ah1 = hh[1], ah2 = hh[2], ah3 = hh[3], ah4 = hh[4], ah5 = hh[5], ah6 = hh[6], ah7 = hh[7], al0 = hl[0], al1 = hl[1], al2 = hl[2], al3 = hl[3], al4 = hl[4], al5 = hl[5], al6 = hl[6], al7 = hl[7];
          var pos = 0;
          while (n >= 128) {
            for (i2 = 0; i2 < 16; i2++) {
              j2 = 8 * i2 + pos;
              wh[i2] = m[j2 + 0] << 24 | m[j2 + 1] << 16 | m[j2 + 2] << 8 | m[j2 + 3];
              wl[i2] = m[j2 + 4] << 24 | m[j2 + 5] << 16 | m[j2 + 6] << 8 | m[j2 + 7];
            }
            for (i2 = 0; i2 < 80; i2++) {
              bh0 = ah0;
              bh1 = ah1;
              bh2 = ah2;
              bh3 = ah3;
              bh4 = ah4;
              bh5 = ah5;
              bh6 = ah6;
              bh7 = ah7;
              bl0 = al0;
              bl1 = al1;
              bl2 = al2;
              bl3 = al3;
              bl4 = al4;
              bl5 = al5;
              bl6 = al6;
              bl7 = al7;
              h = ah7;
              l = al7;
              a2 = l & 65535;
              b2 = l >>> 16;
              c2 = h & 65535;
              d2 = h >>> 16;
              h = (ah4 >>> 14 | al4 << 32 - 14) ^ (ah4 >>> 18 | al4 << 32 - 18) ^ (al4 >>> 41 - 32 | ah4 << 32 - (41 - 32));
              l = (al4 >>> 14 | ah4 << 32 - 14) ^ (al4 >>> 18 | ah4 << 32 - 18) ^ (ah4 >>> 41 - 32 | al4 << 32 - (41 - 32));
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              h = ah4 & ah5 ^ ~ah4 & ah6;
              l = al4 & al5 ^ ~al4 & al6;
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              h = K[i2 * 2];
              l = K[i2 * 2 + 1];
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              h = wh[i2 % 16];
              l = wl[i2 % 16];
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              b2 += a2 >>> 16;
              c2 += b2 >>> 16;
              d2 += c2 >>> 16;
              th = c2 & 65535 | d2 << 16;
              tl = a2 & 65535 | b2 << 16;
              h = th;
              l = tl;
              a2 = l & 65535;
              b2 = l >>> 16;
              c2 = h & 65535;
              d2 = h >>> 16;
              h = (ah0 >>> 28 | al0 << 32 - 28) ^ (al0 >>> 34 - 32 | ah0 << 32 - (34 - 32)) ^ (al0 >>> 39 - 32 | ah0 << 32 - (39 - 32));
              l = (al0 >>> 28 | ah0 << 32 - 28) ^ (ah0 >>> 34 - 32 | al0 << 32 - (34 - 32)) ^ (ah0 >>> 39 - 32 | al0 << 32 - (39 - 32));
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              h = ah0 & ah1 ^ ah0 & ah2 ^ ah1 & ah2;
              l = al0 & al1 ^ al0 & al2 ^ al1 & al2;
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              b2 += a2 >>> 16;
              c2 += b2 >>> 16;
              d2 += c2 >>> 16;
              bh7 = c2 & 65535 | d2 << 16;
              bl7 = a2 & 65535 | b2 << 16;
              h = bh3;
              l = bl3;
              a2 = l & 65535;
              b2 = l >>> 16;
              c2 = h & 65535;
              d2 = h >>> 16;
              h = th;
              l = tl;
              a2 += l & 65535;
              b2 += l >>> 16;
              c2 += h & 65535;
              d2 += h >>> 16;
              b2 += a2 >>> 16;
              c2 += b2 >>> 16;
              d2 += c2 >>> 16;
              bh3 = c2 & 65535 | d2 << 16;
              bl3 = a2 & 65535 | b2 << 16;
              ah1 = bh0;
              ah2 = bh1;
              ah3 = bh2;
              ah4 = bh3;
              ah5 = bh4;
              ah6 = bh5;
              ah7 = bh6;
              ah0 = bh7;
              al1 = bl0;
              al2 = bl1;
              al3 = bl2;
              al4 = bl3;
              al5 = bl4;
              al6 = bl5;
              al7 = bl6;
              al0 = bl7;
              if (i2 % 16 === 15) {
                for (j2 = 0; j2 < 16; j2++) {
                  h = wh[j2];
                  l = wl[j2];
                  a2 = l & 65535;
                  b2 = l >>> 16;
                  c2 = h & 65535;
                  d2 = h >>> 16;
                  h = wh[(j2 + 9) % 16];
                  l = wl[(j2 + 9) % 16];
                  a2 += l & 65535;
                  b2 += l >>> 16;
                  c2 += h & 65535;
                  d2 += h >>> 16;
                  th = wh[(j2 + 1) % 16];
                  tl = wl[(j2 + 1) % 16];
                  h = (th >>> 1 | tl << 32 - 1) ^ (th >>> 8 | tl << 32 - 8) ^ th >>> 7;
                  l = (tl >>> 1 | th << 32 - 1) ^ (tl >>> 8 | th << 32 - 8) ^ (tl >>> 7 | th << 32 - 7);
                  a2 += l & 65535;
                  b2 += l >>> 16;
                  c2 += h & 65535;
                  d2 += h >>> 16;
                  th = wh[(j2 + 14) % 16];
                  tl = wl[(j2 + 14) % 16];
                  h = (th >>> 19 | tl << 32 - 19) ^ (tl >>> 61 - 32 | th << 32 - (61 - 32)) ^ th >>> 6;
                  l = (tl >>> 19 | th << 32 - 19) ^ (th >>> 61 - 32 | tl << 32 - (61 - 32)) ^ (tl >>> 6 | th << 32 - 6);
                  a2 += l & 65535;
                  b2 += l >>> 16;
                  c2 += h & 65535;
                  d2 += h >>> 16;
                  b2 += a2 >>> 16;
                  c2 += b2 >>> 16;
                  d2 += c2 >>> 16;
                  wh[j2] = c2 & 65535 | d2 << 16;
                  wl[j2] = a2 & 65535 | b2 << 16;
                }
              }
            }
            h = ah0;
            l = al0;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[0];
            l = hl[0];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[0] = ah0 = c2 & 65535 | d2 << 16;
            hl[0] = al0 = a2 & 65535 | b2 << 16;
            h = ah1;
            l = al1;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[1];
            l = hl[1];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[1] = ah1 = c2 & 65535 | d2 << 16;
            hl[1] = al1 = a2 & 65535 | b2 << 16;
            h = ah2;
            l = al2;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[2];
            l = hl[2];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[2] = ah2 = c2 & 65535 | d2 << 16;
            hl[2] = al2 = a2 & 65535 | b2 << 16;
            h = ah3;
            l = al3;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[3];
            l = hl[3];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[3] = ah3 = c2 & 65535 | d2 << 16;
            hl[3] = al3 = a2 & 65535 | b2 << 16;
            h = ah4;
            l = al4;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[4];
            l = hl[4];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[4] = ah4 = c2 & 65535 | d2 << 16;
            hl[4] = al4 = a2 & 65535 | b2 << 16;
            h = ah5;
            l = al5;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[5];
            l = hl[5];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[5] = ah5 = c2 & 65535 | d2 << 16;
            hl[5] = al5 = a2 & 65535 | b2 << 16;
            h = ah6;
            l = al6;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[6];
            l = hl[6];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[6] = ah6 = c2 & 65535 | d2 << 16;
            hl[6] = al6 = a2 & 65535 | b2 << 16;
            h = ah7;
            l = al7;
            a2 = l & 65535;
            b2 = l >>> 16;
            c2 = h & 65535;
            d2 = h >>> 16;
            h = hh[7];
            l = hl[7];
            a2 += l & 65535;
            b2 += l >>> 16;
            c2 += h & 65535;
            d2 += h >>> 16;
            b2 += a2 >>> 16;
            c2 += b2 >>> 16;
            d2 += c2 >>> 16;
            hh[7] = ah7 = c2 & 65535 | d2 << 16;
            hl[7] = al7 = a2 & 65535 | b2 << 16;
            pos += 128;
            n -= 128;
          }
          return n;
        }
        function crypto_hash(out, m, n) {
          var hh = new Int32Array(8), hl = new Int32Array(8), x = new Uint8Array(256), i2, b2 = n;
          hh[0] = 1779033703;
          hh[1] = 3144134277;
          hh[2] = 1013904242;
          hh[3] = 2773480762;
          hh[4] = 1359893119;
          hh[5] = 2600822924;
          hh[6] = 528734635;
          hh[7] = 1541459225;
          hl[0] = 4089235720;
          hl[1] = 2227873595;
          hl[2] = 4271175723;
          hl[3] = 1595750129;
          hl[4] = 2917565137;
          hl[5] = 725511199;
          hl[6] = 4215389547;
          hl[7] = 327033209;
          crypto_hashblocks_hl(hh, hl, m, n);
          n %= 128;
          for (i2 = 0; i2 < n; i2++)
            x[i2] = m[b2 - n + i2];
          x[n] = 128;
          n = 256 - 128 * (n < 112 ? 1 : 0);
          x[n - 9] = 0;
          ts64(x, n - 8, b2 / 536870912 | 0, b2 << 3);
          crypto_hashblocks_hl(hh, hl, x, n);
          for (i2 = 0; i2 < 8; i2++)
            ts64(out, 8 * i2, hh[i2], hl[i2]);
          return 0;
        }
        function add(p, q2) {
          var a2 = gf(), b2 = gf(), c2 = gf(), d2 = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
          Z(a2, p[1], p[0]);
          Z(t, q2[1], q2[0]);
          M(a2, a2, t);
          A(b2, p[0], p[1]);
          A(t, q2[0], q2[1]);
          M(b2, b2, t);
          M(c2, p[3], q2[3]);
          M(c2, c2, D2);
          M(d2, p[2], q2[2]);
          A(d2, d2, d2);
          Z(e, b2, a2);
          Z(f, d2, c2);
          A(g, d2, c2);
          A(h, b2, a2);
          M(p[0], e, f);
          M(p[1], h, g);
          M(p[2], g, f);
          M(p[3], e, h);
        }
        function cswap(p, q2, b2) {
          var i2;
          for (i2 = 0; i2 < 4; i2++) {
            sel25519(p[i2], q2[i2], b2);
          }
        }
        function pack(r, p) {
          var tx = gf(), ty = gf(), zi = gf();
          inv25519(zi, p[2]);
          M(tx, p[0], zi);
          M(ty, p[1], zi);
          pack25519(r, ty);
          r[31] ^= par25519(tx) << 7;
        }
        function scalarmult(p, q2, s) {
          var b2, i2;
          set25519(p[0], gf0);
          set25519(p[1], gf1);
          set25519(p[2], gf1);
          set25519(p[3], gf0);
          for (i2 = 255; i2 >= 0; --i2) {
            b2 = s[i2 / 8 | 0] >> (i2 & 7) & 1;
            cswap(p, q2, b2);
            add(q2, p);
            add(p, p);
            cswap(p, q2, b2);
          }
        }
        function scalarbase(p, s) {
          var q2 = [gf(), gf(), gf(), gf()];
          set25519(q2[0], X);
          set25519(q2[1], Y);
          set25519(q2[2], gf1);
          M(q2[3], X, Y);
          scalarmult(p, q2, s);
        }
        function crypto_sign_keypair(pk, sk, seeded) {
          var d2 = new Uint8Array(64);
          var p = [gf(), gf(), gf(), gf()];
          var i2;
          if (!seeded)
            randombytes(sk, 32);
          crypto_hash(d2, sk, 32);
          d2[0] &= 248;
          d2[31] &= 127;
          d2[31] |= 64;
          scalarbase(p, d2);
          pack(pk, p);
          for (i2 = 0; i2 < 32; i2++)
            sk[i2 + 32] = pk[i2];
          return 0;
        }
        var L = new Float64Array([237, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16]);
        function modL(r, x) {
          var carry, i2, j2, k;
          for (i2 = 63; i2 >= 32; --i2) {
            carry = 0;
            for (j2 = i2 - 32, k = i2 - 12; j2 < k; ++j2) {
              x[j2] += carry - 16 * x[i2] * L[j2 - (i2 - 32)];
              carry = x[j2] + 128 >> 8;
              x[j2] -= carry * 256;
            }
            x[j2] += carry;
            x[i2] = 0;
          }
          carry = 0;
          for (j2 = 0; j2 < 32; j2++) {
            x[j2] += carry - (x[31] >> 4) * L[j2];
            carry = x[j2] >> 8;
            x[j2] &= 255;
          }
          for (j2 = 0; j2 < 32; j2++)
            x[j2] -= carry * L[j2];
          for (i2 = 0; i2 < 32; i2++) {
            x[i2 + 1] += x[i2] >> 8;
            r[i2] = x[i2] & 255;
          }
        }
        function reduce(r) {
          var x = new Float64Array(64), i2;
          for (i2 = 0; i2 < 64; i2++)
            x[i2] = r[i2];
          for (i2 = 0; i2 < 64; i2++)
            r[i2] = 0;
          modL(r, x);
        }
        function crypto_sign(sm, m, n, sk) {
          var d2 = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
          var i2, j2, x = new Float64Array(64);
          var p = [gf(), gf(), gf(), gf()];
          crypto_hash(d2, sk, 32);
          d2[0] &= 248;
          d2[31] &= 127;
          d2[31] |= 64;
          var smlen = n + 64;
          for (i2 = 0; i2 < n; i2++)
            sm[64 + i2] = m[i2];
          for (i2 = 0; i2 < 32; i2++)
            sm[32 + i2] = d2[32 + i2];
          crypto_hash(r, sm.subarray(32), n + 32);
          reduce(r);
          scalarbase(p, r);
          pack(sm, p);
          for (i2 = 32; i2 < 64; i2++)
            sm[i2] = sk[i2];
          crypto_hash(h, sm, n + 64);
          reduce(h);
          for (i2 = 0; i2 < 64; i2++)
            x[i2] = 0;
          for (i2 = 0; i2 < 32; i2++)
            x[i2] = r[i2];
          for (i2 = 0; i2 < 32; i2++) {
            for (j2 = 0; j2 < 32; j2++) {
              x[i2 + j2] += h[i2] * d2[j2];
            }
          }
          modL(sm.subarray(32), x);
          return smlen;
        }
        function unpackneg(r, p) {
          var t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
          set25519(r[2], gf1);
          unpack25519(r[1], p);
          S(num, r[1]);
          M(den, num, D);
          Z(num, num, r[2]);
          A(den, r[2], den);
          S(den2, den);
          S(den4, den2);
          M(den6, den4, den2);
          M(t, den6, num);
          M(t, t, den);
          pow2523(t, t);
          M(t, t, num);
          M(t, t, den);
          M(t, t, den);
          M(r[0], t, den);
          S(chk, r[0]);
          M(chk, chk, den);
          if (neq25519(chk, num))
            M(r[0], r[0], I);
          S(chk, r[0]);
          M(chk, chk, den);
          if (neq25519(chk, num))
            return -1;
          if (par25519(r[0]) === p[31] >> 7)
            Z(r[0], gf0, r[0]);
          M(r[3], r[0], r[1]);
          return 0;
        }
        function crypto_sign_open(m, sm, n, pk) {
          var i2, mlen;
          var t = new Uint8Array(32), h = new Uint8Array(64);
          var p = [gf(), gf(), gf(), gf()], q2 = [gf(), gf(), gf(), gf()];
          mlen = -1;
          if (n < 64)
            return -1;
          if (unpackneg(q2, pk))
            return -1;
          for (i2 = 0; i2 < n; i2++)
            m[i2] = sm[i2];
          for (i2 = 0; i2 < 32; i2++)
            m[i2 + 32] = pk[i2];
          crypto_hash(h, m, n);
          reduce(h);
          scalarmult(p, q2, h);
          scalarbase(q2, sm.subarray(32));
          add(p, q2);
          pack(t, p);
          n -= 64;
          if (crypto_verify_32(sm, 0, t, 0)) {
            for (i2 = 0; i2 < n; i2++)
              m[i2] = 0;
            return -1;
          }
          for (i2 = 0; i2 < n; i2++)
            m[i2] = sm[i2 + 64];
          mlen = n;
          return mlen;
        }
        var crypto_secretbox_KEYBYTES = 32, crypto_secretbox_NONCEBYTES = 24, crypto_secretbox_ZEROBYTES = 32, crypto_secretbox_BOXZEROBYTES = 16, crypto_scalarmult_BYTES = 32, crypto_scalarmult_SCALARBYTES = 32, crypto_box_PUBLICKEYBYTES = 32, crypto_box_SECRETKEYBYTES = 32, crypto_box_BEFORENMBYTES = 32, crypto_box_NONCEBYTES = crypto_secretbox_NONCEBYTES, crypto_box_ZEROBYTES = crypto_secretbox_ZEROBYTES, crypto_box_BOXZEROBYTES = crypto_secretbox_BOXZEROBYTES, crypto_sign_BYTES = 64, crypto_sign_PUBLICKEYBYTES = 32, crypto_sign_SECRETKEYBYTES = 64, crypto_sign_SEEDBYTES = 32, crypto_hash_BYTES = 64;
        nacl.lowlevel = {
          crypto_core_hsalsa20,
          crypto_stream_xor,
          crypto_stream,
          crypto_stream_salsa20_xor,
          crypto_stream_salsa20,
          crypto_onetimeauth,
          crypto_onetimeauth_verify,
          crypto_verify_16,
          crypto_verify_32,
          crypto_secretbox,
          crypto_secretbox_open,
          crypto_scalarmult,
          crypto_scalarmult_base,
          crypto_box_beforenm,
          crypto_box_afternm,
          crypto_box,
          crypto_box_open,
          crypto_box_keypair,
          crypto_hash,
          crypto_sign,
          crypto_sign_keypair,
          crypto_sign_open,
          crypto_secretbox_KEYBYTES,
          crypto_secretbox_NONCEBYTES,
          crypto_secretbox_ZEROBYTES,
          crypto_secretbox_BOXZEROBYTES,
          crypto_scalarmult_BYTES,
          crypto_scalarmult_SCALARBYTES,
          crypto_box_PUBLICKEYBYTES,
          crypto_box_SECRETKEYBYTES,
          crypto_box_BEFORENMBYTES,
          crypto_box_NONCEBYTES,
          crypto_box_ZEROBYTES,
          crypto_box_BOXZEROBYTES,
          crypto_sign_BYTES,
          crypto_sign_PUBLICKEYBYTES,
          crypto_sign_SECRETKEYBYTES,
          crypto_sign_SEEDBYTES,
          crypto_hash_BYTES
        };
        function checkLengths(k, n) {
          if (k.length !== crypto_secretbox_KEYBYTES)
            throw new Error("bad key size");
          if (n.length !== crypto_secretbox_NONCEBYTES)
            throw new Error("bad nonce size");
        }
        function checkBoxLengths(pk, sk) {
          if (pk.length !== crypto_box_PUBLICKEYBYTES)
            throw new Error("bad public key size");
          if (sk.length !== crypto_box_SECRETKEYBYTES)
            throw new Error("bad secret key size");
        }
        function checkArrayTypes() {
          var t, i2;
          for (i2 = 0; i2 < arguments.length; i2++) {
            if ((t = Object.prototype.toString.call(arguments[i2])) !== "[object Uint8Array]")
              throw new TypeError("unexpected type " + t + ", use Uint8Array");
          }
        }
        function cleanup(arr) {
          for (var i2 = 0; i2 < arr.length; i2++)
            arr[i2] = 0;
        }
        if (!nacl.util) {
          nacl.util = {};
          nacl.util.decodeUTF8 = nacl.util.encodeUTF8 = nacl.util.encodeBase64 = nacl.util.decodeBase64 = function() {
            throw new Error("nacl.util moved into separate package: https://github.com/dchest/tweetnacl-util-js");
          };
        }
        nacl.randomBytes = function(n) {
          var b2 = new Uint8Array(n);
          randombytes(b2, n);
          return b2;
        };
        nacl.secretbox = function(msg, nonce, key2) {
          checkArrayTypes(msg, nonce, key2);
          checkLengths(key2, nonce);
          var m = new Uint8Array(crypto_secretbox_ZEROBYTES + msg.length);
          var c2 = new Uint8Array(m.length);
          for (var i2 = 0; i2 < msg.length; i2++)
            m[i2 + crypto_secretbox_ZEROBYTES] = msg[i2];
          crypto_secretbox(c2, m, m.length, nonce, key2);
          return c2.subarray(crypto_secretbox_BOXZEROBYTES);
        };
        nacl.secretbox.open = function(box, nonce, key2) {
          checkArrayTypes(box, nonce, key2);
          checkLengths(key2, nonce);
          var c2 = new Uint8Array(crypto_secretbox_BOXZEROBYTES + box.length);
          var m = new Uint8Array(c2.length);
          for (var i2 = 0; i2 < box.length; i2++)
            c2[i2 + crypto_secretbox_BOXZEROBYTES] = box[i2];
          if (c2.length < 32)
            return false;
          if (crypto_secretbox_open(m, c2, c2.length, nonce, key2) !== 0)
            return false;
          return m.subarray(crypto_secretbox_ZEROBYTES);
        };
        nacl.secretbox.keyLength = crypto_secretbox_KEYBYTES;
        nacl.secretbox.nonceLength = crypto_secretbox_NONCEBYTES;
        nacl.secretbox.overheadLength = crypto_secretbox_BOXZEROBYTES;
        nacl.scalarMult = function(n, p) {
          checkArrayTypes(n, p);
          if (n.length !== crypto_scalarmult_SCALARBYTES)
            throw new Error("bad n size");
          if (p.length !== crypto_scalarmult_BYTES)
            throw new Error("bad p size");
          var q2 = new Uint8Array(crypto_scalarmult_BYTES);
          crypto_scalarmult(q2, n, p);
          return q2;
        };
        nacl.scalarMult.base = function(n) {
          checkArrayTypes(n);
          if (n.length !== crypto_scalarmult_SCALARBYTES)
            throw new Error("bad n size");
          var q2 = new Uint8Array(crypto_scalarmult_BYTES);
          crypto_scalarmult_base(q2, n);
          return q2;
        };
        nacl.scalarMult.scalarLength = crypto_scalarmult_SCALARBYTES;
        nacl.scalarMult.groupElementLength = crypto_scalarmult_BYTES;
        nacl.box = function(msg, nonce, publicKey, secretKey) {
          var k = nacl.box.before(publicKey, secretKey);
          return nacl.secretbox(msg, nonce, k);
        };
        nacl.box.before = function(publicKey, secretKey) {
          checkArrayTypes(publicKey, secretKey);
          checkBoxLengths(publicKey, secretKey);
          var k = new Uint8Array(crypto_box_BEFORENMBYTES);
          crypto_box_beforenm(k, publicKey, secretKey);
          return k;
        };
        nacl.box.after = nacl.secretbox;
        nacl.box.open = function(msg, nonce, publicKey, secretKey) {
          var k = nacl.box.before(publicKey, secretKey);
          return nacl.secretbox.open(msg, nonce, k);
        };
        nacl.box.open.after = nacl.secretbox.open;
        nacl.box.keyPair = function() {
          var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
          var sk = new Uint8Array(crypto_box_SECRETKEYBYTES);
          crypto_box_keypair(pk, sk);
          return { publicKey: pk, secretKey: sk };
        };
        nacl.box.keyPair.fromSecretKey = function(secretKey) {
          checkArrayTypes(secretKey);
          if (secretKey.length !== crypto_box_SECRETKEYBYTES)
            throw new Error("bad secret key size");
          var pk = new Uint8Array(crypto_box_PUBLICKEYBYTES);
          crypto_scalarmult_base(pk, secretKey);
          return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
        };
        nacl.box.publicKeyLength = crypto_box_PUBLICKEYBYTES;
        nacl.box.secretKeyLength = crypto_box_SECRETKEYBYTES;
        nacl.box.sharedKeyLength = crypto_box_BEFORENMBYTES;
        nacl.box.nonceLength = crypto_box_NONCEBYTES;
        nacl.box.overheadLength = nacl.secretbox.overheadLength;
        nacl.sign = function(msg, secretKey) {
          checkArrayTypes(msg, secretKey);
          if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
            throw new Error("bad secret key size");
          var signedMsg = new Uint8Array(crypto_sign_BYTES + msg.length);
          crypto_sign(signedMsg, msg, msg.length, secretKey);
          return signedMsg;
        };
        nacl.sign.open = function(signedMsg, publicKey) {
          if (arguments.length !== 2)
            throw new Error("nacl.sign.open accepts 2 arguments; did you mean to use nacl.sign.detached.verify?");
          checkArrayTypes(signedMsg, publicKey);
          if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
            throw new Error("bad public key size");
          var tmp = new Uint8Array(signedMsg.length);
          var mlen = crypto_sign_open(tmp, signedMsg, signedMsg.length, publicKey);
          if (mlen < 0)
            return null;
          var m = new Uint8Array(mlen);
          for (var i2 = 0; i2 < m.length; i2++)
            m[i2] = tmp[i2];
          return m;
        };
        nacl.sign.detached = function(msg, secretKey) {
          var signedMsg = nacl.sign(msg, secretKey);
          var sig = new Uint8Array(crypto_sign_BYTES);
          for (var i2 = 0; i2 < sig.length; i2++)
            sig[i2] = signedMsg[i2];
          return sig;
        };
        nacl.sign.detached.verify = function(msg, sig, publicKey) {
          checkArrayTypes(msg, sig, publicKey);
          if (sig.length !== crypto_sign_BYTES)
            throw new Error("bad signature size");
          if (publicKey.length !== crypto_sign_PUBLICKEYBYTES)
            throw new Error("bad public key size");
          var sm = new Uint8Array(crypto_sign_BYTES + msg.length);
          var m = new Uint8Array(crypto_sign_BYTES + msg.length);
          var i2;
          for (i2 = 0; i2 < crypto_sign_BYTES; i2++)
            sm[i2] = sig[i2];
          for (i2 = 0; i2 < msg.length; i2++)
            sm[i2 + crypto_sign_BYTES] = msg[i2];
          return crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
        };
        nacl.sign.keyPair = function() {
          var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
          var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
          crypto_sign_keypair(pk, sk);
          return { publicKey: pk, secretKey: sk };
        };
        nacl.sign.keyPair.fromSecretKey = function(secretKey) {
          checkArrayTypes(secretKey);
          if (secretKey.length !== crypto_sign_SECRETKEYBYTES)
            throw new Error("bad secret key size");
          var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
          for (var i2 = 0; i2 < pk.length; i2++)
            pk[i2] = secretKey[32 + i2];
          return { publicKey: pk, secretKey: new Uint8Array(secretKey) };
        };
        nacl.sign.keyPair.fromSeed = function(seed) {
          checkArrayTypes(seed);
          if (seed.length !== crypto_sign_SEEDBYTES)
            throw new Error("bad seed size");
          var pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
          var sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
          for (var i2 = 0; i2 < 32; i2++)
            sk[i2] = seed[i2];
          crypto_sign_keypair(pk, sk, true);
          return { publicKey: pk, secretKey: sk };
        };
        nacl.sign.publicKeyLength = crypto_sign_PUBLICKEYBYTES;
        nacl.sign.secretKeyLength = crypto_sign_SECRETKEYBYTES;
        nacl.sign.seedLength = crypto_sign_SEEDBYTES;
        nacl.sign.signatureLength = crypto_sign_BYTES;
        nacl.hash = function(msg) {
          checkArrayTypes(msg);
          var h = new Uint8Array(crypto_hash_BYTES);
          crypto_hash(h, msg, msg.length);
          return h;
        };
        nacl.hash.hashLength = crypto_hash_BYTES;
        nacl.verify = function(x, y) {
          checkArrayTypes(x, y);
          if (x.length === 0 || y.length === 0)
            return false;
          if (x.length !== y.length)
            return false;
          return vn(x, 0, y, 0, x.length) === 0 ? true : false;
        };
        nacl.setPRNG = function(fn) {
          randombytes = fn;
        };
        (function() {
          var crypto2 = typeof self !== "undefined" ? self.crypto || self.msCrypto : null;
          if (crypto2 && crypto2.getRandomValues) {
            var QUOTA = 65536;
            nacl.setPRNG(function(x, n) {
              var i2, v = new Uint8Array(n);
              for (i2 = 0; i2 < n; i2 += QUOTA) {
                crypto2.getRandomValues(v.subarray(i2, i2 + Math.min(n - i2, QUOTA)));
              }
              for (i2 = 0; i2 < n; i2++)
                x[i2] = v[i2];
              cleanup(v);
            });
          } else if (typeof commonjsRequire !== "undefined") {
            crypto2 = require$$0$2;
            if (crypto2 && crypto2.randomBytes) {
              nacl.setPRNG(function(x, n) {
                var i2, v = crypto2.randomBytes(n);
                for (i2 = 0; i2 < n; i2++)
                  x[i2] = v[i2];
                cleanup(v);
              });
            }
          }
        })();
      })(module.exports ? module.exports : self.nacl = self.nacl || {});
    })(naclFast);
    return naclFast.exports;
  }
  var utils$2;
  var hasRequiredUtils$2;
  function requireUtils$2() {
    if (hasRequiredUtils$2)
      return utils$2;
    hasRequiredUtils$2 = 1;
    utils$2 = {
      bufferSplit,
      addRSAMissing,
      calculateDSAPublic,
      calculateED25519Public,
      calculateX25519Public,
      mpNormalize,
      mpDenormalize,
      ecNormalize,
      countZeros,
      assertCompatible,
      isCompatible,
      opensslKeyDeriv,
      opensshCipherInfo,
      publicFromPrivateECDSA,
      zeroPadToLength,
      writeBitString,
      readBitString,
      pbkdf2: pbkdf22
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var PrivateKey = requirePrivateKey();
    var Key = requireKey();
    var crypto2 = require$$0$2;
    var algs2 = requireAlgs();
    var asn1 = requireLib$4();
    var ec2 = requireEc();
    var jsbn2 = requireJsbn().BigInteger;
    var nacl = requireNaclFast();
    var MAX_CLASS_DEPTH = 3;
    function isCompatible(obj, klass, needVer) {
      if (obj === null || typeof obj !== "object")
        return false;
      if (needVer === void 0)
        needVer = klass.prototype._sshpkApiVersion;
      if (obj instanceof klass && klass.prototype._sshpkApiVersion[0] == needVer[0])
        return true;
      var proto = Object.getPrototypeOf(obj);
      var depth = 0;
      while (proto.constructor.name !== klass.name) {
        proto = Object.getPrototypeOf(proto);
        if (!proto || ++depth > MAX_CLASS_DEPTH)
          return false;
      }
      if (proto.constructor.name !== klass.name)
        return false;
      var ver = proto._sshpkApiVersion;
      if (ver === void 0)
        ver = klass._oldVersionDetect(obj);
      if (ver[0] != needVer[0] || ver[1] < needVer[1])
        return false;
      return true;
    }
    function assertCompatible(obj, klass, needVer, name) {
      if (name === void 0)
        name = "object";
      assert.ok(obj, name + " must not be null");
      assert.object(obj, name + " must be an object");
      if (needVer === void 0)
        needVer = klass.prototype._sshpkApiVersion;
      if (obj instanceof klass && klass.prototype._sshpkApiVersion[0] == needVer[0])
        return;
      var proto = Object.getPrototypeOf(obj);
      var depth = 0;
      while (proto.constructor.name !== klass.name) {
        proto = Object.getPrototypeOf(proto);
        assert.ok(
          proto && ++depth <= MAX_CLASS_DEPTH,
          name + " must be a " + klass.name + " instance"
        );
      }
      assert.strictEqual(
        proto.constructor.name,
        klass.name,
        name + " must be a " + klass.name + " instance"
      );
      var ver = proto._sshpkApiVersion;
      if (ver === void 0)
        ver = klass._oldVersionDetect(obj);
      assert.ok(
        ver[0] == needVer[0] && ver[1] >= needVer[1],
        name + " must be compatible with " + klass.name + " klass version " + needVer[0] + "." + needVer[1]
      );
    }
    var CIPHER_LEN = {
      "des-ede3-cbc": { key: 24, iv: 8 },
      "aes-128-cbc": { key: 16, iv: 16 },
      "aes-256-cbc": { key: 32, iv: 16 }
    };
    var PKCS5_SALT_LEN = 8;
    function opensslKeyDeriv(cipher, salt, passphrase, count) {
      assert.buffer(salt, "salt");
      assert.buffer(passphrase, "passphrase");
      assert.number(count, "iteration count");
      var clen = CIPHER_LEN[cipher];
      assert.object(clen, "supported cipher");
      salt = salt.slice(0, PKCS5_SALT_LEN);
      var D, D_prev, bufs;
      var material = Buffer2.alloc(0);
      while (material.length < clen.key + clen.iv) {
        bufs = [];
        if (D_prev)
          bufs.push(D_prev);
        bufs.push(passphrase);
        bufs.push(salt);
        D = Buffer2.concat(bufs);
        for (var j2 = 0; j2 < count; ++j2)
          D = crypto2.createHash("md5").update(D).digest();
        material = Buffer2.concat([material, D]);
        D_prev = D;
      }
      return {
        key: material.slice(0, clen.key),
        iv: material.slice(clen.key, clen.key + clen.iv)
      };
    }
    function pbkdf22(hashAlg, salt, iterations, size, passphrase) {
      var hkey = Buffer2.alloc(salt.length + 4);
      salt.copy(hkey);
      var gen = 0, ts = [];
      var i2 = 1;
      while (gen < size) {
        var t = T(i2++);
        gen += t.length;
        ts.push(t);
      }
      return Buffer2.concat(ts).slice(0, size);
      function T(I) {
        hkey.writeUInt32BE(I, hkey.length - 4);
        var hmac2 = crypto2.createHmac(hashAlg, passphrase);
        hmac2.update(hkey);
        var Ti = hmac2.digest();
        var Uc = Ti;
        var c2 = 1;
        while (c2++ < iterations) {
          hmac2 = crypto2.createHmac(hashAlg, passphrase);
          hmac2.update(Uc);
          Uc = hmac2.digest();
          for (var x = 0; x < Ti.length; ++x)
            Ti[x] ^= Uc[x];
        }
        return Ti;
      }
    }
    function countZeros(buf) {
      var o = 0, obit = 8;
      while (o < buf.length) {
        var mask = 1 << obit;
        if ((buf[o] & mask) === mask)
          break;
        obit--;
        if (obit < 0) {
          o++;
          obit = 8;
        }
      }
      return o * 8 + (8 - obit) - 1;
    }
    function bufferSplit(buf, chr) {
      assert.buffer(buf);
      assert.string(chr);
      var parts = [];
      var lastPart = 0;
      var matches = 0;
      for (var i2 = 0; i2 < buf.length; ++i2) {
        if (buf[i2] === chr.charCodeAt(matches))
          ++matches;
        else if (buf[i2] === chr.charCodeAt(0))
          matches = 1;
        else
          matches = 0;
        if (matches >= chr.length) {
          var newPart = i2 + 1;
          parts.push(buf.slice(lastPart, newPart - matches));
          lastPart = newPart;
          matches = 0;
        }
      }
      if (lastPart <= buf.length)
        parts.push(buf.slice(lastPart, buf.length));
      return parts;
    }
    function ecNormalize(buf, addZero) {
      assert.buffer(buf);
      if (buf[0] === 0 && buf[1] === 4) {
        if (addZero)
          return buf;
        return buf.slice(1);
      } else if (buf[0] === 4) {
        if (!addZero)
          return buf;
      } else {
        while (buf[0] === 0)
          buf = buf.slice(1);
        if (buf[0] === 2 || buf[0] === 3)
          throw new Error("Compressed elliptic curve points are not supported");
        if (buf[0] !== 4)
          throw new Error("Not a valid elliptic curve point");
        if (!addZero)
          return buf;
      }
      var b2 = Buffer2.alloc(buf.length + 1);
      b2[0] = 0;
      buf.copy(b2, 1);
      return b2;
    }
    function readBitString(der, tag) {
      if (tag === void 0)
        tag = asn1.Ber.BitString;
      var buf = der.readString(tag, true);
      assert.strictEqual(buf[0], 0, "bit strings with unused bits are not supported (0x" + buf[0].toString(16) + ")");
      return buf.slice(1);
    }
    function writeBitString(der, buf, tag) {
      if (tag === void 0)
        tag = asn1.Ber.BitString;
      var b2 = Buffer2.alloc(buf.length + 1);
      b2[0] = 0;
      buf.copy(b2, 1);
      der.writeBuffer(b2, tag);
    }
    function mpNormalize(buf) {
      assert.buffer(buf);
      while (buf.length > 1 && buf[0] === 0 && (buf[1] & 128) === 0)
        buf = buf.slice(1);
      if ((buf[0] & 128) === 128) {
        var b2 = Buffer2.alloc(buf.length + 1);
        b2[0] = 0;
        buf.copy(b2, 1);
        buf = b2;
      }
      return buf;
    }
    function mpDenormalize(buf) {
      assert.buffer(buf);
      while (buf.length > 1 && buf[0] === 0)
        buf = buf.slice(1);
      return buf;
    }
    function zeroPadToLength(buf, len) {
      assert.buffer(buf);
      assert.number(len);
      while (buf.length > len) {
        assert.equal(buf[0], 0);
        buf = buf.slice(1);
      }
      while (buf.length < len) {
        var b2 = Buffer2.alloc(buf.length + 1);
        b2[0] = 0;
        buf.copy(b2, 1);
        buf = b2;
      }
      return buf;
    }
    function bigintToMpBuf(bigint) {
      var buf = Buffer2.from(bigint.toByteArray());
      buf = mpNormalize(buf);
      return buf;
    }
    function calculateDSAPublic(g, p, x) {
      assert.buffer(g);
      assert.buffer(p);
      assert.buffer(x);
      g = new jsbn2(g);
      p = new jsbn2(p);
      x = new jsbn2(x);
      var y = g.modPow(x, p);
      var ybuf = bigintToMpBuf(y);
      return ybuf;
    }
    function calculateED25519Public(k) {
      assert.buffer(k);
      var kp = nacl.sign.keyPair.fromSeed(new Uint8Array(k));
      return Buffer2.from(kp.publicKey);
    }
    function calculateX25519Public(k) {
      assert.buffer(k);
      var kp = nacl.box.keyPair.fromSeed(new Uint8Array(k));
      return Buffer2.from(kp.publicKey);
    }
    function addRSAMissing(key2) {
      assert.object(key2);
      assertCompatible(key2, PrivateKey, [1, 1]);
      var d2 = new jsbn2(key2.part.d.data);
      var buf;
      if (!key2.part.dmodp) {
        var p = new jsbn2(key2.part.p.data);
        var dmodp = d2.mod(p.subtract(1));
        buf = bigintToMpBuf(dmodp);
        key2.part.dmodp = { name: "dmodp", data: buf };
        key2.parts.push(key2.part.dmodp);
      }
      if (!key2.part.dmodq) {
        var q2 = new jsbn2(key2.part.q.data);
        var dmodq = d2.mod(q2.subtract(1));
        buf = bigintToMpBuf(dmodq);
        key2.part.dmodq = { name: "dmodq", data: buf };
        key2.parts.push(key2.part.dmodq);
      }
    }
    function publicFromPrivateECDSA(curveName, priv) {
      assert.string(curveName, "curveName");
      assert.buffer(priv);
      var params = algs2.curves[curveName];
      var p = new jsbn2(params.p);
      var a2 = new jsbn2(params.a);
      var b2 = new jsbn2(params.b);
      var curve = new ec2.ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex(params.G.toString("hex"));
      var d2 = new jsbn2(mpNormalize(priv));
      var pub = G.multiply(d2);
      pub = Buffer2.from(curve.encodePointHex(pub), "hex");
      var parts = [];
      parts.push({ name: "curve", data: Buffer2.from(curveName) });
      parts.push({ name: "Q", data: pub });
      var key2 = new Key({ type: "ecdsa", curve, parts });
      return key2;
    }
    function opensshCipherInfo(cipher) {
      var inf = {};
      switch (cipher) {
        case "3des-cbc":
          inf.keySize = 24;
          inf.blockSize = 8;
          inf.opensslName = "des-ede3-cbc";
          break;
        case "blowfish-cbc":
          inf.keySize = 16;
          inf.blockSize = 8;
          inf.opensslName = "bf-cbc";
          break;
        case "aes128-cbc":
        case "aes128-ctr":
        case "[email protected]":
          inf.keySize = 16;
          inf.blockSize = 16;
          inf.opensslName = "aes-128-" + cipher.slice(7, 10);
          break;
        case "aes192-cbc":
        case "aes192-ctr":
        case "[email protected]":
          inf.keySize = 24;
          inf.blockSize = 16;
          inf.opensslName = "aes-192-" + cipher.slice(7, 10);
          break;
        case "aes256-cbc":
        case "aes256-ctr":
        case "[email protected]":
          inf.keySize = 32;
          inf.blockSize = 16;
          inf.opensslName = "aes-256-" + cipher.slice(7, 10);
          break;
        default:
          throw new Error(
            'Unsupported openssl cipher "' + cipher + '"'
          );
      }
      return inf;
    }
    return utils$2;
  }
  var sshBuffer;
  var hasRequiredSshBuffer;
  function requireSshBuffer() {
    if (hasRequiredSshBuffer)
      return sshBuffer;
    hasRequiredSshBuffer = 1;
    sshBuffer = SSHBuffer;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    function SSHBuffer(opts) {
      assert.object(opts, "options");
      if (opts.buffer !== void 0)
        assert.buffer(opts.buffer, "options.buffer");
      this._size = opts.buffer ? opts.buffer.length : 1024;
      this._buffer = opts.buffer || Buffer2.alloc(this._size);
      this._offset = 0;
    }
    SSHBuffer.prototype.toBuffer = function() {
      return this._buffer.slice(0, this._offset);
    };
    SSHBuffer.prototype.atEnd = function() {
      return this._offset >= this._buffer.length;
    };
    SSHBuffer.prototype.remainder = function() {
      return this._buffer.slice(this._offset);
    };
    SSHBuffer.prototype.skip = function(n) {
      this._offset += n;
    };
    SSHBuffer.prototype.expand = function() {
      this._size *= 2;
      var buf = Buffer2.alloc(this._size);
      this._buffer.copy(buf, 0);
      this._buffer = buf;
    };
    SSHBuffer.prototype.readPart = function() {
      return { data: this.readBuffer() };
    };
    SSHBuffer.prototype.readBuffer = function() {
      var len = this._buffer.readUInt32BE(this._offset);
      this._offset += 4;
      assert.ok(
        this._offset + len <= this._buffer.length,
        "length out of bounds at +0x" + this._offset.toString(16) + " (data truncated?)"
      );
      var buf = this._buffer.slice(this._offset, this._offset + len);
      this._offset += len;
      return buf;
    };
    SSHBuffer.prototype.readString = function() {
      return this.readBuffer().toString();
    };
    SSHBuffer.prototype.readCString = function() {
      var offset = this._offset;
      while (offset < this._buffer.length && this._buffer[offset] !== 0)
        offset++;
      assert.ok(offset < this._buffer.length, "c string does not terminate");
      var str = this._buffer.slice(this._offset, offset).toString();
      this._offset = offset + 1;
      return str;
    };
    SSHBuffer.prototype.readInt = function() {
      var v = this._buffer.readUInt32BE(this._offset);
      this._offset += 4;
      return v;
    };
    SSHBuffer.prototype.readInt64 = function() {
      assert.ok(
        this._offset + 8 < this._buffer.length,
        "buffer not long enough to read Int64"
      );
      var v = this._buffer.slice(this._offset, this._offset + 8);
      this._offset += 8;
      return v;
    };
    SSHBuffer.prototype.readChar = function() {
      var v = this._buffer[this._offset++];
      return v;
    };
    SSHBuffer.prototype.writeBuffer = function(buf) {
      while (this._offset + 4 + buf.length > this._size)
        this.expand();
      this._buffer.writeUInt32BE(buf.length, this._offset);
      this._offset += 4;
      buf.copy(this._buffer, this._offset);
      this._offset += buf.length;
    };
    SSHBuffer.prototype.writeString = function(str) {
      this.writeBuffer(Buffer2.from(str, "utf8"));
    };
    SSHBuffer.prototype.writeCString = function(str) {
      while (this._offset + 1 + str.length > this._size)
        this.expand();
      this._buffer.write(str, this._offset);
      this._offset += str.length;
      this._buffer[this._offset++] = 0;
    };
    SSHBuffer.prototype.writeInt = function(v) {
      while (this._offset + 4 > this._size)
        this.expand();
      this._buffer.writeUInt32BE(v, this._offset);
      this._offset += 4;
    };
    SSHBuffer.prototype.writeInt64 = function(v) {
      assert.buffer(v, "value");
      if (v.length > 8) {
        var lead = v.slice(0, v.length - 8);
        for (var i2 = 0; i2 < lead.length; ++i2) {
          assert.strictEqual(
            lead[i2],
            0,
            "must fit in 64 bits of precision"
          );
        }
        v = v.slice(v.length - 8, v.length);
      }
      while (this._offset + 8 > this._size)
        this.expand();
      v.copy(this._buffer, this._offset);
      this._offset += 8;
    };
    SSHBuffer.prototype.writeChar = function(v) {
      while (this._offset + 1 > this._size)
        this.expand();
      this._buffer[this._offset++] = v;
    };
    SSHBuffer.prototype.writePart = function(p) {
      this.writeBuffer(p.data);
    };
    SSHBuffer.prototype.write = function(buf) {
      while (this._offset + buf.length > this._size)
        this.expand();
      buf.copy(this._buffer, this._offset);
      this._offset += buf.length;
    };
    return sshBuffer;
  }
  var signature;
  var hasRequiredSignature;
  function requireSignature() {
    if (hasRequiredSignature)
      return signature;
    hasRequiredSignature = 1;
    signature = Signature;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    requireAlgs();
    var errs = requireErrors$1();
    var utils2 = requireUtils$2();
    var asn1 = requireLib$4();
    var SSHBuffer = requireSshBuffer();
    var InvalidAlgorithmError = errs.InvalidAlgorithmError;
    var SignatureParseError = errs.SignatureParseError;
    function Signature(opts) {
      assert.object(opts, "options");
      assert.arrayOfObject(opts.parts, "options.parts");
      assert.string(opts.type, "options.type");
      var partLookup = {};
      for (var i2 = 0; i2 < opts.parts.length; ++i2) {
        var part = opts.parts[i2];
        partLookup[part.name] = part;
      }
      this.type = opts.type;
      this.hashAlgorithm = opts.hashAlgo;
      this.curve = opts.curve;
      this.parts = opts.parts;
      this.part = partLookup;
    }
    Signature.prototype.toBuffer = function(format2) {
      if (format2 === void 0)
        format2 = "asn1";
      assert.string(format2, "format");
      var buf;
      var stype = "ssh-" + this.type;
      switch (this.type) {
        case "rsa":
          switch (this.hashAlgorithm) {
            case "sha256":
              stype = "rsa-sha2-256";
              break;
            case "sha512":
              stype = "rsa-sha2-512";
              break;
            case "sha1":
            case void 0:
              break;
            default:
              throw new Error("SSH signature format does not support hash algorithm " + this.hashAlgorithm);
          }
          if (format2 === "ssh") {
            buf = new SSHBuffer({});
            buf.writeString(stype);
            buf.writePart(this.part.sig);
            return buf.toBuffer();
          } else {
            return this.part.sig.data;
          }
        case "ed25519":
          if (format2 === "ssh") {
            buf = new SSHBuffer({});
            buf.writeString(stype);
            buf.writePart(this.part.sig);
            return buf.toBuffer();
          } else {
            return this.part.sig.data;
          }
        case "dsa":
        case "ecdsa":
          var r, s;
          if (format2 === "asn1") {
            var der = new asn1.BerWriter();
            der.startSequence();
            r = utils2.mpNormalize(this.part.r.data);
            s = utils2.mpNormalize(this.part.s.data);
            der.writeBuffer(r, asn1.Ber.Integer);
            der.writeBuffer(s, asn1.Ber.Integer);
            der.endSequence();
            return der.buffer;
          } else if (format2 === "ssh" && this.type === "dsa") {
            buf = new SSHBuffer({});
            buf.writeString("ssh-dss");
            r = this.part.r.data;
            if (r.length > 20 && r[0] === 0)
              r = r.slice(1);
            s = this.part.s.data;
            if (s.length > 20 && s[0] === 0)
              s = s.slice(1);
            if (this.hashAlgorithm && this.hashAlgorithm !== "sha1" || r.length + s.length !== 40) {
              throw new Error("OpenSSH only supports DSA signatures with SHA1 hash");
            }
            buf.writeBuffer(Buffer2.concat([r, s]));
            return buf.toBuffer();
          } else if (format2 === "ssh" && this.type === "ecdsa") {
            var inner = new SSHBuffer({});
            r = this.part.r.data;
            inner.writeBuffer(r);
            inner.writePart(this.part.s);
            buf = new SSHBuffer({});
            var curve;
            if (r[0] === 0)
              r = r.slice(1);
            var sz = r.length * 8;
            if (sz === 256)
              curve = "nistp256";
            else if (sz === 384)
              curve = "nistp384";
            else if (sz === 528)
              curve = "nistp521";
            buf.writeString("ecdsa-sha2-" + curve);
            buf.writeBuffer(inner.toBuffer());
            return buf.toBuffer();
          }
          throw new Error("Invalid signature format");
        default:
          throw new Error("Invalid signature data");
      }
    };
    Signature.prototype.toString = function(format2) {
      assert.optionalString(format2, "format");
      return this.toBuffer(format2).toString("base64");
    };
    Signature.parse = function(data2, type2, format2) {
      if (typeof data2 === "string")
        data2 = Buffer2.from(data2, "base64");
      assert.buffer(data2, "data");
      assert.string(format2, "format");
      assert.string(type2, "type");
      var opts = {};
      opts.type = type2.toLowerCase();
      opts.parts = [];
      try {
        assert.ok(data2.length > 0, "signature must not be empty");
        switch (opts.type) {
          case "rsa":
            return parseOneNum(data2, type2, format2, opts);
          case "ed25519":
            return parseOneNum(data2, type2, format2, opts);
          case "dsa":
          case "ecdsa":
            if (format2 === "asn1")
              return parseDSAasn1(data2, type2, format2, opts);
            else if (opts.type === "dsa")
              return parseDSA(data2, type2, format2, opts);
            else
              return parseECDSA(data2, type2, format2, opts);
          default:
            throw new InvalidAlgorithmError(type2);
        }
      } catch (e) {
        if (e instanceof InvalidAlgorithmError)
          throw e;
        throw new SignatureParseError(type2, format2, e);
      }
    };
    function parseOneNum(data2, type2, format2, opts) {
      if (format2 === "ssh") {
        try {
          var buf = new SSHBuffer({ buffer: data2 });
          var head = buf.readString();
        } catch (e) {
        }
        if (buf !== void 0) {
          var msg = "SSH signature does not match expected type (expected " + type2 + ", got " + head + ")";
          switch (head) {
            case "ssh-rsa":
              assert.strictEqual(type2, "rsa", msg);
              opts.hashAlgo = "sha1";
              break;
            case "rsa-sha2-256":
              assert.strictEqual(type2, "rsa", msg);
              opts.hashAlgo = "sha256";
              break;
            case "rsa-sha2-512":
              assert.strictEqual(type2, "rsa", msg);
              opts.hashAlgo = "sha512";
              break;
            case "ssh-ed25519":
              assert.strictEqual(type2, "ed25519", msg);
              opts.hashAlgo = "sha512";
              break;
            default:
              throw new Error("Unknown SSH signature type: " + head);
          }
          var sig = buf.readPart();
          assert.ok(buf.atEnd(), "extra trailing bytes");
          sig.name = "sig";
          opts.parts.push(sig);
          return new Signature(opts);
        }
      }
      opts.parts.push({ name: "sig", data: data2 });
      return new Signature(opts);
    }
    function parseDSAasn1(data2, type2, format2, opts) {
      var der = new asn1.BerReader(data2);
      der.readSequence();
      var r = der.readString(asn1.Ber.Integer, true);
      var s = der.readString(asn1.Ber.Integer, true);
      opts.parts.push({ name: "r", data: utils2.mpNormalize(r) });
      opts.parts.push({ name: "s", data: utils2.mpNormalize(s) });
      return new Signature(opts);
    }
    function parseDSA(data2, type2, format2, opts) {
      if (data2.length != 40) {
        var buf = new SSHBuffer({ buffer: data2 });
        var d2 = buf.readBuffer();
        if (d2.toString("ascii") === "ssh-dss")
          d2 = buf.readBuffer();
        assert.ok(buf.atEnd(), "extra trailing bytes");
        assert.strictEqual(d2.length, 40, "invalid inner length");
        data2 = d2;
      }
      opts.parts.push({ name: "r", data: data2.slice(0, 20) });
      opts.parts.push({ name: "s", data: data2.slice(20, 40) });
      return new Signature(opts);
    }
    function parseECDSA(data2, type2, format2, opts) {
      var buf = new SSHBuffer({ buffer: data2 });
      var r, s;
      var inner = buf.readBuffer();
      var stype = inner.toString("ascii");
      if (stype.slice(0, 6) === "ecdsa-") {
        var parts = stype.split("-");
        assert.strictEqual(parts[0], "ecdsa");
        assert.strictEqual(parts[1], "sha2");
        opts.curve = parts[2];
        switch (opts.curve) {
          case "nistp256":
            opts.hashAlgo = "sha256";
            break;
          case "nistp384":
            opts.hashAlgo = "sha384";
            break;
          case "nistp521":
            opts.hashAlgo = "sha512";
            break;
          default:
            throw new Error("Unsupported ECDSA curve: " + opts.curve);
        }
        inner = buf.readBuffer();
        assert.ok(buf.atEnd(), "extra trailing bytes on outer");
        buf = new SSHBuffer({ buffer: inner });
        r = buf.readPart();
      } else {
        r = { data: inner };
      }
      s = buf.readPart();
      assert.ok(buf.atEnd(), "extra trailing bytes");
      r.name = "r";
      s.name = "s";
      opts.parts.push(r);
      opts.parts.push(s);
      return new Signature(opts);
    }
    Signature.isSignature = function(obj, ver) {
      return utils2.isCompatible(obj, Signature, ver);
    };
    Signature.prototype._sshpkApiVersion = [2, 1];
    Signature._oldVersionDetect = function(obj) {
      assert.func(obj.toBuffer);
      if (obj.hasOwnProperty("hashAlgorithm"))
        return [2, 0];
      return [1, 0];
    };
    return signature;
  }
  var eccJsbn = {};
  var sec;
  var hasRequiredSec;
  function requireSec() {
    if (hasRequiredSec)
      return sec;
    hasRequiredSec = 1;
    var BigInteger = requireJsbn().BigInteger;
    var ECCurveFp = requireEc().ECCurveFp;
    function X9ECParameters(curve, g, n, h) {
      this.curve = curve;
      this.g = g;
      this.n = n;
      this.h = h;
    }
    function x9getCurve() {
      return this.curve;
    }
    function x9getG() {
      return this.g;
    }
    function x9getN() {
      return this.n;
    }
    function x9getH() {
      return this.h;
    }
    X9ECParameters.prototype.getCurve = x9getCurve;
    X9ECParameters.prototype.getG = x9getG;
    X9ECParameters.prototype.getN = x9getN;
    X9ECParameters.prototype.getH = x9getH;
    function fromHex(s) {
      return new BigInteger(s, 16);
    }
    function secp128r1() {
      var p = fromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF");
      var a2 = fromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC");
      var b2 = fromHex("E87579C11079F43DD824993C2CEE5ED3");
      var n = fromHex("FFFFFFFE0000000075A30D1B9038A115");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("04161FF7528B899B2D0C28607CA52C5B86CF5AC8395BAFEB13C02DA292DDED7A83");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp160k1() {
      var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73");
      var a2 = BigInteger.ZERO;
      var b2 = fromHex("7");
      var n = fromHex("0100000000000000000001B8FA16DFAB9ACA16B6B3");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("043B4C382CE37AA192A4019E763036F4F5DD4D7EBB938CF935318FDCED6BC28286531733C3F03C4FEE");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp160r1() {
      var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF");
      var a2 = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC");
      var b2 = fromHex("1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45");
      var n = fromHex("0100000000000000000001F4C8F927AED3CA752257");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("044A96B5688EF573284664698968C38BB913CBFC8223A628553168947D59DCC912042351377AC5FB32");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp192k1() {
      var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37");
      var a2 = BigInteger.ZERO;
      var b2 = fromHex("3");
      var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("04DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp192r1() {
      var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF");
      var a2 = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
      var b2 = fromHex("64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1");
      var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("04188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF101207192B95FFC8DA78631011ED6B24CDD573F977A11E794811");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp224r1() {
      var p = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001");
      var a2 = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE");
      var b2 = fromHex("B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4");
      var n = fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("04B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34");
      return new X9ECParameters(curve, G, n, h);
    }
    function secp256r1() {
      var p = fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF");
      var a2 = fromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC");
      var b2 = fromHex("5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B");
      var n = fromHex("FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551");
      var h = BigInteger.ONE;
      var curve = new ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex("046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5");
      return new X9ECParameters(curve, G, n, h);
    }
    sec = {
      "secp128r1": secp128r1,
      "secp160k1": secp160k1,
      "secp160r1": secp160r1,
      "secp192k1": secp192k1,
      "secp192r1": secp192r1,
      "secp224r1": secp224r1,
      "secp256r1": secp256r1
    };
    return sec;
  }
  var hasRequiredEccJsbn;
  function requireEccJsbn() {
    if (hasRequiredEccJsbn)
      return eccJsbn;
    hasRequiredEccJsbn = 1;
    var crypto2 = require$$0$2;
    var BigInteger = requireJsbn().BigInteger;
    requireEc().ECPointFp;
    var Buffer2 = requireSafer().Buffer;
    eccJsbn.ECCurves = requireSec();
    function unstupid(hex, len) {
      return hex.length >= len ? hex : unstupid("0" + hex, len);
    }
    eccJsbn.ECKey = function(curve, key2, isPublic) {
      var priv;
      var c2 = curve();
      var n = c2.getN();
      var bytes = Math.floor(n.bitLength() / 8);
      if (key2) {
        if (isPublic) {
          var curve = c2.getCurve();
          this.P = curve.decodePointHex(key2.toString("hex"));
        } else {
          if (key2.length != bytes)
            return false;
          priv = new BigInteger(key2.toString("hex"), 16);
        }
      } else {
        var n1 = n.subtract(BigInteger.ONE);
        var r = new BigInteger(crypto2.randomBytes(n.bitLength()));
        priv = r.mod(n1).add(BigInteger.ONE);
        this.P = c2.getG().multiply(priv);
      }
      if (this.P) {
        this.PublicKey = Buffer2.from(c2.getCurve().encodeCompressedPointHex(this.P), "hex");
      }
      if (priv) {
        this.PrivateKey = Buffer2.from(unstupid(priv.toString(16), bytes * 2), "hex");
        this.deriveSharedSecret = function(key3) {
          if (!key3 || !key3.P)
            return false;
          var S = key3.P.multiply(priv);
          return Buffer2.from(unstupid(S.getX().toBigInteger().toString(16), bytes * 2), "hex");
        };
      }
    };
    return eccJsbn;
  }
  var dhe;
  var hasRequiredDhe;
  function requireDhe() {
    if (hasRequiredDhe)
      return dhe;
    hasRequiredDhe = 1;
    dhe = {
      DiffieHellman,
      generateECDSA,
      generateED25519
    };
    var assert = requireAssert();
    var crypto2 = require$$0$2;
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var utils2 = requireUtils$2();
    var nacl = requireNaclFast();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var CRYPTO_HAVE_ECDH = crypto2.createECDH !== void 0;
    requireEccJsbn();
    var ec2 = requireEc();
    var jsbn2 = requireJsbn().BigInteger;
    function DiffieHellman(key2) {
      utils2.assertCompatible(key2, Key, [1, 4], "key");
      this._isPriv = PrivateKey.isPrivateKey(key2, [1, 3]);
      this._algo = key2.type;
      this._curve = key2.curve;
      this._key = key2;
      if (key2.type === "dsa") {
        if (!CRYPTO_HAVE_ECDH) {
          throw new Error("Due to bugs in the node 0.10 crypto API, node 0.12.x or later is required to use DH");
        }
        this._dh = crypto2.createDiffieHellman(
          key2.part.p.data,
          void 0,
          key2.part.g.data,
          void 0
        );
        this._p = key2.part.p;
        this._g = key2.part.g;
        if (this._isPriv)
          this._dh.setPrivateKey(key2.part.x.data);
        this._dh.setPublicKey(key2.part.y.data);
      } else if (key2.type === "ecdsa") {
        if (!CRYPTO_HAVE_ECDH) {
          this._ecParams = new X9ECParameters(this._curve);
          if (this._isPriv) {
            this._priv = new ECPrivate(
              this._ecParams,
              key2.part.d.data
            );
          }
          return;
        }
        var curve = {
          "nistp256": "prime256v1",
          "nistp384": "secp384r1",
          "nistp521": "secp521r1"
        }[key2.curve];
        this._dh = crypto2.createECDH(curve);
        if (typeof this._dh !== "object" || typeof this._dh.setPrivateKey !== "function") {
          CRYPTO_HAVE_ECDH = false;
          DiffieHellman.call(this, key2);
          return;
        }
        if (this._isPriv)
          this._dh.setPrivateKey(key2.part.d.data);
        this._dh.setPublicKey(key2.part.Q.data);
      } else if (key2.type === "curve25519") {
        if (this._isPriv) {
          utils2.assertCompatible(key2, PrivateKey, [1, 5], "key");
          this._priv = key2.part.k.data;
        }
      } else {
        throw new Error("DH not supported for " + key2.type + " keys");
      }
    }
    DiffieHellman.prototype.getPublicKey = function() {
      if (this._isPriv)
        return this._key.toPublic();
      return this._key;
    };
    DiffieHellman.prototype.getPrivateKey = function() {
      if (this._isPriv)
        return this._key;
      else
        return void 0;
    };
    DiffieHellman.prototype.getKey = DiffieHellman.prototype.getPrivateKey;
    DiffieHellman.prototype._keyCheck = function(pk, isPub) {
      assert.object(pk, "key");
      if (!isPub)
        utils2.assertCompatible(pk, PrivateKey, [1, 3], "key");
      utils2.assertCompatible(pk, Key, [1, 4], "key");
      if (pk.type !== this._algo) {
        throw new Error("A " + pk.type + " key cannot be used in " + this._algo + " Diffie-Hellman");
      }
      if (pk.curve !== this._curve) {
        throw new Error("A key from the " + pk.curve + " curve cannot be used with a " + this._curve + " Diffie-Hellman");
      }
      if (pk.type === "dsa") {
        assert.deepEqual(
          pk.part.p,
          this._p,
          "DSA key prime does not match"
        );
        assert.deepEqual(
          pk.part.g,
          this._g,
          "DSA key generator does not match"
        );
      }
    };
    DiffieHellman.prototype.setKey = function(pk) {
      this._keyCheck(pk);
      if (pk.type === "dsa") {
        this._dh.setPrivateKey(pk.part.x.data);
        this._dh.setPublicKey(pk.part.y.data);
      } else if (pk.type === "ecdsa") {
        if (CRYPTO_HAVE_ECDH) {
          this._dh.setPrivateKey(pk.part.d.data);
          this._dh.setPublicKey(pk.part.Q.data);
        } else {
          this._priv = new ECPrivate(
            this._ecParams,
            pk.part.d.data
          );
        }
      } else if (pk.type === "curve25519") {
        var k = pk.part.k;
        if (!pk.part.k)
          k = pk.part.r;
        this._priv = k.data;
        if (this._priv[0] === 0)
          this._priv = this._priv.slice(1);
        this._priv = this._priv.slice(0, 32);
      }
      this._key = pk;
      this._isPriv = true;
    };
    DiffieHellman.prototype.setPrivateKey = DiffieHellman.prototype.setKey;
    DiffieHellman.prototype.computeSecret = function(otherpk) {
      this._keyCheck(otherpk, true);
      if (!this._isPriv)
        throw new Error("DH exchange has not been initialized with a private key yet");
      var pub;
      if (this._algo === "dsa") {
        return this._dh.computeSecret(
          otherpk.part.y.data
        );
      } else if (this._algo === "ecdsa") {
        if (CRYPTO_HAVE_ECDH) {
          return this._dh.computeSecret(
            otherpk.part.Q.data
          );
        } else {
          pub = new ECPublic(
            this._ecParams,
            otherpk.part.Q.data
          );
          return this._priv.deriveSharedSecret(pub);
        }
      } else if (this._algo === "curve25519") {
        pub = otherpk.part.A.data;
        while (pub[0] === 0 && pub.length > 32)
          pub = pub.slice(1);
        var priv = this._priv;
        assert.strictEqual(pub.length, 32);
        assert.strictEqual(priv.length, 32);
        var secret = nacl.box.before(
          new Uint8Array(pub),
          new Uint8Array(priv)
        );
        return Buffer2.from(secret);
      }
      throw new Error("Invalid algorithm: " + this._algo);
    };
    DiffieHellman.prototype.generateKey = function() {
      var parts = [];
      var priv, pub;
      if (this._algo === "dsa") {
        this._dh.generateKeys();
        parts.push({ name: "p", data: this._p.data });
        parts.push({ name: "q", data: this._key.part.q.data });
        parts.push({ name: "g", data: this._g.data });
        parts.push({ name: "y", data: this._dh.getPublicKey() });
        parts.push({ name: "x", data: this._dh.getPrivateKey() });
        this._key = new PrivateKey({
          type: "dsa",
          parts
        });
        this._isPriv = true;
        return this._key;
      } else if (this._algo === "ecdsa") {
        if (CRYPTO_HAVE_ECDH) {
          this._dh.generateKeys();
          parts.push({
            name: "curve",
            data: Buffer2.from(this._curve)
          });
          parts.push({ name: "Q", data: this._dh.getPublicKey() });
          parts.push({ name: "d", data: this._dh.getPrivateKey() });
          this._key = new PrivateKey({
            type: "ecdsa",
            curve: this._curve,
            parts
          });
          this._isPriv = true;
          return this._key;
        } else {
          var n = this._ecParams.getN();
          var r = new jsbn2(crypto2.randomBytes(n.bitLength()));
          var n1 = n.subtract(jsbn2.ONE);
          priv = r.mod(n1).add(jsbn2.ONE);
          pub = this._ecParams.getG().multiply(priv);
          priv = Buffer2.from(priv.toByteArray());
          pub = Buffer2.from(this._ecParams.getCurve().encodePointHex(pub), "hex");
          this._priv = new ECPrivate(this._ecParams, priv);
          parts.push({
            name: "curve",
            data: Buffer2.from(this._curve)
          });
          parts.push({ name: "Q", data: pub });
          parts.push({ name: "d", data: priv });
          this._key = new PrivateKey({
            type: "ecdsa",
            curve: this._curve,
            parts
          });
          this._isPriv = true;
          return this._key;
        }
      } else if (this._algo === "curve25519") {
        var pair = nacl.box.keyPair();
        priv = Buffer2.from(pair.secretKey);
        pub = Buffer2.from(pair.publicKey);
        priv = Buffer2.concat([priv, pub]);
        assert.strictEqual(priv.length, 64);
        assert.strictEqual(pub.length, 32);
        parts.push({ name: "A", data: pub });
        parts.push({ name: "k", data: priv });
        this._key = new PrivateKey({
          type: "curve25519",
          parts
        });
        this._isPriv = true;
        return this._key;
      }
      throw new Error("Invalid algorithm: " + this._algo);
    };
    DiffieHellman.prototype.generateKeys = DiffieHellman.prototype.generateKey;
    function X9ECParameters(name) {
      var params = algs2.curves[name];
      assert.object(params);
      var p = new jsbn2(params.p);
      var a2 = new jsbn2(params.a);
      var b2 = new jsbn2(params.b);
      var n = new jsbn2(params.n);
      var h = jsbn2.ONE;
      var curve = new ec2.ECCurveFp(p, a2, b2);
      var G = curve.decodePointHex(params.G.toString("hex"));
      this.curve = curve;
      this.g = G;
      this.n = n;
      this.h = h;
    }
    X9ECParameters.prototype.getCurve = function() {
      return this.curve;
    };
    X9ECParameters.prototype.getG = function() {
      return this.g;
    };
    X9ECParameters.prototype.getN = function() {
      return this.n;
    };
    X9ECParameters.prototype.getH = function() {
      return this.h;
    };
    function ECPublic(params, buffer) {
      this._params = params;
      if (buffer[0] === 0)
        buffer = buffer.slice(1);
      this._pub = params.getCurve().decodePointHex(buffer.toString("hex"));
    }
    function ECPrivate(params, buffer) {
      this._params = params;
      this._priv = new jsbn2(utils2.mpNormalize(buffer));
    }
    ECPrivate.prototype.deriveSharedSecret = function(pubKey) {
      assert.ok(pubKey instanceof ECPublic);
      var S = pubKey._pub.multiply(this._priv);
      return Buffer2.from(S.getX().toBigInteger().toByteArray());
    };
    function generateED25519() {
      var pair = nacl.sign.keyPair();
      var priv = Buffer2.from(pair.secretKey);
      var pub = Buffer2.from(pair.publicKey);
      assert.strictEqual(priv.length, 64);
      assert.strictEqual(pub.length, 32);
      var parts = [];
      parts.push({ name: "A", data: pub });
      parts.push({ name: "k", data: priv.slice(0, 32) });
      var key2 = new PrivateKey({
        type: "ed25519",
        parts
      });
      return key2;
    }
    function generateECDSA(curve) {
      var parts = [];
      var key2;
      if (CRYPTO_HAVE_ECDH) {
        var osCurve = {
          "nistp256": "prime256v1",
          "nistp384": "secp384r1",
          "nistp521": "secp521r1"
        }[curve];
        var dh = crypto2.createECDH(osCurve);
        dh.generateKeys();
        parts.push({
          name: "curve",
          data: Buffer2.from(curve)
        });
        parts.push({ name: "Q", data: dh.getPublicKey() });
        parts.push({ name: "d", data: dh.getPrivateKey() });
        key2 = new PrivateKey({
          type: "ecdsa",
          curve,
          parts
        });
        return key2;
      } else {
        var ecParams = new X9ECParameters(curve);
        var n = ecParams.getN();
        var cByteLen = Math.ceil((n.bitLength() + 64) / 8);
        var c2 = new jsbn2(crypto2.randomBytes(cByteLen));
        var n1 = n.subtract(jsbn2.ONE);
        var priv = c2.mod(n1).add(jsbn2.ONE);
        var pub = ecParams.getG().multiply(priv);
        priv = Buffer2.from(priv.toByteArray());
        pub = Buffer2.from(ecParams.getCurve().encodePointHex(pub), "hex");
        parts.push({ name: "curve", data: Buffer2.from(curve) });
        parts.push({ name: "Q", data: pub });
        parts.push({ name: "d", data: priv });
        key2 = new PrivateKey({
          type: "ecdsa",
          curve,
          parts
        });
        return key2;
      }
    }
    return dhe;
  }
  var edCompat;
  var hasRequiredEdCompat;
  function requireEdCompat() {
    if (hasRequiredEdCompat)
      return edCompat;
    hasRequiredEdCompat = 1;
    edCompat = {
      Verifier,
      Signer
    };
    var nacl = requireNaclFast();
    var stream = require$$0$2;
    var util2 = require$$0$2;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var Signature = requireSignature();
    function Verifier(key2, hashAlgo) {
      if (hashAlgo.toLowerCase() !== "sha512")
        throw new Error("ED25519 only supports the use of SHA-512 hashes");
      this.key = key2;
      this.chunks = [];
      stream.Writable.call(this, {});
    }
    util2.inherits(Verifier, stream.Writable);
    Verifier.prototype._write = function(chunk, enc, cb) {
      this.chunks.push(chunk);
      cb();
    };
    Verifier.prototype.update = function(chunk) {
      if (typeof chunk === "string")
        chunk = Buffer2.from(chunk, "binary");
      this.chunks.push(chunk);
    };
    Verifier.prototype.verify = function(signature2, fmt) {
      var sig;
      if (Signature.isSignature(signature2, [2, 0])) {
        if (signature2.type !== "ed25519")
          return false;
        sig = signature2.toBuffer("raw");
      } else if (typeof signature2 === "string") {
        sig = Buffer2.from(signature2, "base64");
      } else if (Signature.isSignature(signature2, [1, 0])) {
        throw new Error("signature was created by too old a version of sshpk and cannot be verified");
      }
      assert.buffer(sig);
      return nacl.sign.detached.verify(
        new Uint8Array(Buffer2.concat(this.chunks)),
        new Uint8Array(sig),
        new Uint8Array(this.key.part.A.data)
      );
    };
    function Signer(key2, hashAlgo) {
      if (hashAlgo.toLowerCase() !== "sha512")
        throw new Error("ED25519 only supports the use of SHA-512 hashes");
      this.key = key2;
      this.chunks = [];
      stream.Writable.call(this, {});
    }
    util2.inherits(Signer, stream.Writable);
    Signer.prototype._write = function(chunk, enc, cb) {
      this.chunks.push(chunk);
      cb();
    };
    Signer.prototype.update = function(chunk) {
      if (typeof chunk === "string")
        chunk = Buffer2.from(chunk, "binary");
      this.chunks.push(chunk);
    };
    Signer.prototype.sign = function() {
      var sig = nacl.sign.detached(
        new Uint8Array(Buffer2.concat(this.chunks)),
        new Uint8Array(Buffer2.concat([
          this.key.part.k.data,
          this.key.part.A.data
        ]))
      );
      var sigBuf = Buffer2.from(sig);
      var sigObj = Signature.parse(sigBuf, "ed25519", "raw");
      sigObj.hashAlgorithm = "sha512";
      return sigObj;
    };
    return edCompat;
  }
  var pkcs8;
  var hasRequiredPkcs8;
  function requirePkcs8() {
    if (hasRequiredPkcs8)
      return pkcs8;
    hasRequiredPkcs8 = 1;
    pkcs8 = {
      read,
      readPkcs8,
      write,
      writePkcs8,
      pkcs8ToBuffer,
      readECDSACurve,
      writeECDSACurve
    };
    var assert = requireAssert();
    var asn1 = requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var utils2 = requireUtils$2();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var pem2 = requirePem();
    function read(buf, options) {
      return pem2.read(buf, options, "pkcs8");
    }
    function write(key2, options) {
      return pem2.write(key2, options, "pkcs8");
    }
    function readMPInt(der, nm) {
      assert.strictEqual(
        der.peek(),
        asn1.Ber.Integer,
        nm + " is not an Integer"
      );
      return utils2.mpNormalize(der.readString(asn1.Ber.Integer, true));
    }
    function readPkcs8(alg, type2, der) {
      if (der.peek() === asn1.Ber.Integer) {
        assert.strictEqual(
          type2,
          "private",
          "unexpected Integer at start of public key"
        );
        der.readString(asn1.Ber.Integer, true);
      }
      der.readSequence();
      var next = der.offset + der.length;
      var oid = der.readOID();
      switch (oid) {
        case "1.2.840.113549.1.1.1":
          der._offset = next;
          if (type2 === "public")
            return readPkcs8RSAPublic(der);
          else
            return readPkcs8RSAPrivate(der);
        case "1.2.840.10040.4.1":
          if (type2 === "public")
            return readPkcs8DSAPublic(der);
          else
            return readPkcs8DSAPrivate(der);
        case "1.2.840.10045.2.1":
          if (type2 === "public")
            return readPkcs8ECDSAPublic(der);
          else
            return readPkcs8ECDSAPrivate(der);
        case "1.3.101.112":
          if (type2 === "public") {
            return readPkcs8EdDSAPublic(der);
          } else {
            return readPkcs8EdDSAPrivate(der);
          }
        case "1.3.101.110":
          if (type2 === "public") {
            return readPkcs8X25519Public(der);
          } else {
            return readPkcs8X25519Private(der);
          }
        default:
          throw new Error("Unknown key type OID " + oid);
      }
    }
    function readPkcs8RSAPublic(der) {
      der.readSequence(asn1.Ber.BitString);
      der.readByte();
      der.readSequence();
      var n = readMPInt(der, "modulus");
      var e = readMPInt(der, "exponent");
      var key2 = {
        type: "rsa",
        source: der.originalInput,
        parts: [
          { name: "e", data: e },
          { name: "n", data: n }
        ]
      };
      return new Key(key2);
    }
    function readPkcs8RSAPrivate(der) {
      der.readSequence(asn1.Ber.OctetString);
      der.readSequence();
      var ver = readMPInt(der, "version");
      assert.equal(ver[0], 0, "unknown RSA private key version");
      var n = readMPInt(der, "modulus");
      var e = readMPInt(der, "public exponent");
      var d2 = readMPInt(der, "private exponent");
      var p = readMPInt(der, "prime1");
      var q2 = readMPInt(der, "prime2");
      var dmodp = readMPInt(der, "exponent1");
      var dmodq = readMPInt(der, "exponent2");
      var iqmp = readMPInt(der, "iqmp");
      var key2 = {
        type: "rsa",
        parts: [
          { name: "n", data: n },
          { name: "e", data: e },
          { name: "d", data: d2 },
          { name: "iqmp", data: iqmp },
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "dmodp", data: dmodp },
          { name: "dmodq", data: dmodq }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs8DSAPublic(der) {
      der.readSequence();
      var p = readMPInt(der, "p");
      var q2 = readMPInt(der, "q");
      var g = readMPInt(der, "g");
      der.readSequence(asn1.Ber.BitString);
      der.readByte();
      var y = readMPInt(der, "y");
      var key2 = {
        type: "dsa",
        parts: [
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "g", data: g },
          { name: "y", data: y }
        ]
      };
      return new Key(key2);
    }
    function readPkcs8DSAPrivate(der) {
      der.readSequence();
      var p = readMPInt(der, "p");
      var q2 = readMPInt(der, "q");
      var g = readMPInt(der, "g");
      der.readSequence(asn1.Ber.OctetString);
      var x = readMPInt(der, "x");
      var y = utils2.calculateDSAPublic(g, p, x);
      var key2 = {
        type: "dsa",
        parts: [
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "g", data: g },
          { name: "y", data: y },
          { name: "x", data: x }
        ]
      };
      return new PrivateKey(key2);
    }
    function readECDSACurve(der) {
      var curveName, curveNames;
      var j2, c2, cd;
      if (der.peek() === asn1.Ber.OID) {
        var oid = der.readOID();
        curveNames = Object.keys(algs2.curves);
        for (j2 = 0; j2 < curveNames.length; ++j2) {
          c2 = curveNames[j2];
          cd = algs2.curves[c2];
          if (cd.pkcs8oid === oid) {
            curveName = c2;
            break;
          }
        }
      } else {
        der.readSequence();
        var version2 = der.readString(asn1.Ber.Integer, true);
        assert.strictEqual(version2[0], 1, "ECDSA key not version 1");
        var curve = {};
        der.readSequence();
        var fieldTypeOid = der.readOID();
        assert.strictEqual(
          fieldTypeOid,
          "1.2.840.10045.1.1",
          "ECDSA key is not from a prime-field"
        );
        var p = curve.p = utils2.mpNormalize(
          der.readString(asn1.Ber.Integer, true)
        );
        curve.size = p.length * 8 - utils2.countZeros(p);
        der.readSequence();
        curve.a = utils2.mpNormalize(
          der.readString(asn1.Ber.OctetString, true)
        );
        curve.b = utils2.mpNormalize(
          der.readString(asn1.Ber.OctetString, true)
        );
        if (der.peek() === asn1.Ber.BitString)
          curve.s = der.readString(asn1.Ber.BitString, true);
        curve.G = der.readString(asn1.Ber.OctetString, true);
        assert.strictEqual(
          curve.G[0],
          4,
          "uncompressed G is required"
        );
        curve.n = utils2.mpNormalize(
          der.readString(asn1.Ber.Integer, true)
        );
        curve.h = utils2.mpNormalize(
          der.readString(asn1.Ber.Integer, true)
        );
        assert.strictEqual(curve.h[0], 1, "a cofactor=1 curve is required");
        curveNames = Object.keys(algs2.curves);
        var ks = Object.keys(curve);
        for (j2 = 0; j2 < curveNames.length; ++j2) {
          c2 = curveNames[j2];
          cd = algs2.curves[c2];
          var equal = true;
          for (var i2 = 0; i2 < ks.length; ++i2) {
            var k = ks[i2];
            if (cd[k] === void 0)
              continue;
            if (typeof cd[k] === "object" && cd[k].equals !== void 0) {
              if (!cd[k].equals(curve[k])) {
                equal = false;
                break;
              }
            } else if (Buffer2.isBuffer(cd[k])) {
              if (cd[k].toString("binary") !== curve[k].toString("binary")) {
                equal = false;
                break;
              }
            } else {
              if (cd[k] !== curve[k]) {
                equal = false;
                break;
              }
            }
          }
          if (equal) {
            curveName = c2;
            break;
          }
        }
      }
      return curveName;
    }
    function readPkcs8ECDSAPrivate(der) {
      var curveName = readECDSACurve(der);
      assert.string(curveName, "a known elliptic curve");
      der.readSequence(asn1.Ber.OctetString);
      der.readSequence();
      var version2 = readMPInt(der, "version");
      assert.equal(version2[0], 1, "unknown version of ECDSA key");
      var d2 = der.readString(asn1.Ber.OctetString, true);
      var Q;
      if (der.peek() == 160) {
        der.readSequence(160);
        der._offset += der.length;
      }
      if (der.peek() == 161) {
        der.readSequence(161);
        Q = der.readString(asn1.Ber.BitString, true);
        Q = utils2.ecNormalize(Q);
      }
      if (Q === void 0) {
        var pub = utils2.publicFromPrivateECDSA(curveName, d2);
        Q = pub.part.Q.data;
      }
      var key2 = {
        type: "ecdsa",
        parts: [
          { name: "curve", data: Buffer2.from(curveName) },
          { name: "Q", data: Q },
          { name: "d", data: d2 }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs8ECDSAPublic(der) {
      var curveName = readECDSACurve(der);
      assert.string(curveName, "a known elliptic curve");
      var Q = der.readString(asn1.Ber.BitString, true);
      Q = utils2.ecNormalize(Q);
      var key2 = {
        type: "ecdsa",
        parts: [
          { name: "curve", data: Buffer2.from(curveName) },
          { name: "Q", data: Q }
        ]
      };
      return new Key(key2);
    }
    function readPkcs8EdDSAPublic(der) {
      if (der.peek() === 0)
        der.readByte();
      var A = utils2.readBitString(der);
      var key2 = {
        type: "ed25519",
        parts: [
          { name: "A", data: utils2.zeroPadToLength(A, 32) }
        ]
      };
      return new Key(key2);
    }
    function readPkcs8X25519Public(der) {
      var A = utils2.readBitString(der);
      var key2 = {
        type: "curve25519",
        parts: [
          { name: "A", data: utils2.zeroPadToLength(A, 32) }
        ]
      };
      return new Key(key2);
    }
    function readPkcs8EdDSAPrivate(der) {
      if (der.peek() === 0)
        der.readByte();
      der.readSequence(asn1.Ber.OctetString);
      var k = der.readString(asn1.Ber.OctetString, true);
      k = utils2.zeroPadToLength(k, 32);
      var A, tag;
      while ((tag = der.peek()) !== null) {
        if (tag === (asn1.Ber.Context | 1)) {
          A = utils2.readBitString(der, tag);
        } else {
          der.readSequence(tag);
          der._offset += der.length;
        }
      }
      if (A === void 0)
        A = utils2.calculateED25519Public(k);
      var key2 = {
        type: "ed25519",
        parts: [
          { name: "A", data: utils2.zeroPadToLength(A, 32) },
          { name: "k", data: utils2.zeroPadToLength(k, 32) }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs8X25519Private(der) {
      if (der.peek() === 0)
        der.readByte();
      der.readSequence(asn1.Ber.OctetString);
      var k = der.readString(asn1.Ber.OctetString, true);
      k = utils2.zeroPadToLength(k, 32);
      var A = utils2.calculateX25519Public(k);
      var key2 = {
        type: "curve25519",
        parts: [
          { name: "A", data: utils2.zeroPadToLength(A, 32) },
          { name: "k", data: utils2.zeroPadToLength(k, 32) }
        ]
      };
      return new PrivateKey(key2);
    }
    function pkcs8ToBuffer(key2) {
      var der = new asn1.BerWriter();
      writePkcs8(der, key2);
      return der.buffer;
    }
    function writePkcs8(der, key2) {
      der.startSequence();
      if (PrivateKey.isPrivateKey(key2)) {
        var version2 = 0;
        if (key2.type === "ed25519")
          version2 = 1;
        var vbuf = Buffer2.from([version2]);
        der.writeBuffer(vbuf, asn1.Ber.Integer);
      }
      der.startSequence();
      switch (key2.type) {
        case "rsa":
          der.writeOID("1.2.840.113549.1.1.1");
          if (PrivateKey.isPrivateKey(key2))
            writePkcs8RSAPrivate(key2, der);
          else
            writePkcs8RSAPublic(key2, der);
          break;
        case "dsa":
          der.writeOID("1.2.840.10040.4.1");
          if (PrivateKey.isPrivateKey(key2))
            writePkcs8DSAPrivate(key2, der);
          else
            writePkcs8DSAPublic(key2, der);
          break;
        case "ecdsa":
          der.writeOID("1.2.840.10045.2.1");
          if (PrivateKey.isPrivateKey(key2))
            writePkcs8ECDSAPrivate(key2, der);
          else
            writePkcs8ECDSAPublic(key2, der);
          break;
        case "ed25519":
          der.writeOID("1.3.101.112");
          if (PrivateKey.isPrivateKey(key2))
            writePkcs8EdDSAPrivate(key2, der);
          else
            writePkcs8EdDSAPublic(key2, der);
          break;
        default:
          throw new Error("Unsupported key type: " + key2.type);
      }
      der.endSequence();
    }
    function writePkcs8RSAPrivate(key2, der) {
      der.writeNull();
      der.endSequence();
      der.startSequence(asn1.Ber.OctetString);
      der.startSequence();
      var version2 = Buffer2.from([0]);
      der.writeBuffer(version2, asn1.Ber.Integer);
      der.writeBuffer(key2.part.n.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.e.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.d.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      if (!key2.part.dmodp || !key2.part.dmodq)
        utils2.addRSAMissing(key2);
      der.writeBuffer(key2.part.dmodp.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.dmodq.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.iqmp.data, asn1.Ber.Integer);
      der.endSequence();
      der.endSequence();
    }
    function writePkcs8RSAPublic(key2, der) {
      der.writeNull();
      der.endSequence();
      der.startSequence(asn1.Ber.BitString);
      der.writeByte(0);
      der.startSequence();
      der.writeBuffer(key2.part.n.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.e.data, asn1.Ber.Integer);
      der.endSequence();
      der.endSequence();
    }
    function writePkcs8DSAPrivate(key2, der) {
      der.startSequence();
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.g.data, asn1.Ber.Integer);
      der.endSequence();
      der.endSequence();
      der.startSequence(asn1.Ber.OctetString);
      der.writeBuffer(key2.part.x.data, asn1.Ber.Integer);
      der.endSequence();
    }
    function writePkcs8DSAPublic(key2, der) {
      der.startSequence();
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.g.data, asn1.Ber.Integer);
      der.endSequence();
      der.endSequence();
      der.startSequence(asn1.Ber.BitString);
      der.writeByte(0);
      der.writeBuffer(key2.part.y.data, asn1.Ber.Integer);
      der.endSequence();
    }
    function writeECDSACurve(key2, der) {
      var curve = algs2.curves[key2.curve];
      if (curve.pkcs8oid) {
        der.writeOID(curve.pkcs8oid);
      } else {
        der.startSequence();
        var version2 = Buffer2.from([1]);
        der.writeBuffer(version2, asn1.Ber.Integer);
        der.startSequence();
        der.writeOID("1.2.840.10045.1.1");
        der.writeBuffer(curve.p, asn1.Ber.Integer);
        der.endSequence();
        der.startSequence();
        var a2 = curve.p;
        if (a2[0] === 0)
          a2 = a2.slice(1);
        der.writeBuffer(a2, asn1.Ber.OctetString);
        der.writeBuffer(curve.b, asn1.Ber.OctetString);
        der.writeBuffer(curve.s, asn1.Ber.BitString);
        der.endSequence();
        der.writeBuffer(curve.G, asn1.Ber.OctetString);
        der.writeBuffer(curve.n, asn1.Ber.Integer);
        var h = curve.h;
        if (!h) {
          h = Buffer2.from([1]);
        }
        der.writeBuffer(h, asn1.Ber.Integer);
        der.endSequence();
      }
    }
    function writePkcs8ECDSAPublic(key2, der) {
      writeECDSACurve(key2, der);
      der.endSequence();
      var Q = utils2.ecNormalize(key2.part.Q.data, true);
      der.writeBuffer(Q, asn1.Ber.BitString);
    }
    function writePkcs8ECDSAPrivate(key2, der) {
      writeECDSACurve(key2, der);
      der.endSequence();
      der.startSequence(asn1.Ber.OctetString);
      der.startSequence();
      var version2 = Buffer2.from([1]);
      der.writeBuffer(version2, asn1.Ber.Integer);
      der.writeBuffer(key2.part.d.data, asn1.Ber.OctetString);
      der.startSequence(161);
      var Q = utils2.ecNormalize(key2.part.Q.data, true);
      der.writeBuffer(Q, asn1.Ber.BitString);
      der.endSequence();
      der.endSequence();
      der.endSequence();
    }
    function writePkcs8EdDSAPublic(key2, der) {
      der.endSequence();
      utils2.writeBitString(der, key2.part.A.data);
    }
    function writePkcs8EdDSAPrivate(key2, der) {
      der.endSequence();
      der.startSequence(asn1.Ber.OctetString);
      var k = utils2.mpNormalize(key2.part.k.data);
      while (k.length > 32 && k[0] === 0)
        k = k.slice(1);
      der.writeBuffer(k, asn1.Ber.OctetString);
      der.endSequence();
      utils2.writeBitString(der, key2.part.A.data, asn1.Ber.Context | 1);
    }
    return pkcs8;
  }
  var pkcs1;
  var hasRequiredPkcs1;
  function requirePkcs1() {
    if (hasRequiredPkcs1)
      return pkcs1;
    hasRequiredPkcs1 = 1;
    pkcs1 = {
      read,
      readPkcs1,
      write,
      writePkcs1
    };
    var assert = requireAssert();
    var asn1 = requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var utils2 = requireUtils$2();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var pem2 = requirePem();
    var pkcs82 = requirePkcs8();
    var readECDSACurve = pkcs82.readECDSACurve;
    function read(buf, options) {
      return pem2.read(buf, options, "pkcs1");
    }
    function write(key2, options) {
      return pem2.write(key2, options, "pkcs1");
    }
    function readMPInt(der, nm) {
      assert.strictEqual(
        der.peek(),
        asn1.Ber.Integer,
        nm + " is not an Integer"
      );
      return utils2.mpNormalize(der.readString(asn1.Ber.Integer, true));
    }
    function readPkcs1(alg, type2, der) {
      switch (alg) {
        case "RSA":
          if (type2 === "public")
            return readPkcs1RSAPublic(der);
          else if (type2 === "private")
            return readPkcs1RSAPrivate(der);
          throw new Error("Unknown key type: " + type2);
        case "DSA":
          if (type2 === "public")
            return readPkcs1DSAPublic(der);
          else if (type2 === "private")
            return readPkcs1DSAPrivate(der);
          throw new Error("Unknown key type: " + type2);
        case "EC":
        case "ECDSA":
          if (type2 === "private")
            return readPkcs1ECDSAPrivate(der);
          else if (type2 === "public")
            return readPkcs1ECDSAPublic(der);
          throw new Error("Unknown key type: " + type2);
        case "EDDSA":
        case "EdDSA":
          if (type2 === "private")
            return readPkcs1EdDSAPrivate(der);
          throw new Error(type2 + " keys not supported with EdDSA");
        default:
          throw new Error("Unknown key algo: " + alg);
      }
    }
    function readPkcs1RSAPublic(der) {
      var n = readMPInt(der, "modulus");
      var e = readMPInt(der, "exponent");
      var key2 = {
        type: "rsa",
        parts: [
          { name: "e", data: e },
          { name: "n", data: n }
        ]
      };
      return new Key(key2);
    }
    function readPkcs1RSAPrivate(der) {
      var version2 = readMPInt(der, "version");
      assert.strictEqual(version2[0], 0);
      var n = readMPInt(der, "modulus");
      var e = readMPInt(der, "public exponent");
      var d2 = readMPInt(der, "private exponent");
      var p = readMPInt(der, "prime1");
      var q2 = readMPInt(der, "prime2");
      var dmodp = readMPInt(der, "exponent1");
      var dmodq = readMPInt(der, "exponent2");
      var iqmp = readMPInt(der, "iqmp");
      var key2 = {
        type: "rsa",
        parts: [
          { name: "n", data: n },
          { name: "e", data: e },
          { name: "d", data: d2 },
          { name: "iqmp", data: iqmp },
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "dmodp", data: dmodp },
          { name: "dmodq", data: dmodq }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs1DSAPrivate(der) {
      var version2 = readMPInt(der, "version");
      assert.strictEqual(version2.readUInt8(0), 0);
      var p = readMPInt(der, "p");
      var q2 = readMPInt(der, "q");
      var g = readMPInt(der, "g");
      var y = readMPInt(der, "y");
      var x = readMPInt(der, "x");
      var key2 = {
        type: "dsa",
        parts: [
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "g", data: g },
          { name: "y", data: y },
          { name: "x", data: x }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs1EdDSAPrivate(der) {
      var version2 = readMPInt(der, "version");
      assert.strictEqual(version2.readUInt8(0), 1);
      var k = der.readString(asn1.Ber.OctetString, true);
      der.readSequence(160);
      var oid = der.readOID();
      assert.strictEqual(oid, "1.3.101.112", "the ed25519 curve identifier");
      der.readSequence(161);
      var A = utils2.readBitString(der);
      var key2 = {
        type: "ed25519",
        parts: [
          { name: "A", data: utils2.zeroPadToLength(A, 32) },
          { name: "k", data: k }
        ]
      };
      return new PrivateKey(key2);
    }
    function readPkcs1DSAPublic(der) {
      var y = readMPInt(der, "y");
      var p = readMPInt(der, "p");
      var q2 = readMPInt(der, "q");
      var g = readMPInt(der, "g");
      var key2 = {
        type: "dsa",
        parts: [
          { name: "y", data: y },
          { name: "p", data: p },
          { name: "q", data: q2 },
          { name: "g", data: g }
        ]
      };
      return new Key(key2);
    }
    function readPkcs1ECDSAPublic(der) {
      der.readSequence();
      var oid = der.readOID();
      assert.strictEqual(oid, "1.2.840.10045.2.1", "must be ecPublicKey");
      var curveOid = der.readOID();
      var curve;
      var curves = Object.keys(algs2.curves);
      for (var j2 = 0; j2 < curves.length; ++j2) {
        var c2 = curves[j2];
        var cd = algs2.curves[c2];
        if (cd.pkcs8oid === curveOid) {
          curve = c2;
          break;
        }
      }
      assert.string(curve, "a known ECDSA named curve");
      var Q = der.readString(asn1.Ber.BitString, true);
      Q = utils2.ecNormalize(Q);
      var key2 = {
        type: "ecdsa",
        parts: [
          { name: "curve", data: Buffer2.from(curve) },
          { name: "Q", data: Q }
        ]
      };
      return new Key(key2);
    }
    function readPkcs1ECDSAPrivate(der) {
      var version2 = readMPInt(der, "version");
      assert.strictEqual(version2.readUInt8(0), 1);
      var d2 = der.readString(asn1.Ber.OctetString, true);
      der.readSequence(160);
      var curve = readECDSACurve(der);
      assert.string(curve, "a known elliptic curve");
      der.readSequence(161);
      var Q = der.readString(asn1.Ber.BitString, true);
      Q = utils2.ecNormalize(Q);
      var key2 = {
        type: "ecdsa",
        parts: [
          { name: "curve", data: Buffer2.from(curve) },
          { name: "Q", data: Q },
          { name: "d", data: d2 }
        ]
      };
      return new PrivateKey(key2);
    }
    function writePkcs1(der, key2) {
      der.startSequence();
      switch (key2.type) {
        case "rsa":
          if (PrivateKey.isPrivateKey(key2))
            writePkcs1RSAPrivate(der, key2);
          else
            writePkcs1RSAPublic(der, key2);
          break;
        case "dsa":
          if (PrivateKey.isPrivateKey(key2))
            writePkcs1DSAPrivate(der, key2);
          else
            writePkcs1DSAPublic(der, key2);
          break;
        case "ecdsa":
          if (PrivateKey.isPrivateKey(key2))
            writePkcs1ECDSAPrivate(der, key2);
          else
            writePkcs1ECDSAPublic(der, key2);
          break;
        case "ed25519":
          if (PrivateKey.isPrivateKey(key2))
            writePkcs1EdDSAPrivate(der, key2);
          else
            writePkcs1EdDSAPublic();
          break;
        default:
          throw new Error("Unknown key algo: " + key2.type);
      }
      der.endSequence();
    }
    function writePkcs1RSAPublic(der, key2) {
      der.writeBuffer(key2.part.n.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.e.data, asn1.Ber.Integer);
    }
    function writePkcs1RSAPrivate(der, key2) {
      var ver = Buffer2.from([0]);
      der.writeBuffer(ver, asn1.Ber.Integer);
      der.writeBuffer(key2.part.n.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.e.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.d.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      if (!key2.part.dmodp || !key2.part.dmodq)
        utils2.addRSAMissing(key2);
      der.writeBuffer(key2.part.dmodp.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.dmodq.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.iqmp.data, asn1.Ber.Integer);
    }
    function writePkcs1DSAPrivate(der, key2) {
      var ver = Buffer2.from([0]);
      der.writeBuffer(ver, asn1.Ber.Integer);
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.g.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.y.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.x.data, asn1.Ber.Integer);
    }
    function writePkcs1DSAPublic(der, key2) {
      der.writeBuffer(key2.part.y.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.p.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.q.data, asn1.Ber.Integer);
      der.writeBuffer(key2.part.g.data, asn1.Ber.Integer);
    }
    function writePkcs1ECDSAPublic(der, key2) {
      der.startSequence();
      der.writeOID("1.2.840.10045.2.1");
      var curve = key2.part.curve.data.toString();
      var curveOid = algs2.curves[curve].pkcs8oid;
      assert.string(curveOid, "a known ECDSA named curve");
      der.writeOID(curveOid);
      der.endSequence();
      var Q = utils2.ecNormalize(key2.part.Q.data, true);
      der.writeBuffer(Q, asn1.Ber.BitString);
    }
    function writePkcs1ECDSAPrivate(der, key2) {
      var ver = Buffer2.from([1]);
      der.writeBuffer(ver, asn1.Ber.Integer);
      der.writeBuffer(key2.part.d.data, asn1.Ber.OctetString);
      der.startSequence(160);
      var curve = key2.part.curve.data.toString();
      var curveOid = algs2.curves[curve].pkcs8oid;
      assert.string(curveOid, "a known ECDSA named curve");
      der.writeOID(curveOid);
      der.endSequence();
      der.startSequence(161);
      var Q = utils2.ecNormalize(key2.part.Q.data, true);
      der.writeBuffer(Q, asn1.Ber.BitString);
      der.endSequence();
    }
    function writePkcs1EdDSAPrivate(der, key2) {
      var ver = Buffer2.from([1]);
      der.writeBuffer(ver, asn1.Ber.Integer);
      der.writeBuffer(key2.part.k.data, asn1.Ber.OctetString);
      der.startSequence(160);
      der.writeOID("1.3.101.112");
      der.endSequence();
      der.startSequence(161);
      utils2.writeBitString(der, key2.part.A.data);
      der.endSequence();
    }
    function writePkcs1EdDSAPublic(der, key2) {
      throw new Error("Public keys are not supported for EdDSA PKCS#1");
    }
    return pkcs1;
  }
  var rfc4253;
  var hasRequiredRfc4253;
  function requireRfc4253() {
    if (hasRequiredRfc4253)
      return rfc4253;
    hasRequiredRfc4253 = 1;
    rfc4253 = {
      read: read.bind(void 0, false, void 0),
      readType: read.bind(void 0, false),
      write,
      /* semi-private api, used by sshpk-agent */
      readPartial: read.bind(void 0, true),
      /* shared with ssh format */
      readInternal: read,
      keyTypeToAlg,
      algToKeyType
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var utils2 = requireUtils$2();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var SSHBuffer = requireSshBuffer();
    function algToKeyType(alg) {
      assert.string(alg);
      if (alg === "ssh-dss")
        return "dsa";
      else if (alg === "ssh-rsa")
        return "rsa";
      else if (alg === "ssh-ed25519")
        return "ed25519";
      else if (alg === "ssh-curve25519")
        return "curve25519";
      else if (alg.match(/^ecdsa-sha2-/))
        return "ecdsa";
      else
        throw new Error("Unknown algorithm " + alg);
    }
    function keyTypeToAlg(key2) {
      assert.object(key2);
      if (key2.type === "dsa")
        return "ssh-dss";
      else if (key2.type === "rsa")
        return "ssh-rsa";
      else if (key2.type === "ed25519")
        return "ssh-ed25519";
      else if (key2.type === "curve25519")
        return "ssh-curve25519";
      else if (key2.type === "ecdsa")
        return "ecdsa-sha2-" + key2.part.curve.data.toString();
      else
        throw new Error("Unknown key type " + key2.type);
    }
    function read(partial, type2, buf, options) {
      if (typeof buf === "string")
        buf = Buffer2.from(buf);
      assert.buffer(buf, "buf");
      var key2 = {};
      var parts = key2.parts = [];
      var sshbuf = new SSHBuffer({ buffer: buf });
      var alg = sshbuf.readString();
      assert.ok(!sshbuf.atEnd(), "key must have at least one part");
      key2.type = algToKeyType(alg);
      var partCount = algs2.info[key2.type].parts.length;
      if (type2 && type2 === "private")
        partCount = algs2.privInfo[key2.type].parts.length;
      while (!sshbuf.atEnd() && parts.length < partCount)
        parts.push(sshbuf.readPart());
      while (!partial && !sshbuf.atEnd())
        parts.push(sshbuf.readPart());
      assert.ok(
        parts.length >= 1,
        "key must have at least one part"
      );
      assert.ok(
        partial || sshbuf.atEnd(),
        "leftover bytes at end of key"
      );
      var Constructor = Key;
      var algInfo = algs2.info[key2.type];
      if (type2 === "private" || algInfo.parts.length !== parts.length) {
        algInfo = algs2.privInfo[key2.type];
        Constructor = PrivateKey;
      }
      assert.strictEqual(algInfo.parts.length, parts.length);
      if (key2.type === "ecdsa") {
        var res = /^ecdsa-sha2-(.+)$/.exec(alg);
        assert.ok(res !== null);
        assert.strictEqual(res[1], parts[0].data.toString());
      }
      var normalized = true;
      for (var i2 = 0; i2 < algInfo.parts.length; ++i2) {
        var p = parts[i2];
        p.name = algInfo.parts[i2];
        if (key2.type === "ed25519" && p.name === "k")
          p.data = p.data.slice(0, 32);
        if (p.name !== "curve" && algInfo.normalize !== false) {
          var nd;
          if (key2.type === "ed25519") {
            nd = utils2.zeroPadToLength(p.data, 32);
          } else {
            nd = utils2.mpNormalize(p.data);
          }
          if (nd.toString("binary") !== p.data.toString("binary")) {
            p.data = nd;
            normalized = false;
          }
        }
      }
      if (normalized)
        key2._rfc4253Cache = sshbuf.toBuffer();
      if (partial && typeof partial === "object") {
        partial.remainder = sshbuf.remainder();
        partial.consumed = sshbuf._offset;
      }
      return new Constructor(key2);
    }
    function write(key2, options) {
      assert.object(key2);
      var alg = keyTypeToAlg(key2);
      var i2;
      var algInfo = algs2.info[key2.type];
      if (PrivateKey.isPrivateKey(key2))
        algInfo = algs2.privInfo[key2.type];
      var parts = algInfo.parts;
      var buf = new SSHBuffer({});
      buf.writeString(alg);
      for (i2 = 0; i2 < parts.length; ++i2) {
        var data2 = key2.part[parts[i2]].data;
        if (algInfo.normalize !== false) {
          if (key2.type === "ed25519")
            data2 = utils2.zeroPadToLength(data2, 32);
          else
            data2 = utils2.mpNormalize(data2);
        }
        if (key2.type === "ed25519" && parts[i2] === "k")
          data2 = Buffer2.concat([data2, key2.part.A.data]);
        buf.writeBuffer(data2);
      }
      return buf.toBuffer();
    }
    return rfc4253;
  }
  var bcryptPbkdf;
  var hasRequiredBcryptPbkdf;
  function requireBcryptPbkdf() {
    if (hasRequiredBcryptPbkdf)
      return bcryptPbkdf;
    hasRequiredBcryptPbkdf = 1;
    var crypto_hash_sha512 = requireNaclFast().lowlevel.crypto_hash;
    var BLF_J = 0;
    var Blowfish = function() {
      this.S = [
        new Uint32Array([
          3509652390,
          2564797868,
          805139163,
          3491422135,
          3101798381,
          1780907670,
          3128725573,
          4046225305,
          614570311,
          3012652279,
          134345442,
          2240740374,
          1667834072,
          1901547113,
          2757295779,
          4103290238,
          227898511,
          1921955416,
          1904987480,
          2182433518,
          2069144605,
          3260701109,
          2620446009,
          720527379,
          3318853667,
          677414384,
          3393288472,
          3101374703,
          2390351024,
          1614419982,
          1822297739,
          2954791486,
          3608508353,
          3174124327,
          2024746970,
          1432378464,
          3864339955,
          2857741204,
          1464375394,
          1676153920,
          1439316330,
          715854006,
          3033291828,
          289532110,
          2706671279,
          2087905683,
          3018724369,
          1668267050,
          732546397,
          1947742710,
          3462151702,
          2609353502,
          2950085171,
          1814351708,
          2050118529,
          680887927,
          999245976,
          1800124847,
          3300911131,
          1713906067,
          1641548236,
          4213287313,
          1216130144,
          1575780402,
          4018429277,
          3917837745,
          3693486850,
          3949271944,
          596196993,
          3549867205,
          258830323,
          2213823033,
          772490370,
          2760122372,
          1774776394,
          2652871518,
          566650946,
          4142492826,
          1728879713,
          2882767088,
          1783734482,
          3629395816,
          2517608232,
          2874225571,
          1861159788,
          326777828,
          3124490320,
          2130389656,
          2716951837,
          967770486,
          1724537150,
          2185432712,
          2364442137,
          1164943284,
          2105845187,
          998989502,
          3765401048,
          2244026483,
          1075463327,
          1455516326,
          1322494562,
          910128902,
          469688178,
          1117454909,
          936433444,
          3490320968,
          3675253459,
          1240580251,
          122909385,
          2157517691,
          634681816,
          4142456567,
          3825094682,
          3061402683,
          2540495037,
          79693498,
          3249098678,
          1084186820,
          1583128258,
          426386531,
          1761308591,
          1047286709,
          322548459,
          995290223,
          1845252383,
          2603652396,
          3431023940,
          2942221577,
          3202600964,
          3727903485,
          1712269319,
          422464435,
          3234572375,
          1170764815,
          3523960633,
          3117677531,
          1434042557,
          442511882,
          3600875718,
          1076654713,
          1738483198,
          4213154764,
          2393238008,
          3677496056,
          1014306527,
          4251020053,
          793779912,
          2902807211,
          842905082,
          4246964064,
          1395751752,
          1040244610,
          2656851899,
          3396308128,
          445077038,
          3742853595,
          3577915638,
          679411651,
          2892444358,
          2354009459,
          1767581616,
          3150600392,
          3791627101,
          3102740896,
          284835224,
          4246832056,
          1258075500,
          768725851,
          2589189241,
          3069724005,
          3532540348,
          1274779536,
          3789419226,
          2764799539,
          1660621633,
          3471099624,
          4011903706,
          913787905,
          3497959166,
          737222580,
          2514213453,
          2928710040,
          3937242737,
          1804850592,
          3499020752,
          2949064160,
          2386320175,
          2390070455,
          2415321851,
          4061277028,
          2290661394,
          2416832540,
          1336762016,
          1754252060,
          3520065937,
          3014181293,
          791618072,
          3188594551,
          3933548030,
          2332172193,
          3852520463,
          3043980520,
          413987798,
          3465142937,
          3030929376,
          4245938359,
          2093235073,
          3534596313,
          375366246,
          2157278981,
          2479649556,
          555357303,
          3870105701,
          2008414854,
          3344188149,
          4221384143,
          3956125452,
          2067696032,
          3594591187,
          2921233993,
          2428461,
          544322398,
          577241275,
          1471733935,
          610547355,
          4027169054,
          1432588573,
          1507829418,
          2025931657,
          3646575487,
          545086370,
          48609733,
          2200306550,
          1653985193,
          298326376,
          1316178497,
          3007786442,
          2064951626,
          458293330,
          2589141269,
          3591329599,
          3164325604,
          727753846,
          2179363840,
          146436021,
          1461446943,
          4069977195,
          705550613,
          3059967265,
          3887724982,
          4281599278,
          3313849956,
          1404054877,
          2845806497,
          146425753,
          1854211946
        ]),
        new Uint32Array([
          1266315497,
          3048417604,
          3681880366,
          3289982499,
          290971e4,
          1235738493,
          2632868024,
          2414719590,
          3970600049,
          1771706367,
          1449415276,
          3266420449,
          422970021,
          1963543593,
          2690192192,
          3826793022,
          1062508698,
          1531092325,
          1804592342,
          2583117782,
          2714934279,
          4024971509,
          1294809318,
          4028980673,
          1289560198,
          2221992742,
          1669523910,
          35572830,
          157838143,
          1052438473,
          1016535060,
          1802137761,
          1753167236,
          1386275462,
          3080475397,
          2857371447,
          1040679964,
          2145300060,
          2390574316,
          1461121720,
          2956646967,
          4031777805,
          4028374788,
          33600511,
          2920084762,
          1018524850,
          629373528,
          3691585981,
          3515945977,
          2091462646,
          2486323059,
          586499841,
          988145025,
          935516892,
          3367335476,
          2599673255,
          2839830854,
          265290510,
          3972581182,
          2759138881,
          3795373465,
          1005194799,
          847297441,
          406762289,
          1314163512,
          1332590856,
          1866599683,
          4127851711,
          750260880,
          613907577,
          1450815602,
          3165620655,
          3734664991,
          3650291728,
          3012275730,
          3704569646,
          1427272223,
          778793252,
          1343938022,
          2676280711,
          2052605720,
          1946737175,
          3164576444,
          3914038668,
          3967478842,
          3682934266,
          1661551462,
          3294938066,
          4011595847,
          840292616,
          3712170807,
          616741398,
          312560963,
          711312465,
          1351876610,
          322626781,
          1910503582,
          271666773,
          2175563734,
          1594956187,
          70604529,
          3617834859,
          1007753275,
          1495573769,
          4069517037,
          2549218298,
          2663038764,
          504708206,
          2263041392,
          3941167025,
          2249088522,
          1514023603,
          1998579484,
          1312622330,
          694541497,
          2582060303,
          2151582166,
          1382467621,
          776784248,
          2618340202,
          3323268794,
          2497899128,
          2784771155,
          503983604,
          4076293799,
          907881277,
          423175695,
          432175456,
          1378068232,
          4145222326,
          3954048622,
          3938656102,
          3820766613,
          2793130115,
          2977904593,
          26017576,
          3274890735,
          3194772133,
          1700274565,
          1756076034,
          4006520079,
          3677328699,
          720338349,
          1533947780,
          354530856,
          688349552,
          3973924725,
          1637815568,
          332179504,
          3949051286,
          53804574,
          2852348879,
          3044236432,
          1282449977,
          3583942155,
          3416972820,
          4006381244,
          1617046695,
          2628476075,
          3002303598,
          1686838959,
          431878346,
          2686675385,
          1700445008,
          1080580658,
          1009431731,
          832498133,
          3223435511,
          2605976345,
          2271191193,
          2516031870,
          1648197032,
          4164389018,
          2548247927,
          300782431,
          375919233,
          238389289,
          3353747414,
          2531188641,
          2019080857,
          1475708069,
          455242339,
          2609103871,
          448939670,
          3451063019,
          1395535956,
          2413381860,
          1841049896,
          1491858159,
          885456874,
          4264095073,
          4001119347,
          1565136089,
          3898914787,
          1108368660,
          540939232,
          1173283510,
          2745871338,
          3681308437,
          4207628240,
          3343053890,
          4016749493,
          1699691293,
          1103962373,
          3625875870,
          2256883143,
          3830138730,
          1031889488,
          3479347698,
          1535977030,
          4236805024,
          3251091107,
          2132092099,
          1774941330,
          1199868427,
          1452454533,
          157007616,
          2904115357,
          342012276,
          595725824,
          1480756522,
          206960106,
          497939518,
          591360097,
          863170706,
          2375253569,
          3596610801,
          1814182875,
          2094937945,
          3421402208,
          1082520231,
          3463918190,
          2785509508,
          435703966,
          3908032597,
          1641649973,
          2842273706,
          3305899714,
          1510255612,
          2148256476,
          2655287854,
          3276092548,
          4258621189,
          236887753,
          3681803219,
          274041037,
          1734335097,
          3815195456,
          3317970021,
          1899903192,
          1026095262,
          4050517792,
          356393447,
          2410691914,
          3873677099,
          3682840055
        ]),
        new Uint32Array([
          3913112168,
          2491498743,
          4132185628,
          2489919796,
          1091903735,
          1979897079,
          3170134830,
          3567386728,
          3557303409,
          857797738,
          1136121015,
          1342202287,
          507115054,
          2535736646,
          337727348,
          3213592640,
          1301675037,
          2528481711,
          1895095763,
          1721773893,
          3216771564,
          62756741,
          2142006736,
          835421444,
          2531993523,
          1442658625,
          3659876326,
          2882144922,
          676362277,
          1392781812,
          170690266,
          3921047035,
          1759253602,
          3611846912,
          1745797284,
          664899054,
          1329594018,
          3901205900,
          3045908486,
          2062866102,
          2865634940,
          3543621612,
          3464012697,
          1080764994,
          553557557,
          3656615353,
          3996768171,
          991055499,
          499776247,
          1265440854,
          648242737,
          3940784050,
          980351604,
          3713745714,
          1749149687,
          3396870395,
          4211799374,
          3640570775,
          1161844396,
          3125318951,
          1431517754,
          545492359,
          4268468663,
          3499529547,
          1437099964,
          2702547544,
          3433638243,
          2581715763,
          2787789398,
          1060185593,
          1593081372,
          2418618748,
          4260947970,
          69676912,
          2159744348,
          86519011,
          2512459080,
          3838209314,
          1220612927,
          3339683548,
          133810670,
          1090789135,
          1078426020,
          1569222167,
          845107691,
          3583754449,
          4072456591,
          1091646820,
          628848692,
          1613405280,
          3757631651,
          526609435,
          236106946,
          48312990,
          2942717905,
          3402727701,
          1797494240,
          859738849,
          992217954,
          4005476642,
          2243076622,
          3870952857,
          3732016268,
          765654824,
          3490871365,
          2511836413,
          1685915746,
          3888969200,
          1414112111,
          2273134842,
          3281911079,
          4080962846,
          172450625,
          2569994100,
          980381355,
          4109958455,
          2819808352,
          2716589560,
          2568741196,
          3681446669,
          3329971472,
          1835478071,
          660984891,
          3704678404,
          4045999559,
          3422617507,
          3040415634,
          1762651403,
          1719377915,
          3470491036,
          2693910283,
          3642056355,
          3138596744,
          1364962596,
          2073328063,
          1983633131,
          926494387,
          3423689081,
          2150032023,
          4096667949,
          1749200295,
          3328846651,
          309677260,
          2016342300,
          1779581495,
          3079819751,
          111262694,
          1274766160,
          443224088,
          298511866,
          1025883608,
          3806446537,
          1145181785,
          168956806,
          3641502830,
          3584813610,
          1689216846,
          3666258015,
          3200248200,
          1692713982,
          2646376535,
          4042768518,
          1618508792,
          1610833997,
          3523052358,
          4130873264,
          2001055236,
          3610705100,
          2202168115,
          4028541809,
          2961195399,
          1006657119,
          2006996926,
          3186142756,
          1430667929,
          3210227297,
          1314452623,
          4074634658,
          4101304120,
          2273951170,
          1399257539,
          3367210612,
          3027628629,
          1190975929,
          2062231137,
          2333990788,
          2221543033,
          2438960610,
          1181637006,
          548689776,
          2362791313,
          3372408396,
          3104550113,
          3145860560,
          296247880,
          1970579870,
          3078560182,
          3769228297,
          1714227617,
          3291629107,
          3898220290,
          166772364,
          1251581989,
          493813264,
          448347421,
          195405023,
          2709975567,
          677966185,
          3703036547,
          1463355134,
          2715995803,
          1338867538,
          1343315457,
          2802222074,
          2684532164,
          233230375,
          2599980071,
          2000651841,
          3277868038,
          1638401717,
          4028070440,
          3237316320,
          6314154,
          819756386,
          300326615,
          590932579,
          1405279636,
          3267499572,
          3150704214,
          2428286686,
          3959192993,
          3461946742,
          1862657033,
          1266418056,
          963775037,
          2089974820,
          2263052895,
          1917689273,
          448879540,
          3550394620,
          3981727096,
          150775221,
          3627908307,
          1303187396,
          508620638,
          2975983352,
          2726630617,
          1817252668,
          1876281319,
          1457606340,
          908771278,
          3720792119,
          3617206836,
          2455994898,
          1729034894,
          1080033504
        ]),
        new Uint32Array([
          976866871,
          3556439503,
          2881648439,
          1522871579,
          1555064734,
          1336096578,
          3548522304,
          2579274686,
          3574697629,
          3205460757,
          3593280638,
          3338716283,
          3079412587,
          564236357,
          2993598910,
          1781952180,
          1464380207,
          3163844217,
          3332601554,
          1699332808,
          1393555694,
          1183702653,
          3581086237,
          1288719814,
          691649499,
          2847557200,
          2895455976,
          3193889540,
          2717570544,
          1781354906,
          1676643554,
          2592534050,
          3230253752,
          1126444790,
          2770207658,
          2633158820,
          2210423226,
          2615765581,
          2414155088,
          3127139286,
          673620729,
          2805611233,
          1269405062,
          4015350505,
          3341807571,
          4149409754,
          1057255273,
          2012875353,
          2162469141,
          2276492801,
          2601117357,
          993977747,
          3918593370,
          2654263191,
          753973209,
          36408145,
          2530585658,
          25011837,
          3520020182,
          2088578344,
          530523599,
          2918365339,
          1524020338,
          1518925132,
          3760827505,
          3759777254,
          1202760957,
          3985898139,
          3906192525,
          674977740,
          4174734889,
          2031300136,
          2019492241,
          3983892565,
          4153806404,
          3822280332,
          352677332,
          2297720250,
          60907813,
          90501309,
          3286998549,
          1016092578,
          2535922412,
          2839152426,
          457141659,
          509813237,
          4120667899,
          652014361,
          1966332200,
          2975202805,
          55981186,
          2327461051,
          676427537,
          3255491064,
          2882294119,
          3433927263,
          1307055953,
          942726286,
          933058658,
          2468411793,
          3933900994,
          4215176142,
          1361170020,
          2001714738,
          2830558078,
          3274259782,
          1222529897,
          1679025792,
          2729314320,
          3714953764,
          1770335741,
          151462246,
          3013232138,
          1682292957,
          1483529935,
          471910574,
          1539241949,
          458788160,
          3436315007,
          1807016891,
          3718408830,
          978976581,
          1043663428,
          3165965781,
          1927990952,
          4200891579,
          2372276910,
          3208408903,
          3533431907,
          1412390302,
          2931980059,
          4132332400,
          1947078029,
          3881505623,
          4168226417,
          2941484381,
          1077988104,
          1320477388,
          886195818,
          18198404,
          3786409e3,
          2509781533,
          112762804,
          3463356488,
          1866414978,
          891333506,
          18488651,
          661792760,
          1628790961,
          3885187036,
          3141171499,
          876946877,
          2693282273,
          1372485963,
          791857591,
          2686433993,
          3759982718,
          3167212022,
          3472953795,
          2716379847,
          445679433,
          3561995674,
          3504004811,
          3574258232,
          54117162,
          3331405415,
          2381918588,
          3769707343,
          4154350007,
          1140177722,
          4074052095,
          668550556,
          3214352940,
          367459370,
          261225585,
          2610173221,
          4209349473,
          3468074219,
          3265815641,
          314222801,
          3066103646,
          3808782860,
          282218597,
          3406013506,
          3773591054,
          379116347,
          1285071038,
          846784868,
          2669647154,
          3771962079,
          3550491691,
          2305946142,
          453669953,
          1268987020,
          3317592352,
          3279303384,
          3744833421,
          2610507566,
          3859509063,
          266596637,
          3847019092,
          517658769,
          3462560207,
          3443424879,
          370717030,
          4247526661,
          2224018117,
          4143653529,
          4112773975,
          2788324899,
          2477274417,
          1456262402,
          2901442914,
          1517677493,
          1846949527,
          2295493580,
          3734397586,
          2176403920,
          1280348187,
          1908823572,
          3871786941,
          846861322,
          1172426758,
          3287448474,
          3383383037,
          1655181056,
          3139813346,
          901632758,
          1897031941,
          2986607138,
          3066810236,
          3447102507,
          1393639104,
          373351379,
          950779232,
          625454576,
          3124240540,
          4148612726,
          2007998917,
          544563296,
          2244738638,
          2330496472,
          2058025392,
          1291430526,
          424198748,
          50039436,
          29584100,
          3605783033,
          2429876329,
          2791104160,
          1057563949,
          3255363231,
          3075367218,
          3463963227,
          1469046755,
          985887462
        ])
      ];
      this.P = new Uint32Array([
        608135816,
        2242054355,
        320440878,
        57701188,
        2752067618,
        698298832,
        137296536,
        3964562569,
        1160258022,
        953160567,
        3193202383,
        887688300,
        3232508343,
        3380367581,
        1065670069,
        3041331479,
        2450970073,
        2306472731
      ]);
    };
    function F(S, x8, i2) {
      return (S[0][x8[i2 + 3]] + S[1][x8[i2 + 2]] ^ S[2][x8[i2 + 1]]) + S[3][x8[i2]];
    }
    Blowfish.prototype.encipher = function(x, x8) {
      if (x8 === void 0) {
        x8 = new Uint8Array(x.buffer);
        if (x.byteOffset !== 0)
          x8 = x8.subarray(x.byteOffset);
      }
      x[0] ^= this.P[0];
      for (var i2 = 1; i2 < 16; i2 += 2) {
        x[1] ^= F(this.S, x8, 0) ^ this.P[i2];
        x[0] ^= F(this.S, x8, 4) ^ this.P[i2 + 1];
      }
      var t = x[0];
      x[0] = x[1] ^ this.P[17];
      x[1] = t;
    };
    Blowfish.prototype.decipher = function(x) {
      var x8 = new Uint8Array(x.buffer);
      if (x.byteOffset !== 0)
        x8 = x8.subarray(x.byteOffset);
      x[0] ^= this.P[17];
      for (var i2 = 16; i2 > 0; i2 -= 2) {
        x[1] ^= F(this.S, x8, 0) ^ this.P[i2];
        x[0] ^= F(this.S, x8, 4) ^ this.P[i2 - 1];
      }
      var t = x[0];
      x[0] = x[1] ^ this.P[0];
      x[1] = t;
    };
    function stream2word(data2, databytes) {
      var i2, temp = 0;
      for (i2 = 0; i2 < 4; i2++, BLF_J++) {
        if (BLF_J >= databytes)
          BLF_J = 0;
        temp = temp << 8 | data2[BLF_J];
      }
      return temp;
    }
    Blowfish.prototype.expand0state = function(key2, keybytes) {
      var d2 = new Uint32Array(2), i2, k;
      var d8 = new Uint8Array(d2.buffer);
      for (i2 = 0, BLF_J = 0; i2 < 18; i2++) {
        this.P[i2] ^= stream2word(key2, keybytes);
      }
      BLF_J = 0;
      for (i2 = 0; i2 < 18; i2 += 2) {
        this.encipher(d2, d8);
        this.P[i2] = d2[0];
        this.P[i2 + 1] = d2[1];
      }
      for (i2 = 0; i2 < 4; i2++) {
        for (k = 0; k < 256; k += 2) {
          this.encipher(d2, d8);
          this.S[i2][k] = d2[0];
          this.S[i2][k + 1] = d2[1];
        }
      }
    };
    Blowfish.prototype.expandstate = function(data2, databytes, key2, keybytes) {
      var d2 = new Uint32Array(2), i2, k;
      for (i2 = 0, BLF_J = 0; i2 < 18; i2++) {
        this.P[i2] ^= stream2word(key2, keybytes);
      }
      for (i2 = 0, BLF_J = 0; i2 < 18; i2 += 2) {
        d2[0] ^= stream2word(data2, databytes);
        d2[1] ^= stream2word(data2, databytes);
        this.encipher(d2);
        this.P[i2] = d2[0];
        this.P[i2 + 1] = d2[1];
      }
      for (i2 = 0; i2 < 4; i2++) {
        for (k = 0; k < 256; k += 2) {
          d2[0] ^= stream2word(data2, databytes);
          d2[1] ^= stream2word(data2, databytes);
          this.encipher(d2);
          this.S[i2][k] = d2[0];
          this.S[i2][k + 1] = d2[1];
        }
      }
      BLF_J = 0;
    };
    Blowfish.prototype.enc = function(data2, blocks) {
      for (var i2 = 0; i2 < blocks; i2++) {
        this.encipher(data2.subarray(i2 * 2));
      }
    };
    Blowfish.prototype.dec = function(data2, blocks) {
      for (var i2 = 0; i2 < blocks; i2++) {
        this.decipher(data2.subarray(i2 * 2));
      }
    };
    var BCRYPT_BLOCKS = 8, BCRYPT_HASHSIZE = 32;
    function bcrypt_hash(sha2pass, sha2salt, out) {
      var state = new Blowfish(), cdata = new Uint32Array(BCRYPT_BLOCKS), i2, ciphertext = new Uint8Array([
        79,
        120,
        121,
        99,
        104,
        114,
        111,
        109,
        97,
        116,
        105,
        99,
        66,
        108,
        111,
        119,
        102,
        105,
        115,
        104,
        83,
        119,
        97,
        116,
        68,
        121,
        110,
        97,
        109,
        105,
        116,
        101
      ]);
      state.expandstate(sha2salt, 64, sha2pass, 64);
      for (i2 = 0; i2 < 64; i2++) {
        state.expand0state(sha2salt, 64);
        state.expand0state(sha2pass, 64);
      }
      for (i2 = 0; i2 < BCRYPT_BLOCKS; i2++)
        cdata[i2] = stream2word(ciphertext, ciphertext.byteLength);
      for (i2 = 0; i2 < 64; i2++)
        state.enc(cdata, cdata.byteLength / 8);
      for (i2 = 0; i2 < BCRYPT_BLOCKS; i2++) {
        out[4 * i2 + 3] = cdata[i2] >>> 24;
        out[4 * i2 + 2] = cdata[i2] >>> 16;
        out[4 * i2 + 1] = cdata[i2] >>> 8;
        out[4 * i2 + 0] = cdata[i2];
      }
    }
    function bcrypt_pbkdf(pass, passlen, salt, saltlen, key2, keylen, rounds) {
      var sha2pass = new Uint8Array(64), sha2salt = new Uint8Array(64), out = new Uint8Array(BCRYPT_HASHSIZE), tmpout = new Uint8Array(BCRYPT_HASHSIZE), countsalt = new Uint8Array(saltlen + 4), i2, j2, amt, stride, dest, count, origkeylen = keylen;
      if (rounds < 1)
        return -1;
      if (passlen === 0 || saltlen === 0 || keylen === 0 || keylen > out.byteLength * out.byteLength || saltlen > 1 << 20)
        return -1;
      stride = Math.floor((keylen + out.byteLength - 1) / out.byteLength);
      amt = Math.floor((keylen + stride - 1) / stride);
      for (i2 = 0; i2 < saltlen; i2++)
        countsalt[i2] = salt[i2];
      crypto_hash_sha512(sha2pass, pass, passlen);
      for (count = 1; keylen > 0; count++) {
        countsalt[saltlen + 0] = count >>> 24;
        countsalt[saltlen + 1] = count >>> 16;
        countsalt[saltlen + 2] = count >>> 8;
        countsalt[saltlen + 3] = count;
        crypto_hash_sha512(sha2salt, countsalt, saltlen + 4);
        bcrypt_hash(sha2pass, sha2salt, tmpout);
        for (i2 = out.byteLength; i2--; )
          out[i2] = tmpout[i2];
        for (i2 = 1; i2 < rounds; i2++) {
          crypto_hash_sha512(sha2salt, tmpout, tmpout.byteLength);
          bcrypt_hash(sha2pass, sha2salt, tmpout);
          for (j2 = 0; j2 < out.byteLength; j2++)
            out[j2] ^= tmpout[j2];
        }
        amt = Math.min(amt, keylen);
        for (i2 = 0; i2 < amt; i2++) {
          dest = i2 * stride + (count - 1);
          if (dest >= origkeylen)
            break;
          key2[dest] = out[i2];
        }
        keylen -= i2;
      }
      return 0;
    }
    bcryptPbkdf = {
      BLOCKS: BCRYPT_BLOCKS,
      HASHSIZE: BCRYPT_HASHSIZE,
      hash: bcrypt_hash,
      pbkdf: bcrypt_pbkdf
    };
    return bcryptPbkdf;
  }
  var sshPrivate;
  var hasRequiredSshPrivate;
  function requireSshPrivate() {
    if (hasRequiredSshPrivate)
      return sshPrivate;
    hasRequiredSshPrivate = 1;
    sshPrivate = {
      read,
      readSSHPrivate,
      write
    };
    var assert = requireAssert();
    requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    requireAlgs();
    var utils2 = requireUtils$2();
    var crypto2 = require$$0$2;
    requireKey();
    var PrivateKey = requirePrivateKey();
    var pem2 = requirePem();
    var rfc42532 = requireRfc4253();
    var SSHBuffer = requireSshBuffer();
    var errors2 = requireErrors$1();
    var bcrypt;
    function read(buf, options) {
      return pem2.read(buf, options);
    }
    var MAGIC = "openssh-key-v1";
    function readSSHPrivate(type2, buf, options) {
      buf = new SSHBuffer({ buffer: buf });
      var magic = buf.readCString();
      assert.strictEqual(magic, MAGIC, "bad magic string");
      var cipher = buf.readString();
      var kdf = buf.readString();
      var kdfOpts = buf.readBuffer();
      var nkeys = buf.readInt();
      if (nkeys !== 1) {
        throw new Error("OpenSSH-format key file contains multiple keys: this is unsupported.");
      }
      var pubKey = buf.readBuffer();
      if (type2 === "public") {
        assert.ok(buf.atEnd(), "excess bytes left after key");
        return rfc42532.read(pubKey);
      }
      var privKeyBlob = buf.readBuffer();
      assert.ok(buf.atEnd(), "excess bytes left after key");
      var kdfOptsBuf = new SSHBuffer({ buffer: kdfOpts });
      switch (kdf) {
        case "none":
          if (cipher !== "none") {
            throw new Error('OpenSSH-format key uses KDF "none" but specifies a cipher other than "none"');
          }
          break;
        case "bcrypt":
          var salt = kdfOptsBuf.readBuffer();
          var rounds = kdfOptsBuf.readInt();
          var cinf = utils2.opensshCipherInfo(cipher);
          if (bcrypt === void 0) {
            bcrypt = requireBcryptPbkdf();
          }
          if (typeof options.passphrase === "string") {
            options.passphrase = Buffer2.from(
              options.passphrase,
              "utf-8"
            );
          }
          if (!Buffer2.isBuffer(options.passphrase)) {
            throw new errors2.KeyEncryptedError(
              options.filename,
              "OpenSSH"
            );
          }
          var pass = new Uint8Array(options.passphrase);
          var salti = new Uint8Array(salt);
          var out = new Uint8Array(cinf.keySize + cinf.blockSize);
          var res = bcrypt.pbkdf(
            pass,
            pass.length,
            salti,
            salti.length,
            out,
            out.length,
            rounds
          );
          if (res !== 0) {
            throw new Error("bcrypt_pbkdf function returned failure, parameters invalid");
          }
          out = Buffer2.from(out);
          var ckey = out.slice(0, cinf.keySize);
          var iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);
          var cipherStream = crypto2.createDecipheriv(
            cinf.opensslName,
            ckey,
            iv
          );
          cipherStream.setAutoPadding(false);
          var chunk, chunks = [];
          cipherStream.once("error", function(e) {
            if (e.toString().indexOf("bad decrypt") !== -1) {
              throw new Error("Incorrect passphrase supplied, could not decrypt key");
            }
            throw e;
          });
          cipherStream.write(privKeyBlob);
          cipherStream.end();
          while ((chunk = cipherStream.read()) !== null)
            chunks.push(chunk);
          privKeyBlob = Buffer2.concat(chunks);
          break;
        default:
          throw new Error(
            'OpenSSH-format key uses unknown KDF "' + kdf + '"'
          );
      }
      buf = new SSHBuffer({ buffer: privKeyBlob });
      var checkInt1 = buf.readInt();
      var checkInt2 = buf.readInt();
      if (checkInt1 !== checkInt2) {
        throw new Error("Incorrect passphrase supplied, could not decrypt key");
      }
      var ret = {};
      var key2 = rfc42532.readInternal(ret, "private", buf.remainder());
      buf.skip(ret.consumed);
      var comment2 = buf.readString();
      key2.comment = comment2;
      return key2;
    }
    function write(key2, options) {
      var pubKey;
      if (PrivateKey.isPrivateKey(key2))
        pubKey = key2.toPublic();
      else
        pubKey = key2;
      var cipher = "none";
      var kdf = "none";
      var kdfopts = Buffer2.alloc(0);
      var cinf = { blockSize: 8 };
      var passphrase;
      if (options !== void 0) {
        passphrase = options.passphrase;
        if (typeof passphrase === "string")
          passphrase = Buffer2.from(passphrase, "utf-8");
        if (passphrase !== void 0) {
          assert.buffer(passphrase, "options.passphrase");
          assert.optionalString(options.cipher, "options.cipher");
          cipher = options.cipher;
          if (cipher === void 0)
            cipher = "aes128-ctr";
          cinf = utils2.opensshCipherInfo(cipher);
          kdf = "bcrypt";
        }
      }
      var privBuf;
      if (PrivateKey.isPrivateKey(key2)) {
        privBuf = new SSHBuffer({});
        var checkInt = crypto2.randomBytes(4).readUInt32BE(0);
        privBuf.writeInt(checkInt);
        privBuf.writeInt(checkInt);
        privBuf.write(key2.toBuffer("rfc4253"));
        privBuf.writeString(key2.comment || "");
        var n = 1;
        while (privBuf._offset % cinf.blockSize !== 0)
          privBuf.writeChar(n++);
        privBuf = privBuf.toBuffer();
      }
      switch (kdf) {
        case "none":
          break;
        case "bcrypt":
          var salt = crypto2.randomBytes(16);
          var rounds = 16;
          var kdfssh = new SSHBuffer({});
          kdfssh.writeBuffer(salt);
          kdfssh.writeInt(rounds);
          kdfopts = kdfssh.toBuffer();
          if (bcrypt === void 0) {
            bcrypt = requireBcryptPbkdf();
          }
          var pass = new Uint8Array(passphrase);
          var salti = new Uint8Array(salt);
          var out = new Uint8Array(cinf.keySize + cinf.blockSize);
          var res = bcrypt.pbkdf(
            pass,
            pass.length,
            salti,
            salti.length,
            out,
            out.length,
            rounds
          );
          if (res !== 0) {
            throw new Error("bcrypt_pbkdf function returned failure, parameters invalid");
          }
          out = Buffer2.from(out);
          var ckey = out.slice(0, cinf.keySize);
          var iv = out.slice(cinf.keySize, cinf.keySize + cinf.blockSize);
          var cipherStream = crypto2.createCipheriv(
            cinf.opensslName,
            ckey,
            iv
          );
          cipherStream.setAutoPadding(false);
          var chunk, chunks = [];
          cipherStream.once("error", function(e) {
            throw e;
          });
          cipherStream.write(privBuf);
          cipherStream.end();
          while ((chunk = cipherStream.read()) !== null)
            chunks.push(chunk);
          privBuf = Buffer2.concat(chunks);
          break;
        default:
          throw new Error("Unsupported kdf " + kdf);
      }
      var buf = new SSHBuffer({});
      buf.writeCString(MAGIC);
      buf.writeString(cipher);
      buf.writeString(kdf);
      buf.writeBuffer(kdfopts);
      buf.writeInt(1);
      buf.writeBuffer(pubKey.toBuffer("rfc4253"));
      if (privBuf)
        buf.writeBuffer(privBuf);
      buf = buf.toBuffer();
      var header;
      if (PrivateKey.isPrivateKey(key2))
        header = "OPENSSH PRIVATE KEY";
      else
        header = "OPENSSH PUBLIC KEY";
      var tmp = buf.toString("base64");
      var len = tmp.length + tmp.length / 70 + 18 + 16 + header.length * 2 + 10;
      buf = Buffer2.alloc(len);
      var o = 0;
      o += buf.write("-----BEGIN " + header + "-----\n", o);
      for (var i2 = 0; i2 < tmp.length; ) {
        var limit = i2 + 70;
        if (limit > tmp.length)
          limit = tmp.length;
        o += buf.write(tmp.slice(i2, limit), o);
        buf[o++] = 10;
        i2 = limit;
      }
      o += buf.write("-----END " + header + "-----\n", o);
      return buf.slice(0, o);
    }
    return sshPrivate;
  }
  var pem;
  var hasRequiredPem;
  function requirePem() {
    if (hasRequiredPem)
      return pem;
    hasRequiredPem = 1;
    pem = {
      read,
      write
    };
    var assert = requireAssert();
    var asn1 = requireLib$4();
    var crypto2 = require$$0$2;
    var Buffer2 = requireSafer().Buffer;
    requireAlgs();
    var utils2 = requireUtils$2();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var pkcs12 = requirePkcs1();
    var pkcs82 = requirePkcs8();
    var sshpriv = requireSshPrivate();
    var rfc42532 = requireRfc4253();
    var errors2 = requireErrors$1();
    var OID_PBES2 = "1.2.840.113549.1.5.13";
    var OID_PBKDF2 = "1.2.840.113549.1.5.12";
    var OID_TO_CIPHER = {
      "1.2.840.113549.3.7": "3des-cbc",
      "2.16.840.1.101.3.4.1.2": "aes128-cbc",
      "2.16.840.1.101.3.4.1.42": "aes256-cbc"
    };
    Object.keys(OID_TO_CIPHER).forEach(function(k) {
    });
    var OID_TO_HASH = {
      "1.2.840.113549.2.7": "sha1",
      "1.2.840.113549.2.9": "sha256",
      "1.2.840.113549.2.11": "sha512"
    };
    Object.keys(OID_TO_HASH).forEach(function(k) {
    });
    function read(buf, options, forceType) {
      var input = buf;
      if (typeof buf !== "string") {
        assert.buffer(buf, "buf");
        buf = buf.toString("ascii");
      }
      var lines = buf.trim().split(/[\r\n]+/g);
      var m;
      var si = -1;
      while (!m && si < lines.length) {
        m = lines[++si].match(
          /*JSSTYLED*/
          /[-]+[ ]*BEGIN ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/
        );
      }
      assert.ok(m, "invalid PEM header");
      var m2;
      var ei = lines.length;
      while (!m2 && ei > 0) {
        m2 = lines[--ei].match(
          /*JSSTYLED*/
          /[-]+[ ]*END ([A-Z0-9][A-Za-z0-9]+ )?(PUBLIC|PRIVATE) KEY[ ]*[-]+/
        );
      }
      assert.ok(m2, "invalid PEM footer");
      assert.equal(m[2], m2[2]);
      var type2 = m[2].toLowerCase();
      var alg;
      if (m[1]) {
        assert.equal(m[1], m2[1], "PEM header and footer mismatch");
        alg = m[1].trim();
      }
      lines = lines.slice(si, ei + 1);
      var headers = {};
      while (true) {
        lines = lines.slice(1);
        m = lines[0].match(
          /*JSSTYLED*/
          /^([A-Za-z0-9-]+): (.+)$/
        );
        if (!m)
          break;
        headers[m[1].toLowerCase()] = m[2];
      }
      lines = lines.slice(0, -1).join("");
      buf = Buffer2.from(lines, "base64");
      var cipher, key2, iv;
      if (headers["proc-type"]) {
        var parts = headers["proc-type"].split(",");
        if (parts[0] === "4" && parts[1] === "ENCRYPTED") {
          if (typeof options.passphrase === "string") {
            options.passphrase = Buffer2.from(
              options.passphrase,
              "utf-8"
            );
          }
          if (!Buffer2.isBuffer(options.passphrase)) {
            throw new errors2.KeyEncryptedError(
              options.filename,
              "PEM"
            );
          } else {
            parts = headers["dek-info"].split(",");
            assert.ok(parts.length === 2);
            cipher = parts[0].toLowerCase();
            iv = Buffer2.from(parts[1], "hex");
            key2 = utils2.opensslKeyDeriv(
              cipher,
              iv,
              options.passphrase,
              1
            ).key;
          }
        }
      }
      if (alg && alg.toLowerCase() === "encrypted") {
        var eder = new asn1.BerReader(buf);
        var pbesEnd;
        eder.readSequence();
        eder.readSequence();
        pbesEnd = eder.offset + eder.length;
        var method = eder.readOID();
        if (method !== OID_PBES2) {
          throw new Error("Unsupported PEM/PKCS8 encryption scheme: " + method);
        }
        eder.readSequence();
        eder.readSequence();
        var kdfEnd = eder.offset + eder.length;
        var kdfOid = eder.readOID();
        if (kdfOid !== OID_PBKDF2)
          throw new Error("Unsupported PBES2 KDF: " + kdfOid);
        eder.readSequence();
        var salt = eder.readString(asn1.Ber.OctetString, true);
        var iterations = eder.readInt();
        var hashAlg = "sha1";
        if (eder.offset < kdfEnd) {
          eder.readSequence();
          var hashAlgOid = eder.readOID();
          hashAlg = OID_TO_HASH[hashAlgOid];
          if (hashAlg === void 0) {
            throw new Error("Unsupported PBKDF2 hash: " + hashAlgOid);
          }
        }
        eder._offset = kdfEnd;
        eder.readSequence();
        var cipherOid = eder.readOID();
        cipher = OID_TO_CIPHER[cipherOid];
        if (cipher === void 0) {
          throw new Error("Unsupported PBES2 cipher: " + cipherOid);
        }
        iv = eder.readString(asn1.Ber.OctetString, true);
        eder._offset = pbesEnd;
        buf = eder.readString(asn1.Ber.OctetString, true);
        if (typeof options.passphrase === "string") {
          options.passphrase = Buffer2.from(
            options.passphrase,
            "utf-8"
          );
        }
        if (!Buffer2.isBuffer(options.passphrase)) {
          throw new errors2.KeyEncryptedError(
            options.filename,
            "PEM"
          );
        }
        var cinfo = utils2.opensshCipherInfo(cipher);
        cipher = cinfo.opensslName;
        key2 = utils2.pbkdf2(
          hashAlg,
          salt,
          iterations,
          cinfo.keySize,
          options.passphrase
        );
        alg = void 0;
      }
      if (cipher && key2 && iv) {
        var cipherStream = crypto2.createDecipheriv(cipher, key2, iv);
        var chunk, chunks = [];
        cipherStream.once("error", function(e) {
          if (e.toString().indexOf("bad decrypt") !== -1) {
            throw new Error("Incorrect passphrase supplied, could not decrypt key");
          }
          throw e;
        });
        cipherStream.write(buf);
        cipherStream.end();
        while ((chunk = cipherStream.read()) !== null)
          chunks.push(chunk);
        buf = Buffer2.concat(chunks);
      }
      if (alg && alg.toLowerCase() === "openssh")
        return sshpriv.readSSHPrivate(type2, buf, options);
      if (alg && alg.toLowerCase() === "ssh2")
        return rfc42532.readType(type2, buf, options);
      var der = new asn1.BerReader(buf);
      der.originalInput = input;
      der.readSequence();
      if (alg) {
        if (forceType)
          assert.strictEqual(forceType, "pkcs1");
        return pkcs12.readPkcs1(alg, type2, der);
      } else {
        if (forceType)
          assert.strictEqual(forceType, "pkcs8");
        return pkcs82.readPkcs8(alg, type2, der);
      }
    }
    function write(key2, options, type2) {
      assert.object(key2);
      var alg = {
        "ecdsa": "EC",
        "rsa": "RSA",
        "dsa": "DSA",
        "ed25519": "EdDSA"
      }[key2.type];
      var header;
      var der = new asn1.BerWriter();
      if (PrivateKey.isPrivateKey(key2)) {
        if (type2 && type2 === "pkcs8") {
          header = "PRIVATE KEY";
          pkcs82.writePkcs8(der, key2);
        } else {
          if (type2)
            assert.strictEqual(type2, "pkcs1");
          header = alg + " PRIVATE KEY";
          pkcs12.writePkcs1(der, key2);
        }
      } else if (Key.isKey(key2)) {
        if (type2 && type2 === "pkcs1") {
          header = alg + " PUBLIC KEY";
          pkcs12.writePkcs1(der, key2);
        } else {
          if (type2)
            assert.strictEqual(type2, "pkcs8");
          header = "PUBLIC KEY";
          pkcs82.writePkcs8(der, key2);
        }
      } else {
        throw new Error("key is not a Key or PrivateKey");
      }
      var tmp = der.buffer.toString("base64");
      var len = tmp.length + tmp.length / 64 + 18 + 16 + header.length * 2 + 10;
      var buf = Buffer2.alloc(len);
      var o = 0;
      o += buf.write("-----BEGIN " + header + "-----\n", o);
      for (var i2 = 0; i2 < tmp.length; ) {
        var limit = i2 + 64;
        if (limit > tmp.length)
          limit = tmp.length;
        o += buf.write(tmp.slice(i2, limit), o);
        buf[o++] = 10;
        i2 = limit;
      }
      o += buf.write("-----END " + header + "-----\n", o);
      return buf.slice(0, o);
    }
    return pem;
  }
  var ssh;
  var hasRequiredSsh;
  function requireSsh() {
    if (hasRequiredSsh)
      return ssh;
    hasRequiredSsh = 1;
    ssh = {
      read,
      write
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var rfc42532 = requireRfc4253();
    requireUtils$2();
    var Key = requireKey();
    requirePrivateKey();
    requireSshPrivate();
    var SSHKEY_RE = /^([a-z0-9-]+)[ \t]+([a-zA-Z0-9+\/]+[=]*)([ \t]+([^ \t][^\n]*[\n]*)?)?$/;
    var SSHKEY_RE2 = /^([a-z0-9-]+)[ \t\n]+([a-zA-Z0-9+\/][a-zA-Z0-9+\/ \t\n=]*)([^a-zA-Z0-9+\/ \t\n=].*)?$/;
    function read(buf, options) {
      if (typeof buf !== "string") {
        assert.buffer(buf, "buf");
        buf = buf.toString("ascii");
      }
      var trimmed = buf.trim().replace(/[\\\r]/g, "");
      var m = trimmed.match(SSHKEY_RE);
      if (!m)
        m = trimmed.match(SSHKEY_RE2);
      assert.ok(m, "key must match regex");
      var type2 = rfc42532.algToKeyType(m[1]);
      var kbuf = Buffer2.from(m[2], "base64");
      var key2;
      var ret = {};
      if (m[4]) {
        try {
          key2 = rfc42532.read(kbuf);
        } catch (e) {
          m = trimmed.match(SSHKEY_RE2);
          assert.ok(m, "key must match regex");
          kbuf = Buffer2.from(m[2], "base64");
          key2 = rfc42532.readInternal(ret, "public", kbuf);
        }
      } else {
        key2 = rfc42532.readInternal(ret, "public", kbuf);
      }
      assert.strictEqual(type2, key2.type);
      if (m[4] && m[4].length > 0) {
        key2.comment = m[4];
      } else if (ret.consumed) {
        var data2 = m[2] + (m[3] ? m[3] : "");
        var realOffset = Math.ceil(ret.consumed / 3) * 4;
        data2 = data2.slice(0, realOffset - 2).replace(/[^a-zA-Z0-9+\/=]/g, "") + data2.slice(realOffset - 2);
        var padding = ret.consumed % 3;
        if (padding > 0 && data2.slice(realOffset - 1, realOffset) !== "=")
          realOffset--;
        while (data2.slice(realOffset, realOffset + 1) === "=")
          realOffset++;
        var trailer = data2.slice(realOffset);
        trailer = trailer.replace(/[\r\n]/g, " ").replace(/^\s+/, "");
        if (trailer.match(/^[a-zA-Z0-9]/))
          key2.comment = trailer;
      }
      return key2;
    }
    function write(key2, options) {
      assert.object(key2);
      if (!Key.isKey(key2))
        throw new Error("Must be a public key");
      var parts = [];
      var alg = rfc42532.keyTypeToAlg(key2);
      parts.push(alg);
      var buf = rfc42532.write(key2);
      parts.push(buf.toString("base64"));
      if (key2.comment)
        parts.push(key2.comment);
      return Buffer2.from(parts.join(" "));
    }
    return ssh;
  }
  var dnssec;
  var hasRequiredDnssec;
  function requireDnssec() {
    if (hasRequiredDnssec)
      return dnssec;
    hasRequiredDnssec = 1;
    dnssec = {
      read,
      write
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var utils2 = requireUtils$2();
    requireSshBuffer();
    requireDhe();
    var supportedAlgos = {
      "rsa-sha1": 5,
      "rsa-sha256": 8,
      "rsa-sha512": 10,
      "ecdsa-p256-sha256": 13,
      "ecdsa-p384-sha384": 14
      /*
       * ed25519 is hypothetically supported with id 15
       * but the common tools available don't appear to be
       * capable of generating/using ed25519 keys
       */
    };
    var supportedAlgosById = {};
    Object.keys(supportedAlgos).forEach(function(k) {
      supportedAlgosById[supportedAlgos[k]] = k.toUpperCase();
    });
    function read(buf, options) {
      if (typeof buf !== "string") {
        assert.buffer(buf, "buf");
        buf = buf.toString("ascii");
      }
      var lines = buf.split("\n");
      if (lines[0].match(/^Private-key-format\: v1/)) {
        var algElems = lines[1].split(" ");
        var algoNum = parseInt(algElems[1], 10);
        var algoName = algElems[2];
        if (!supportedAlgosById[algoNum])
          throw new Error("Unsupported algorithm: " + algoName);
        return readDNSSECPrivateKey(algoNum, lines.slice(2));
      }
      var line = 0;
      while (lines[line].match(/^\;/))
        line++;
      if ((lines[line].match(/\. IN KEY /) || lines[line].match(/\. IN DNSKEY /)) && lines[line + 1].length === 0) {
        return readRFC3110(lines[line]);
      }
      throw new Error("Cannot parse dnssec key");
    }
    function readRFC3110(keyString) {
      var elems = keyString.split(" ");
      var algorithm = parseInt(elems[5], 10);
      if (!supportedAlgosById[algorithm])
        throw new Error("Unsupported algorithm: " + algorithm);
      var base64key = elems.slice(6, elems.length).join();
      var keyBuffer = Buffer2.from(base64key, "base64");
      if (supportedAlgosById[algorithm].match(/^RSA-/)) {
        var publicExponentLen = keyBuffer.readUInt8(0);
        if (publicExponentLen != 3 && publicExponentLen != 1)
          throw new Error("Cannot parse dnssec key: unsupported exponent length");
        var publicExponent = keyBuffer.slice(1, publicExponentLen + 1);
        publicExponent = utils2.mpNormalize(publicExponent);
        var modulus = keyBuffer.slice(1 + publicExponentLen);
        modulus = utils2.mpNormalize(modulus);
        var rsaKey = {
          type: "rsa",
          parts: []
        };
        rsaKey.parts.push({ name: "e", data: publicExponent });
        rsaKey.parts.push({ name: "n", data: modulus });
        return new Key(rsaKey);
      }
      if (supportedAlgosById[algorithm] === "ECDSA-P384-SHA384" || supportedAlgosById[algorithm] === "ECDSA-P256-SHA256") {
        var curve = "nistp384";
        var size = 384;
        if (supportedAlgosById[algorithm].match(/^ECDSA-P256-SHA256/)) {
          curve = "nistp256";
          size = 256;
        }
        var ecdsaKey = {
          type: "ecdsa",
          curve,
          size,
          parts: [
            { name: "curve", data: Buffer2.from(curve) },
            { name: "Q", data: utils2.ecNormalize(keyBuffer) }
          ]
        };
        return new Key(ecdsaKey);
      }
      throw new Error("Unsupported algorithm: " + supportedAlgosById[algorithm]);
    }
    function elementToBuf(e) {
      return Buffer2.from(e.split(" ")[1], "base64");
    }
    function readDNSSECRSAPrivateKey(elements) {
      var rsaParams = {};
      elements.forEach(function(element) {
        if (element.split(" ")[0] === "Modulus:")
          rsaParams["n"] = elementToBuf(element);
        else if (element.split(" ")[0] === "PublicExponent:")
          rsaParams["e"] = elementToBuf(element);
        else if (element.split(" ")[0] === "PrivateExponent:")
          rsaParams["d"] = elementToBuf(element);
        else if (element.split(" ")[0] === "Prime1:")
          rsaParams["p"] = elementToBuf(element);
        else if (element.split(" ")[0] === "Prime2:")
          rsaParams["q"] = elementToBuf(element);
        else if (element.split(" ")[0] === "Exponent1:")
          rsaParams["dmodp"] = elementToBuf(element);
        else if (element.split(" ")[0] === "Exponent2:")
          rsaParams["dmodq"] = elementToBuf(element);
        else if (element.split(" ")[0] === "Coefficient:")
          rsaParams["iqmp"] = elementToBuf(element);
      });
      var key2 = {
        type: "rsa",
        parts: [
          { name: "e", data: utils2.mpNormalize(rsaParams["e"]) },
          { name: "n", data: utils2.mpNormalize(rsaParams["n"]) },
          { name: "d", data: utils2.mpNormalize(rsaParams["d"]) },
          { name: "p", data: utils2.mpNormalize(rsaParams["p"]) },
          { name: "q", data: utils2.mpNormalize(rsaParams["q"]) },
          {
            name: "dmodp",
            data: utils2.mpNormalize(rsaParams["dmodp"])
          },
          {
            name: "dmodq",
            data: utils2.mpNormalize(rsaParams["dmodq"])
          },
          {
            name: "iqmp",
            data: utils2.mpNormalize(rsaParams["iqmp"])
          }
        ]
      };
      return new PrivateKey(key2);
    }
    function readDNSSECPrivateKey(alg, elements) {
      if (supportedAlgosById[alg].match(/^RSA-/)) {
        return readDNSSECRSAPrivateKey(elements);
      }
      if (supportedAlgosById[alg] === "ECDSA-P384-SHA384" || supportedAlgosById[alg] === "ECDSA-P256-SHA256") {
        var d2 = Buffer2.from(elements[0].split(" ")[1], "base64");
        var curve = "nistp384";
        var size = 384;
        if (supportedAlgosById[alg] === "ECDSA-P256-SHA256") {
          curve = "nistp256";
          size = 256;
        }
        var publicKey = utils2.publicFromPrivateECDSA(curve, d2);
        var Q = publicKey.part["Q"].data;
        var ecdsaKey = {
          type: "ecdsa",
          curve,
          size,
          parts: [
            { name: "curve", data: Buffer2.from(curve) },
            { name: "d", data: d2 },
            { name: "Q", data: Q }
          ]
        };
        return new PrivateKey(ecdsaKey);
      }
      throw new Error("Unsupported algorithm: " + supportedAlgosById[alg]);
    }
    function dnssecTimestamp(date) {
      var year = date.getFullYear() + "";
      var month = date.getMonth() + 1;
      var timestampStr = year + month + date.getUTCDate();
      timestampStr += "" + date.getUTCHours() + date.getUTCMinutes();
      timestampStr += date.getUTCSeconds();
      return timestampStr;
    }
    function rsaAlgFromOptions(opts) {
      if (!opts || !opts.hashAlgo || opts.hashAlgo === "sha1")
        return "5 (RSASHA1)";
      else if (opts.hashAlgo === "sha256")
        return "8 (RSASHA256)";
      else if (opts.hashAlgo === "sha512")
        return "10 (RSASHA512)";
      else
        throw new Error("Unknown or unsupported hash: " + opts.hashAlgo);
    }
    function writeRSA(key2, options) {
      if (!key2.part.dmodp || !key2.part.dmodq) {
        utils2.addRSAMissing(key2);
      }
      var out = "";
      out += "Private-key-format: v1.3\n";
      out += "Algorithm: " + rsaAlgFromOptions(options) + "\n";
      var n = utils2.mpDenormalize(key2.part["n"].data);
      out += "Modulus: " + n.toString("base64") + "\n";
      var e = utils2.mpDenormalize(key2.part["e"].data);
      out += "PublicExponent: " + e.toString("base64") + "\n";
      var d2 = utils2.mpDenormalize(key2.part["d"].data);
      out += "PrivateExponent: " + d2.toString("base64") + "\n";
      var p = utils2.mpDenormalize(key2.part["p"].data);
      out += "Prime1: " + p.toString("base64") + "\n";
      var q2 = utils2.mpDenormalize(key2.part["q"].data);
      out += "Prime2: " + q2.toString("base64") + "\n";
      var dmodp = utils2.mpDenormalize(key2.part["dmodp"].data);
      out += "Exponent1: " + dmodp.toString("base64") + "\n";
      var dmodq = utils2.mpDenormalize(key2.part["dmodq"].data);
      out += "Exponent2: " + dmodq.toString("base64") + "\n";
      var iqmp = utils2.mpDenormalize(key2.part["iqmp"].data);
      out += "Coefficient: " + iqmp.toString("base64") + "\n";
      var timestamp = /* @__PURE__ */ new Date();
      out += "Created: " + dnssecTimestamp(timestamp) + "\n";
      out += "Publish: " + dnssecTimestamp(timestamp) + "\n";
      out += "Activate: " + dnssecTimestamp(timestamp) + "\n";
      return Buffer2.from(out, "ascii");
    }
    function writeECDSA(key2, options) {
      var out = "";
      out += "Private-key-format: v1.3\n";
      if (key2.curve === "nistp256") {
        out += "Algorithm: 13 (ECDSAP256SHA256)\n";
      } else if (key2.curve === "nistp384") {
        out += "Algorithm: 14 (ECDSAP384SHA384)\n";
      } else {
        throw new Error("Unsupported curve");
      }
      var base64Key = key2.part["d"].data.toString("base64");
      out += "PrivateKey: " + base64Key + "\n";
      var timestamp = /* @__PURE__ */ new Date();
      out += "Created: " + dnssecTimestamp(timestamp) + "\n";
      out += "Publish: " + dnssecTimestamp(timestamp) + "\n";
      out += "Activate: " + dnssecTimestamp(timestamp) + "\n";
      return Buffer2.from(out, "ascii");
    }
    function write(key2, options) {
      if (PrivateKey.isPrivateKey(key2)) {
        if (key2.type === "rsa") {
          return writeRSA(key2, options);
        } else if (key2.type === "ecdsa") {
          return writeECDSA(key2);
        } else {
          throw new Error("Unsupported algorithm: " + key2.type);
        }
      } else if (Key.isKey(key2)) {
        throw new Error('Format "dnssec" only supports writing private keys');
      } else {
        throw new Error("key is not a Key or PrivateKey");
      }
    }
    return dnssec;
  }
  var putty;
  var hasRequiredPutty;
  function requirePutty() {
    if (hasRequiredPutty)
      return putty;
    hasRequiredPutty = 1;
    putty = {
      read,
      write
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var rfc42532 = requireRfc4253();
    var Key = requireKey();
    var SSHBuffer = requireSshBuffer();
    var crypto2 = require$$0$2;
    var PrivateKey = requirePrivateKey();
    var errors2 = requireErrors$1();
    function read(buf, options) {
      var lines = buf.toString("ascii").split(/[\r\n]+/);
      var found = false;
      var parts;
      var si = 0;
      var formatVersion;
      while (si < lines.length) {
        parts = splitHeader(lines[si++]);
        if (parts) {
          formatVersion = {
            "putty-user-key-file-2": 2,
            "putty-user-key-file-3": 3
          }[parts[0].toLowerCase()];
          if (formatVersion) {
            found = true;
            break;
          }
        }
      }
      if (!found) {
        throw new Error("No PuTTY format first line found");
      }
      var alg = parts[1];
      parts = splitHeader(lines[si++]);
      assert.equal(parts[0].toLowerCase(), "encryption");
      var encryption = parts[1];
      parts = splitHeader(lines[si++]);
      assert.equal(parts[0].toLowerCase(), "comment");
      var comment2 = parts[1];
      parts = splitHeader(lines[si++]);
      assert.equal(parts[0].toLowerCase(), "public-lines");
      var publicLines = parseInt(parts[1], 10);
      if (!isFinite(publicLines) || publicLines < 0 || publicLines > lines.length) {
        throw new Error("Invalid public-lines count");
      }
      var publicBuf = Buffer2.from(
        lines.slice(si, si + publicLines).join(""),
        "base64"
      );
      var keyType = rfc42532.algToKeyType(alg);
      var key2 = rfc42532.read(publicBuf);
      if (key2.type !== keyType) {
        throw new Error("Outer key algorithm mismatch");
      }
      si += publicLines;
      if (lines[si]) {
        parts = splitHeader(lines[si++]);
        assert.equal(parts[0].toLowerCase(), "private-lines");
        var privateLines = parseInt(parts[1], 10);
        if (!isFinite(privateLines) || privateLines < 0 || privateLines > lines.length) {
          throw new Error("Invalid private-lines count");
        }
        var privateBuf = Buffer2.from(
          lines.slice(si, si + privateLines).join(""),
          "base64"
        );
        if (encryption !== "none" && formatVersion === 3) {
          throw new Error("Encrypted keys arenot supported for PuTTY format version 3");
        }
        if (encryption === "aes256-cbc") {
          if (!options.passphrase) {
            throw new errors2.KeyEncryptedError(
              options.filename,
              "PEM"
            );
          }
          var iv = Buffer2.alloc(16, 0);
          var decipher = crypto2.createDecipheriv(
            "aes-256-cbc",
            derivePPK2EncryptionKey(options.passphrase),
            iv
          );
          decipher.setAutoPadding(false);
          privateBuf = Buffer2.concat([
            decipher.update(privateBuf),
            decipher.final()
          ]);
        }
        key2 = new PrivateKey(key2);
        if (key2.type !== keyType) {
          throw new Error("Outer key algorithm mismatch");
        }
        var sshbuf = new SSHBuffer({ buffer: privateBuf });
        var privateKeyParts;
        if (alg === "ssh-dss") {
          privateKeyParts = [{
            name: "x",
            data: sshbuf.readBuffer()
          }];
        } else if (alg === "ssh-rsa") {
          privateKeyParts = [
            { name: "d", data: sshbuf.readBuffer() },
            { name: "p", data: sshbuf.readBuffer() },
            { name: "q", data: sshbuf.readBuffer() },
            { name: "iqmp", data: sshbuf.readBuffer() }
          ];
        } else if (alg.match(/^ecdsa-sha2-nistp/)) {
          privateKeyParts = [{
            name: "d",
            data: sshbuf.readBuffer()
          }];
        } else if (alg === "ssh-ed25519") {
          privateKeyParts = [{
            name: "k",
            data: sshbuf.readBuffer()
          }];
        } else {
          throw new Error("Unsupported PPK key type: " + alg);
        }
        key2 = new PrivateKey({
          type: key2.type,
          parts: key2.parts.concat(privateKeyParts)
        });
      }
      key2.comment = comment2;
      return key2;
    }
    function derivePPK2EncryptionKey(passphrase) {
      var hash1 = crypto2.createHash("sha1").update(Buffer2.concat([
        Buffer2.from([0, 0, 0, 0]),
        Buffer2.from(passphrase)
      ])).digest();
      var hash2 = crypto2.createHash("sha1").update(Buffer2.concat([
        Buffer2.from([0, 0, 0, 1]),
        Buffer2.from(passphrase)
      ])).digest();
      return Buffer2.concat([hash1, hash2]).slice(0, 32);
    }
    function splitHeader(line) {
      var idx = line.indexOf(":");
      if (idx === -1)
        return null;
      var header = line.slice(0, idx);
      ++idx;
      while (line[idx] === " ")
        ++idx;
      var rest = line.slice(idx);
      return [header, rest];
    }
    function write(key2, options) {
      assert.object(key2);
      if (!Key.isKey(key2))
        throw new Error("Must be a public key");
      var alg = rfc42532.keyTypeToAlg(key2);
      var buf = rfc42532.write(key2);
      var comment2 = key2.comment || "";
      var b64 = buf.toString("base64");
      var lines = wrap(b64);
      lines.unshift("Public-Lines: " + lines.length);
      lines.unshift("Comment: " + comment2);
      lines.unshift("Encryption: none");
      lines.unshift("PuTTY-User-Key-File-2: " + alg);
      return Buffer2.from(lines.join("\n") + "\n");
    }
    function wrap(txt, len) {
      var lines = [];
      var pos = 0;
      while (pos < txt.length) {
        lines.push(txt.slice(pos, pos + 64));
        pos += 64;
      }
      return lines;
    }
    return putty;
  }
  var auto;
  var hasRequiredAuto;
  function requireAuto() {
    if (hasRequiredAuto)
      return auto;
    hasRequiredAuto = 1;
    auto = {
      read,
      write
    };
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    requireUtils$2();
    requireKey();
    requirePrivateKey();
    var pem2 = requirePem();
    var ssh2 = requireSsh();
    var rfc42532 = requireRfc4253();
    var dnssec2 = requireDnssec();
    var putty2 = requirePutty();
    var DNSSEC_PRIVKEY_HEADER_PREFIX = "Private-key-format: v1";
    function read(buf, options) {
      if (typeof buf === "string") {
        if (buf.trim().match(/^[-]+[ ]*BEGIN/))
          return pem2.read(buf, options);
        if (buf.match(/^\s*ssh-[a-z]/))
          return ssh2.read(buf, options);
        if (buf.match(/^\s*ecdsa-/))
          return ssh2.read(buf, options);
        if (buf.match(/^putty-user-key-file-2:/i))
          return putty2.read(buf, options);
        if (findDNSSECHeader(buf))
          return dnssec2.read(buf, options);
        buf = Buffer2.from(buf, "binary");
      } else {
        assert.buffer(buf);
        if (findPEMHeader(buf))
          return pem2.read(buf, options);
        if (findSSHHeader(buf))
          return ssh2.read(buf, options);
        if (findPuTTYHeader(buf))
          return putty2.read(buf, options);
        if (findDNSSECHeader(buf))
          return dnssec2.read(buf, options);
      }
      if (buf.readUInt32BE(0) < buf.length)
        return rfc42532.read(buf, options);
      throw new Error("Failed to auto-detect format of key");
    }
    function findPuTTYHeader(buf) {
      var offset = 0;
      while (offset < buf.length && (buf[offset] === 32 || buf[offset] === 10 || buf[offset] === 9))
        ++offset;
      if (offset + 22 <= buf.length && buf.slice(offset, offset + 22).toString("ascii").toLowerCase() === "putty-user-key-file-2:")
        return true;
      return false;
    }
    function findSSHHeader(buf) {
      var offset = 0;
      while (offset < buf.length && (buf[offset] === 32 || buf[offset] === 10 || buf[offset] === 9))
        ++offset;
      if (offset + 4 <= buf.length && buf.slice(offset, offset + 4).toString("ascii") === "ssh-")
        return true;
      if (offset + 6 <= buf.length && buf.slice(offset, offset + 6).toString("ascii") === "ecdsa-")
        return true;
      return false;
    }
    function findPEMHeader(buf) {
      var offset = 0;
      while (offset < buf.length && (buf[offset] === 32 || buf[offset] === 10))
        ++offset;
      if (buf[offset] !== 45)
        return false;
      while (offset < buf.length && buf[offset] === 45)
        ++offset;
      while (offset < buf.length && buf[offset] === 32)
        ++offset;
      if (offset + 5 > buf.length || buf.slice(offset, offset + 5).toString("ascii") !== "BEGIN")
        return false;
      return true;
    }
    function findDNSSECHeader(buf) {
      if (buf.length <= DNSSEC_PRIVKEY_HEADER_PREFIX.length)
        return false;
      var headerCheck = buf.slice(0, DNSSEC_PRIVKEY_HEADER_PREFIX.length);
      if (headerCheck.toString("ascii") === DNSSEC_PRIVKEY_HEADER_PREFIX)
        return true;
      if (typeof buf !== "string") {
        buf = buf.toString("ascii");
      }
      var lines = buf.split("\n");
      var line = 0;
      while (lines[line].match(/^\;/))
        line++;
      if (lines[line].toString("ascii").match(/\. IN KEY /))
        return true;
      if (lines[line].toString("ascii").match(/\. IN DNSKEY /))
        return true;
      return false;
    }
    function write(key2, options) {
      throw new Error('"auto" format cannot be used for writing');
    }
    return auto;
  }
  var privateKey;
  var hasRequiredPrivateKey;
  function requirePrivateKey() {
    if (hasRequiredPrivateKey)
      return privateKey;
    hasRequiredPrivateKey = 1;
    privateKey = PrivateKey;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var crypto2 = require$$0$2;
    requireFingerprint();
    var Signature = requireSignature();
    var errs = requireErrors$1();
    var util2 = require$$0$2;
    var utils2 = requireUtils$2();
    var dhe2 = requireDhe();
    var generateECDSA = dhe2.generateECDSA;
    var generateED25519 = dhe2.generateED25519;
    var edCompat2 = requireEdCompat();
    var nacl = requireNaclFast();
    var Key = requireKey();
    errs.InvalidAlgorithmError;
    var KeyParseError = errs.KeyParseError;
    errs.KeyEncryptedError;
    var formats2 = {};
    formats2["auto"] = requireAuto();
    formats2["pem"] = requirePem();
    formats2["pkcs1"] = requirePkcs1();
    formats2["pkcs8"] = requirePkcs8();
    formats2["rfc4253"] = requireRfc4253();
    formats2["ssh-private"] = requireSshPrivate();
    formats2["openssh"] = formats2["ssh-private"];
    formats2["ssh"] = formats2["ssh-private"];
    formats2["dnssec"] = requireDnssec();
    formats2["putty"] = requirePutty();
    function PrivateKey(opts) {
      assert.object(opts, "options");
      Key.call(this, opts);
      this._pubCache = void 0;
    }
    util2.inherits(PrivateKey, Key);
    PrivateKey.formats = formats2;
    PrivateKey.prototype.toBuffer = function(format2, options) {
      if (format2 === void 0)
        format2 = "pkcs1";
      assert.string(format2, "format");
      assert.object(formats2[format2], "formats[format]");
      assert.optionalObject(options, "options");
      return formats2[format2].write(this, options);
    };
    PrivateKey.prototype.hash = function(algo, type2) {
      return this.toPublic().hash(algo, type2);
    };
    PrivateKey.prototype.fingerprint = function(algo, type2) {
      return this.toPublic().fingerprint(algo, type2);
    };
    PrivateKey.prototype.toPublic = function() {
      if (this._pubCache)
        return this._pubCache;
      var algInfo = algs2.info[this.type];
      var pubParts = [];
      for (var i2 = 0; i2 < algInfo.parts.length; ++i2) {
        var p = algInfo.parts[i2];
        pubParts.push(this.part[p]);
      }
      this._pubCache = new Key({
        type: this.type,
        source: this,
        parts: pubParts
      });
      if (this.comment)
        this._pubCache.comment = this.comment;
      return this._pubCache;
    };
    PrivateKey.prototype.derive = function(newType) {
      assert.string(newType, "type");
      var priv, pub, pair;
      if (this.type === "ed25519" && newType === "curve25519") {
        priv = this.part.k.data;
        if (priv[0] === 0)
          priv = priv.slice(1);
        pair = nacl.box.keyPair.fromSecretKey(new Uint8Array(priv));
        pub = Buffer2.from(pair.publicKey);
        return new PrivateKey({
          type: "curve25519",
          parts: [
            { name: "A", data: utils2.mpNormalize(pub) },
            { name: "k", data: utils2.mpNormalize(priv) }
          ]
        });
      } else if (this.type === "curve25519" && newType === "ed25519") {
        priv = this.part.k.data;
        if (priv[0] === 0)
          priv = priv.slice(1);
        pair = nacl.sign.keyPair.fromSeed(new Uint8Array(priv));
        pub = Buffer2.from(pair.publicKey);
        return new PrivateKey({
          type: "ed25519",
          parts: [
            { name: "A", data: utils2.mpNormalize(pub) },
            { name: "k", data: utils2.mpNormalize(priv) }
          ]
        });
      }
      throw new Error("Key derivation not supported from " + this.type + " to " + newType);
    };
    PrivateKey.prototype.createVerify = function(hashAlgo) {
      return this.toPublic().createVerify(hashAlgo);
    };
    PrivateKey.prototype.createSign = function(hashAlgo) {
      if (hashAlgo === void 0)
        hashAlgo = this.defaultHashAlgorithm();
      assert.string(hashAlgo, "hash algorithm");
      if (this.type === "ed25519" && edCompat2 !== void 0)
        return new edCompat2.Signer(this, hashAlgo);
      if (this.type === "curve25519")
        throw new Error("Curve25519 keys are not suitable for signing or verification");
      var v, nm, err;
      try {
        nm = hashAlgo.toUpperCase();
        v = crypto2.createSign(nm);
      } catch (e) {
        err = e;
      }
      if (v === void 0 || err instanceof Error && err.message.match(/Unknown message digest/)) {
        nm = "RSA-";
        nm += hashAlgo.toUpperCase();
        v = crypto2.createSign(nm);
      }
      assert.ok(v, "failed to create verifier");
      var oldSign = v.sign.bind(v);
      var key2 = this.toBuffer("pkcs1");
      var type2 = this.type;
      var curve = this.curve;
      v.sign = function() {
        var sig = oldSign(key2);
        if (typeof sig === "string")
          sig = Buffer2.from(sig, "binary");
        sig = Signature.parse(sig, type2, "asn1");
        sig.hashAlgorithm = hashAlgo;
        sig.curve = curve;
        return sig;
      };
      return v;
    };
    PrivateKey.parse = function(data2, format2, options) {
      if (typeof data2 !== "string")
        assert.buffer(data2, "data");
      if (format2 === void 0)
        format2 = "auto";
      assert.string(format2, "format");
      if (typeof options === "string")
        options = { filename: options };
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      assert.optionalString(options.filename, "options.filename");
      if (options.filename === void 0)
        options.filename = "(unnamed)";
      assert.object(formats2[format2], "formats[format]");
      try {
        var k = formats2[format2].read(data2, options);
        assert.ok(k instanceof PrivateKey, "key is not a private key");
        if (!k.comment)
          k.comment = options.filename;
        return k;
      } catch (e) {
        if (e.name === "KeyEncryptedError")
          throw e;
        throw new KeyParseError(options.filename, format2, e);
      }
    };
    PrivateKey.isPrivateKey = function(obj, ver) {
      return utils2.isCompatible(obj, PrivateKey, ver);
    };
    PrivateKey.generate = function(type2, options) {
      if (options === void 0)
        options = {};
      assert.object(options, "options");
      switch (type2) {
        case "ecdsa":
          if (options.curve === void 0)
            options.curve = "nistp256";
          assert.string(options.curve, "options.curve");
          return generateECDSA(options.curve);
        case "ed25519":
          return generateED25519();
        default:
          throw new Error('Key generation not supported with key type "' + type2 + '"');
      }
    };
    PrivateKey.prototype._sshpkApiVersion = [1, 6];
    PrivateKey._oldVersionDetect = function(obj) {
      assert.func(obj.toPublic);
      assert.func(obj.createSign);
      if (obj.derive)
        return [1, 3];
      if (obj.defaultHashAlgorithm)
        return [1, 2];
      if (obj.formats["auto"])
        return [1, 1];
      return [1, 0];
    };
    return privateKey;
  }
  var identity;
  var hasRequiredIdentity;
  function requireIdentity() {
    if (hasRequiredIdentity)
      return identity;
    hasRequiredIdentity = 1;
    identity = Identity;
    var assert = requireAssert();
    requireAlgs();
    requireFingerprint();
    requireSignature();
    requireErrors$1();
    var utils2 = requireUtils$2();
    var asn1 = requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    var DNS_NAME_RE = /^([*]|[a-z0-9][a-z0-9\-]{0,62})(?:\.([*]|[a-z0-9][a-z0-9\-]{0,62}))*$/i;
    var oids = {};
    oids.cn = "2.5.4.3";
    oids.o = "2.5.4.10";
    oids.ou = "2.5.4.11";
    oids.l = "2.5.4.7";
    oids.s = "2.5.4.8";
    oids.c = "2.5.4.6";
    oids.sn = "2.5.4.4";
    oids.postalCode = "2.5.4.17";
    oids.serialNumber = "2.5.4.5";
    oids.street = "2.5.4.9";
    oids.x500UniqueIdentifier = "2.5.4.45";
    oids.role = "2.5.4.72";
    oids.telephoneNumber = "2.5.4.20";
    oids.description = "2.5.4.13";
    oids.dc = "0.9.2342.19200300.100.1.25";
    oids.uid = "0.9.2342.19200300.100.1.1";
    oids.mail = "0.9.2342.19200300.100.1.3";
    oids.title = "2.5.4.12";
    oids.gn = "2.5.4.42";
    oids.initials = "2.5.4.43";
    oids.pseudonym = "2.5.4.65";
    oids.emailAddress = "1.2.840.113549.1.9.1";
    var unoids = {};
    Object.keys(oids).forEach(function(k) {
      unoids[oids[k]] = k;
    });
    function Identity(opts) {
      var self2 = this;
      assert.object(opts, "options");
      assert.arrayOfObject(opts.components, "options.components");
      this.components = opts.components;
      this.componentLookup = {};
      this.components.forEach(function(c2) {
        if (c2.name && !c2.oid)
          c2.oid = oids[c2.name];
        if (c2.oid && !c2.name)
          c2.name = unoids[c2.oid];
        if (self2.componentLookup[c2.name] === void 0)
          self2.componentLookup[c2.name] = [];
        self2.componentLookup[c2.name].push(c2);
      });
      if (this.componentLookup.cn && this.componentLookup.cn.length > 0) {
        this.cn = this.componentLookup.cn[0].value;
      }
      assert.optionalString(opts.type, "options.type");
      if (opts.type === void 0) {
        if (this.components.length === 1 && this.componentLookup.cn && this.componentLookup.cn.length === 1 && this.componentLookup.cn[0].value.match(DNS_NAME_RE)) {
          this.type = "host";
          this.hostname = this.componentLookup.cn[0].value;
        } else if (this.componentLookup.dc && this.components.length === this.componentLookup.dc.length) {
          this.type = "host";
          this.hostname = this.componentLookup.dc.map(
            function(c2) {
              return c2.value;
            }
          ).join(".");
        } else if (this.componentLookup.uid && this.components.length === this.componentLookup.uid.length) {
          this.type = "user";
          this.uid = this.componentLookup.uid[0].value;
        } else if (this.componentLookup.cn && this.componentLookup.cn.length === 1 && this.componentLookup.cn[0].value.match(DNS_NAME_RE)) {
          this.type = "host";
          this.hostname = this.componentLookup.cn[0].value;
        } else if (this.componentLookup.uid && this.componentLookup.uid.length === 1) {
          this.type = "user";
          this.uid = this.componentLookup.uid[0].value;
        } else if (this.componentLookup.mail && this.componentLookup.mail.length === 1) {
          this.type = "email";
          this.email = this.componentLookup.mail[0].value;
        } else if (this.componentLookup.cn && this.componentLookup.cn.length === 1) {
          this.type = "user";
          this.uid = this.componentLookup.cn[0].value;
        } else {
          this.type = "unknown";
        }
      } else {
        this.type = opts.type;
        if (this.type === "host")
          this.hostname = opts.hostname;
        else if (this.type === "user")
          this.uid = opts.uid;
        else if (this.type === "email")
          this.email = opts.email;
        else
          throw new Error("Unknown type " + this.type);
      }
    }
    Identity.prototype.toString = function() {
      return this.components.map(function(c2) {
        var n = c2.name.toUpperCase();
        n = n.replace(/=/g, "\\=");
        var v = c2.value;
        v = v.replace(/,/g, "\\,");
        return n + "=" + v;
      }).join(", ");
    };
    Identity.prototype.get = function(name, asArray) {
      assert.string(name, "name");
      var arr = this.componentLookup[name];
      if (arr === void 0 || arr.length === 0)
        return void 0;
      if (!asArray && arr.length > 1)
        throw new Error("Multiple values for attribute " + name);
      if (!asArray)
        return arr[0].value;
      return arr.map(function(c2) {
        return c2.value;
      });
    };
    Identity.prototype.toArray = function(idx) {
      return this.components.map(function(c2) {
        return {
          name: c2.name,
          value: c2.value
        };
      });
    };
    var NOT_PRINTABLE = /[^a-zA-Z0-9 '(),+.\/:=?-]/;
    var NOT_IA5 = /[^\x00-\x7f]/;
    Identity.prototype.toAsn1 = function(der, tag) {
      der.startSequence(tag);
      this.components.forEach(function(c2) {
        der.startSequence(asn1.Ber.Constructor | asn1.Ber.Set);
        der.startSequence();
        der.writeOID(c2.oid);
        if (c2.asn1type === asn1.Ber.Utf8String || c2.value.match(NOT_IA5)) {
          var v = Buffer2.from(c2.value, "utf8");
          der.writeBuffer(v, asn1.Ber.Utf8String);
        } else if (c2.asn1type === asn1.Ber.IA5String || c2.value.match(NOT_PRINTABLE)) {
          der.writeString(c2.value, asn1.Ber.IA5String);
        } else {
          var type2 = asn1.Ber.PrintableString;
          if (c2.asn1type !== void 0)
            type2 = c2.asn1type;
          der.writeString(c2.value, type2);
        }
        der.endSequence();
        der.endSequence();
      });
      der.endSequence();
    };
    function globMatch(a2, b2) {
      if (a2 === "**" || b2 === "**")
        return true;
      var aParts = a2.split(".");
      var bParts = b2.split(".");
      if (aParts.length !== bParts.length)
        return false;
      for (var i2 = 0; i2 < aParts.length; ++i2) {
        if (aParts[i2] === "*" || bParts[i2] === "*")
          continue;
        if (aParts[i2] !== bParts[i2])
          return false;
      }
      return true;
    }
    Identity.prototype.equals = function(other) {
      if (!Identity.isIdentity(other, [1, 0]))
        return false;
      if (other.components.length !== this.components.length)
        return false;
      for (var i2 = 0; i2 < this.components.length; ++i2) {
        if (this.components[i2].oid !== other.components[i2].oid)
          return false;
        if (!globMatch(
          this.components[i2].value,
          other.components[i2].value
        )) {
          return false;
        }
      }
      return true;
    };
    Identity.forHost = function(hostname) {
      assert.string(hostname, "hostname");
      return new Identity({
        type: "host",
        hostname,
        components: [{ name: "cn", value: hostname }]
      });
    };
    Identity.forUser = function(uid) {
      assert.string(uid, "uid");
      return new Identity({
        type: "user",
        uid,
        components: [{ name: "uid", value: uid }]
      });
    };
    Identity.forEmail = function(email) {
      assert.string(email, "email");
      return new Identity({
        type: "email",
        email,
        components: [{ name: "mail", value: email }]
      });
    };
    Identity.parseDN = function(dn) {
      assert.string(dn, "dn");
      var parts = [""];
      var idx = 0;
      var rem = dn;
      while (rem.length > 0) {
        var m;
        if ((m = /^,/.exec(rem)) !== null) {
          parts[++idx] = "";
          rem = rem.slice(m[0].length);
        } else if ((m = /^\\,/.exec(rem)) !== null) {
          parts[idx] += ",";
          rem = rem.slice(m[0].length);
        } else if ((m = /^\\./.exec(rem)) !== null) {
          parts[idx] += m[0];
          rem = rem.slice(m[0].length);
        } else if ((m = /^[^\\,]+/.exec(rem)) !== null) {
          parts[idx] += m[0];
          rem = rem.slice(m[0].length);
        } else {
          throw new Error("Failed to parse DN");
        }
      }
      var cmps = parts.map(function(c2) {
        c2 = c2.trim();
        var eqPos = c2.indexOf("=");
        while (eqPos > 0 && c2.charAt(eqPos - 1) === "\\")
          eqPos = c2.indexOf("=", eqPos + 1);
        if (eqPos === -1) {
          throw new Error("Failed to parse DN");
        }
        var name = c2.slice(0, eqPos).toLowerCase().replace(/\\=/g, "=");
        var value = c2.slice(eqPos + 1);
        return { name, value };
      });
      return new Identity({ components: cmps });
    };
    Identity.fromArray = function(components) {
      assert.arrayOfObject(components, "components");
      components.forEach(function(cmp) {
        assert.object(cmp, "component");
        assert.string(cmp.name, "component.name");
        if (!Buffer2.isBuffer(cmp.value) && !(typeof cmp.value === "string")) {
          throw new Error("Invalid component value");
        }
      });
      return new Identity({ components });
    };
    Identity.parseAsn1 = function(der, top) {
      var components = [];
      der.readSequence(top);
      var end = der.offset + der.length;
      while (der.offset < end) {
        der.readSequence(asn1.Ber.Constructor | asn1.Ber.Set);
        var after = der.offset + der.length;
        der.readSequence();
        var oid = der.readOID();
        var type2 = der.peek();
        var value;
        switch (type2) {
          case asn1.Ber.PrintableString:
          case asn1.Ber.IA5String:
          case asn1.Ber.OctetString:
          case asn1.Ber.T61String:
            value = der.readString(type2);
            break;
          case asn1.Ber.Utf8String:
            value = der.readString(type2, true);
            value = value.toString("utf8");
            break;
          case asn1.Ber.CharacterString:
          case asn1.Ber.BMPString:
            value = der.readString(type2, true);
            value = value.toString("utf16le");
            break;
          default:
            throw new Error("Unknown asn1 type " + type2);
        }
        components.push({ oid, asn1type: type2, value });
        der._offset = after;
      }
      der._offset = end;
      return new Identity({
        components
      });
    };
    Identity.isIdentity = function(obj, ver) {
      return utils2.isCompatible(obj, Identity, ver);
    };
    Identity.prototype._sshpkApiVersion = [1, 0];
    Identity._oldVersionDetect = function(obj) {
      return [1, 0];
    };
    return identity;
  }
  var opensshCert;
  var hasRequiredOpensshCert;
  function requireOpensshCert() {
    if (hasRequiredOpensshCert)
      return opensshCert;
    hasRequiredOpensshCert = 1;
    opensshCert = {
      read,
      verify: verify2,
      sign,
      signAsync,
      write,
      /* Internal private API */
      fromBuffer,
      toBuffer
    };
    var assert = requireAssert();
    var SSHBuffer = requireSshBuffer();
    var crypto2 = require$$0$2;
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var Key = requireKey();
    requirePrivateKey();
    var Identity = requireIdentity();
    var rfc42532 = requireRfc4253();
    var Signature = requireSignature();
    var utils2 = requireUtils$2();
    var Certificate = requireCertificate();
    function verify2(cert, key2) {
      return false;
    }
    var TYPES = {
      "user": 1,
      "host": 2
    };
    Object.keys(TYPES).forEach(function(k) {
      TYPES[TYPES[k]] = k;
    });
    var ECDSA_ALGO = /^ecdsa-sha2-([^@-]+)[email protected]$/;
    function read(buf, options) {
      if (Buffer2.isBuffer(buf))
        buf = buf.toString("ascii");
      var parts = buf.trim().split(/[ \t\n]+/g);
      if (parts.length < 2 || parts.length > 3)
        throw new Error("Not a valid SSH certificate line");
      var algo = parts[0];
      var data2 = parts[1];
      data2 = Buffer2.from(data2, "base64");
      return fromBuffer(data2, algo);
    }
    function fromBuffer(data2, algo, partial) {
      var sshbuf = new SSHBuffer({ buffer: data2 });
      var innerAlgo = sshbuf.readString();
      if (algo !== void 0 && innerAlgo !== algo)
        throw new Error("SSH certificate algorithm mismatch");
      if (algo === void 0)
        algo = innerAlgo;
      var cert = {};
      cert.signatures = {};
      cert.signatures.openssh = {};
      cert.signatures.openssh.nonce = sshbuf.readBuffer();
      var key2 = {};
      var parts = key2.parts = [];
      key2.type = getAlg(algo);
      var partCount = algs2.info[key2.type].parts.length;
      while (parts.length < partCount)
        parts.push(sshbuf.readPart());
      assert.ok(parts.length >= 1, "key must have at least one part");
      var algInfo = algs2.info[key2.type];
      if (key2.type === "ecdsa") {
        var res = ECDSA_ALGO.exec(algo);
        assert.ok(res !== null);
        assert.strictEqual(res[1], parts[0].data.toString());
      }
      for (var i2 = 0; i2 < algInfo.parts.length; ++i2) {
        parts[i2].name = algInfo.parts[i2];
        if (parts[i2].name !== "curve" && algInfo.normalize !== false) {
          var p = parts[i2];
          p.data = utils2.mpNormalize(p.data);
        }
      }
      cert.subjectKey = new Key(key2);
      cert.serial = sshbuf.readInt64();
      var type2 = TYPES[sshbuf.readInt()];
      assert.string(type2, "valid cert type");
      cert.signatures.openssh.keyId = sshbuf.readString();
      var principals = [];
      var pbuf = sshbuf.readBuffer();
      var psshbuf = new SSHBuffer({ buffer: pbuf });
      while (!psshbuf.atEnd())
        principals.push(psshbuf.readString());
      if (principals.length === 0)
        principals = ["*"];
      cert.subjects = principals.map(function(pr) {
        if (type2 === "user")
          return Identity.forUser(pr);
        else if (type2 === "host")
          return Identity.forHost(pr);
        throw new Error("Unknown identity type " + type2);
      });
      cert.validFrom = int64ToDate(sshbuf.readInt64());
      cert.validUntil = int64ToDate(sshbuf.readInt64());
      var exts = [];
      var extbuf = new SSHBuffer({ buffer: sshbuf.readBuffer() });
      var ext;
      while (!extbuf.atEnd()) {
        ext = { critical: true };
        ext.name = extbuf.readString();
        ext.data = extbuf.readBuffer();
        exts.push(ext);
      }
      extbuf = new SSHBuffer({ buffer: sshbuf.readBuffer() });
      while (!extbuf.atEnd()) {
        ext = { critical: false };
        ext.name = extbuf.readString();
        ext.data = extbuf.readBuffer();
        exts.push(ext);
      }
      cert.signatures.openssh.exts = exts;
      sshbuf.readBuffer();
      var signingKeyBuf = sshbuf.readBuffer();
      cert.issuerKey = rfc42532.read(signingKeyBuf);
      cert.issuer = Identity.forHost("**");
      var sigBuf = sshbuf.readBuffer();
      cert.signatures.openssh.signature = Signature.parse(sigBuf, cert.issuerKey.type, "ssh");
      if (partial !== void 0) {
        partial.remainder = sshbuf.remainder();
        partial.consumed = sshbuf._offset;
      }
      return new Certificate(cert);
    }
    function int64ToDate(buf) {
      var i2 = buf.readUInt32BE(0) * 4294967296;
      i2 += buf.readUInt32BE(4);
      var d2 = /* @__PURE__ */ new Date();
      d2.setTime(i2 * 1e3);
      d2.sourceInt64 = buf;
      return d2;
    }
    function dateToInt64(date) {
      if (date.sourceInt64 !== void 0)
        return date.sourceInt64;
      var i2 = Math.round(date.getTime() / 1e3);
      var upper = Math.floor(i2 / 4294967296);
      var lower = Math.floor(i2 % 4294967296);
      var buf = Buffer2.alloc(8);
      buf.writeUInt32BE(upper, 0);
      buf.writeUInt32BE(lower, 4);
      return buf;
    }
    function sign(cert, key2) {
      if (cert.signatures.openssh === void 0)
        cert.signatures.openssh = {};
      try {
        var blob = toBuffer(cert, true);
      } catch (e) {
        delete cert.signatures.openssh;
        return false;
      }
      var sig = cert.signatures.openssh;
      var hashAlgo = void 0;
      if (key2.type === "rsa" || key2.type === "dsa")
        hashAlgo = "sha1";
      var signer2 = key2.createSign(hashAlgo);
      signer2.write(blob);
      sig.signature = signer2.sign();
      return true;
    }
    function signAsync(cert, signer2, done) {
      if (cert.signatures.openssh === void 0)
        cert.signatures.openssh = {};
      try {
        var blob = toBuffer(cert, true);
      } catch (e) {
        delete cert.signatures.openssh;
        done(e);
        return;
      }
      var sig = cert.signatures.openssh;
      signer2(blob, function(err, signature2) {
        if (err) {
          done(err);
          return;
        }
        try {
          signature2.toBuffer("ssh");
        } catch (e) {
          done(e);
          return;
        }
        sig.signature = signature2;
        done();
      });
    }
    function write(cert, options) {
      if (options === void 0)
        options = {};
      var blob = toBuffer(cert);
      var out = getCertType(cert.subjectKey) + " " + blob.toString("base64");
      if (options.comment)
        out = out + " " + options.comment;
      return out;
    }
    function toBuffer(cert, noSig) {
      assert.object(cert.signatures.openssh, "signature for openssh format");
      var sig = cert.signatures.openssh;
      if (sig.nonce === void 0)
        sig.nonce = crypto2.randomBytes(16);
      var buf = new SSHBuffer({});
      buf.writeString(getCertType(cert.subjectKey));
      buf.writeBuffer(sig.nonce);
      var key2 = cert.subjectKey;
      var algInfo = algs2.info[key2.type];
      algInfo.parts.forEach(function(part) {
        buf.writePart(key2.part[part]);
      });
      buf.writeInt64(cert.serial);
      var type2 = cert.subjects[0].type;
      assert.notStrictEqual(type2, "unknown");
      cert.subjects.forEach(function(id) {
        assert.strictEqual(id.type, type2);
      });
      type2 = TYPES[type2];
      buf.writeInt(type2);
      if (sig.keyId === void 0) {
        sig.keyId = cert.subjects[0].type + "_" + (cert.subjects[0].uid || cert.subjects[0].hostname);
      }
      buf.writeString(sig.keyId);
      var sub = new SSHBuffer({});
      cert.subjects.forEach(function(id) {
        if (type2 === TYPES.host)
          sub.writeString(id.hostname);
        else if (type2 === TYPES.user)
          sub.writeString(id.uid);
      });
      buf.writeBuffer(sub.toBuffer());
      buf.writeInt64(dateToInt64(cert.validFrom));
      buf.writeInt64(dateToInt64(cert.validUntil));
      var exts = sig.exts;
      if (exts === void 0)
        exts = [];
      var extbuf = new SSHBuffer({});
      exts.forEach(function(ext) {
        if (ext.critical !== true)
          return;
        extbuf.writeString(ext.name);
        extbuf.writeBuffer(ext.data);
      });
      buf.writeBuffer(extbuf.toBuffer());
      extbuf = new SSHBuffer({});
      exts.forEach(function(ext) {
        if (ext.critical === true)
          return;
        extbuf.writeString(ext.name);
        extbuf.writeBuffer(ext.data);
      });
      buf.writeBuffer(extbuf.toBuffer());
      buf.writeBuffer(Buffer2.alloc(0));
      sub = rfc42532.write(cert.issuerKey);
      buf.writeBuffer(sub);
      if (!noSig)
        buf.writeBuffer(sig.signature.toBuffer("ssh"));
      return buf.toBuffer();
    }
    function getAlg(certType) {
      if (certType === "[email protected]")
        return "rsa";
      if (certType === "[email protected]")
        return "dsa";
      if (certType.match(ECDSA_ALGO))
        return "ecdsa";
      if (certType === "[email protected]")
        return "ed25519";
      throw new Error("Unsupported cert type " + certType);
    }
    function getCertType(key2) {
      if (key2.type === "rsa")
        return "[email protected]";
      if (key2.type === "dsa")
        return "[email protected]";
      if (key2.type === "ecdsa")
        return "ecdsa-sha2-" + key2.curve + "[email protected]";
      if (key2.type === "ed25519")
        return "[email protected]";
      throw new Error("Unsupported key type " + key2.type);
    }
    return opensshCert;
  }
  var x509;
  var hasRequiredX509;
  function requireX509() {
    if (hasRequiredX509)
      return x509;
    hasRequiredX509 = 1;
    x509 = {
      read,
      verify: verify2,
      sign,
      signAsync,
      write
    };
    var assert = requireAssert();
    var asn1 = requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    requireAlgs();
    var utils2 = requireUtils$2();
    requireKey();
    requirePrivateKey();
    requirePem();
    var Identity = requireIdentity();
    var Signature = requireSignature();
    var Certificate = requireCertificate();
    var pkcs82 = requirePkcs8();
    function readMPInt(der, nm) {
      assert.strictEqual(
        der.peek(),
        asn1.Ber.Integer,
        nm + " is not an Integer"
      );
      return utils2.mpNormalize(der.readString(asn1.Ber.Integer, true));
    }
    function verify2(cert, key2) {
      var sig = cert.signatures.x509;
      assert.object(sig, "x509 signature");
      var algParts = sig.algo.split("-");
      if (algParts[0] !== key2.type)
        return false;
      var blob = sig.cache;
      if (blob === void 0) {
        var der = new asn1.BerWriter();
        writeTBSCert(cert, der);
        blob = der.buffer;
      }
      var verifier = key2.createVerify(algParts[1]);
      verifier.write(blob);
      return verifier.verify(sig.signature);
    }
    function Local(i2) {
      return asn1.Ber.Context | asn1.Ber.Constructor | i2;
    }
    function Context(i2) {
      return asn1.Ber.Context | i2;
    }
    var SIGN_ALGS = {
      "rsa-md5": "1.2.840.113549.1.1.4",
      "rsa-sha1": "1.2.840.113549.1.1.5",
      "rsa-sha256": "1.2.840.113549.1.1.11",
      "rsa-sha384": "1.2.840.113549.1.1.12",
      "rsa-sha512": "1.2.840.113549.1.1.13",
      "dsa-sha1": "1.2.840.10040.4.3",
      "dsa-sha256": "2.16.840.1.101.3.4.3.2",
      "ecdsa-sha1": "1.2.840.10045.4.1",
      "ecdsa-sha256": "1.2.840.10045.4.3.2",
      "ecdsa-sha384": "1.2.840.10045.4.3.3",
      "ecdsa-sha512": "1.2.840.10045.4.3.4",
      "ed25519-sha512": "1.3.101.112"
    };
    Object.keys(SIGN_ALGS).forEach(function(k) {
      SIGN_ALGS[SIGN_ALGS[k]] = k;
    });
    SIGN_ALGS["1.3.14.3.2.3"] = "rsa-md5";
    SIGN_ALGS["1.3.14.3.2.29"] = "rsa-sha1";
    var EXTS = {
      "issuerKeyId": "2.5.29.35",
      "altName": "2.5.29.17",
      "basicConstraints": "2.5.29.19",
      "keyUsage": "2.5.29.15",
      "extKeyUsage": "2.5.29.37"
    };
    function read(buf, options) {
      if (typeof buf === "string") {
        buf = Buffer2.from(buf, "binary");
      }
      assert.buffer(buf, "buf");
      var der = new asn1.BerReader(buf);
      der.readSequence();
      if (Math.abs(der.length - der.remain) > 1) {
        throw new Error("DER sequence does not contain whole byte stream");
      }
      var tbsStart = der.offset;
      der.readSequence();
      var sigOffset = der.offset + der.length;
      var tbsEnd = sigOffset;
      if (der.peek() === Local(0)) {
        der.readSequence(Local(0));
        var version2 = der.readInt();
        assert.ok(
          version2 <= 3,
          "only x.509 versions up to v3 supported"
        );
      }
      var cert = {};
      cert.signatures = {};
      var sig = cert.signatures.x509 = {};
      sig.extras = {};
      cert.serial = readMPInt(der, "serial");
      der.readSequence();
      var after = der.offset + der.length;
      var certAlgOid = der.readOID();
      var certAlg = SIGN_ALGS[certAlgOid];
      if (certAlg === void 0)
        throw new Error("unknown signature algorithm " + certAlgOid);
      der._offset = after;
      cert.issuer = Identity.parseAsn1(der);
      der.readSequence();
      cert.validFrom = readDate(der);
      cert.validUntil = readDate(der);
      cert.subjects = [Identity.parseAsn1(der)];
      der.readSequence();
      after = der.offset + der.length;
      cert.subjectKey = pkcs82.readPkcs8(void 0, "public", der);
      der._offset = after;
      if (der.peek() === Local(1)) {
        der.readSequence(Local(1));
        sig.extras.issuerUniqueID = buf.slice(der.offset, der.offset + der.length);
        der._offset += der.length;
      }
      if (der.peek() === Local(2)) {
        der.readSequence(Local(2));
        sig.extras.subjectUniqueID = buf.slice(der.offset, der.offset + der.length);
        der._offset += der.length;
      }
      if (der.peek() === Local(3)) {
        der.readSequence(Local(3));
        var extEnd = der.offset + der.length;
        der.readSequence();
        while (der.offset < extEnd)
          readExtension(cert, buf, der);
        assert.strictEqual(der.offset, extEnd);
      }
      assert.strictEqual(der.offset, sigOffset);
      der.readSequence();
      after = der.offset + der.length;
      var sigAlgOid = der.readOID();
      var sigAlg = SIGN_ALGS[sigAlgOid];
      if (sigAlg === void 0)
        throw new Error("unknown signature algorithm " + sigAlgOid);
      der._offset = after;
      var sigData = der.readString(asn1.Ber.BitString, true);
      if (sigData[0] === 0)
        sigData = sigData.slice(1);
      var algParts = sigAlg.split("-");
      sig.signature = Signature.parse(sigData, algParts[0], "asn1");
      sig.signature.hashAlgorithm = algParts[1];
      sig.algo = sigAlg;
      sig.cache = buf.slice(tbsStart, tbsEnd);
      return new Certificate(cert);
    }
    function readDate(der) {
      if (der.peek() === asn1.Ber.UTCTime) {
        return utcTimeToDate(der.readString(asn1.Ber.UTCTime));
      } else if (der.peek() === asn1.Ber.GeneralizedTime) {
        return gTimeToDate(der.readString(asn1.Ber.GeneralizedTime));
      } else {
        throw new Error("Unsupported date format");
      }
    }
    function writeDate(der, date) {
      if (date.getUTCFullYear() >= 2050 || date.getUTCFullYear() < 1950) {
        der.writeString(dateToGTime(date), asn1.Ber.GeneralizedTime);
      } else {
        der.writeString(dateToUTCTime(date), asn1.Ber.UTCTime);
      }
    }
    var ALTNAME = {
      OtherName: Local(0),
      RFC822Name: Context(1),
      DNSName: Context(2),
      X400Address: Local(3),
      DirectoryName: Local(4),
      EDIPartyName: Local(5),
      URI: Context(6),
      IPAddress: Context(7),
      OID: Context(8)
    };
    var EXTPURPOSE = {
      "serverAuth": "1.3.6.1.5.5.7.3.1",
      "clientAuth": "1.3.6.1.5.5.7.3.2",
      "codeSigning": "1.3.6.1.5.5.7.3.3",
      /* See https://github.com/joyent/oid-docs/blob/master/root.md */
      "joyentDocker": "1.3.6.1.4.1.38678.1.4.1",
      "joyentCmon": "1.3.6.1.4.1.38678.1.4.2"
    };
    var EXTPURPOSE_REV = {};
    Object.keys(EXTPURPOSE).forEach(function(k) {
      EXTPURPOSE_REV[EXTPURPOSE[k]] = k;
    });
    var KEYUSEBITS = [
      "signature",
      "identity",
      "keyEncryption",
      "encryption",
      "keyAgreement",
      "ca",
      "crl"
    ];
    function readExtension(cert, buf, der) {
      der.readSequence();
      var after = der.offset + der.length;
      var extId = der.readOID();
      var id;
      var sig = cert.signatures.x509;
      if (!sig.extras.exts)
        sig.extras.exts = [];
      var critical;
      if (der.peek() === asn1.Ber.Boolean)
        critical = der.readBoolean();
      switch (extId) {
        case EXTS.basicConstraints:
          der.readSequence(asn1.Ber.OctetString);
          der.readSequence();
          var bcEnd = der.offset + der.length;
          var ca = false;
          if (der.peek() === asn1.Ber.Boolean)
            ca = der.readBoolean();
          if (cert.purposes === void 0)
            cert.purposes = [];
          if (ca === true)
            cert.purposes.push("ca");
          var bc = { oid: extId, critical };
          if (der.offset < bcEnd && der.peek() === asn1.Ber.Integer)
            bc.pathLen = der.readInt();
          sig.extras.exts.push(bc);
          break;
        case EXTS.extKeyUsage:
          der.readSequence(asn1.Ber.OctetString);
          der.readSequence();
          if (cert.purposes === void 0)
            cert.purposes = [];
          var ekEnd = der.offset + der.length;
          while (der.offset < ekEnd) {
            var oid = der.readOID();
            cert.purposes.push(EXTPURPOSE_REV[oid] || oid);
          }
          if (cert.purposes.indexOf("serverAuth") !== -1 && cert.purposes.indexOf("clientAuth") === -1) {
            cert.subjects.forEach(function(ide) {
              if (ide.type !== "host") {
                ide.type = "host";
                ide.hostname = ide.uid || ide.email || ide.components[0].value;
              }
            });
          } else if (cert.purposes.indexOf("clientAuth") !== -1 && cert.purposes.indexOf("serverAuth") === -1) {
            cert.subjects.forEach(function(ide) {
              if (ide.type !== "user") {
                ide.type = "user";
                ide.uid = ide.hostname || ide.email || ide.components[0].value;
              }
            });
          }
          sig.extras.exts.push({ oid: extId, critical });
          break;
        case EXTS.keyUsage:
          der.readSequence(asn1.Ber.OctetString);
          var bits = der.readString(asn1.Ber.BitString, true);
          var setBits = readBitField(bits, KEYUSEBITS);
          setBits.forEach(function(bit) {
            if (cert.purposes === void 0)
              cert.purposes = [];
            if (cert.purposes.indexOf(bit) === -1)
              cert.purposes.push(bit);
          });
          sig.extras.exts.push({
            oid: extId,
            critical,
            bits
          });
          break;
        case EXTS.altName:
          der.readSequence(asn1.Ber.OctetString);
          der.readSequence();
          var aeEnd = der.offset + der.length;
          while (der.offset < aeEnd) {
            switch (der.peek()) {
              case ALTNAME.OtherName:
              case ALTNAME.EDIPartyName:
                der.readSequence();
                der._offset += der.length;
                break;
              case ALTNAME.OID:
                der.readOID(ALTNAME.OID);
                break;
              case ALTNAME.RFC822Name:
                var email = der.readString(ALTNAME.RFC822Name);
                id = Identity.forEmail(email);
                if (!cert.subjects[0].equals(id))
                  cert.subjects.push(id);
                break;
              case ALTNAME.DirectoryName:
                der.readSequence(ALTNAME.DirectoryName);
                id = Identity.parseAsn1(der);
                if (!cert.subjects[0].equals(id))
                  cert.subjects.push(id);
                break;
              case ALTNAME.DNSName:
                var host = der.readString(
                  ALTNAME.DNSName
                );
                id = Identity.forHost(host);
                if (!cert.subjects[0].equals(id))
                  cert.subjects.push(id);
                break;
              default:
                der.readString(der.peek());
                break;
            }
          }
          sig.extras.exts.push({ oid: extId, critical });
          break;
        default:
          sig.extras.exts.push({
            oid: extId,
            critical,
            data: der.readString(asn1.Ber.OctetString, true)
          });
          break;
      }
      der._offset = after;
    }
    var UTCTIME_RE = /^([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})?Z$/;
    function utcTimeToDate(t) {
      var m = t.match(UTCTIME_RE);
      assert.ok(m, "timestamps must be in UTC");
      var d2 = /* @__PURE__ */ new Date();
      var thisYear = d2.getUTCFullYear();
      var century = Math.floor(thisYear / 100) * 100;
      var year = parseInt(m[1], 10);
      if (thisYear % 100 < 50 && year >= 60)
        year += century - 1;
      else
        year += century;
      d2.setUTCFullYear(year, parseInt(m[2], 10) - 1, parseInt(m[3], 10));
      d2.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));
      if (m[6] && m[6].length > 0)
        d2.setUTCSeconds(parseInt(m[6], 10));
      return d2;
    }
    var GTIME_RE = /^([0-9]{4})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})?Z$/;
    function gTimeToDate(t) {
      var m = t.match(GTIME_RE);
      assert.ok(m);
      var d2 = /* @__PURE__ */ new Date();
      d2.setUTCFullYear(
        parseInt(m[1], 10),
        parseInt(m[2], 10) - 1,
        parseInt(m[3], 10)
      );
      d2.setUTCHours(parseInt(m[4], 10), parseInt(m[5], 10));
      if (m[6] && m[6].length > 0)
        d2.setUTCSeconds(parseInt(m[6], 10));
      return d2;
    }
    function zeroPad(n, m) {
      if (m === void 0)
        m = 2;
      var s = "" + n;
      while (s.length < m)
        s = "0" + s;
      return s;
    }
    function dateToUTCTime(d2) {
      var s = "";
      s += zeroPad(d2.getUTCFullYear() % 100);
      s += zeroPad(d2.getUTCMonth() + 1);
      s += zeroPad(d2.getUTCDate());
      s += zeroPad(d2.getUTCHours());
      s += zeroPad(d2.getUTCMinutes());
      s += zeroPad(d2.getUTCSeconds());
      s += "Z";
      return s;
    }
    function dateToGTime(d2) {
      var s = "";
      s += zeroPad(d2.getUTCFullYear(), 4);
      s += zeroPad(d2.getUTCMonth() + 1);
      s += zeroPad(d2.getUTCDate());
      s += zeroPad(d2.getUTCHours());
      s += zeroPad(d2.getUTCMinutes());
      s += zeroPad(d2.getUTCSeconds());
      s += "Z";
      return s;
    }
    function sign(cert, key2) {
      if (cert.signatures.x509 === void 0)
        cert.signatures.x509 = {};
      var sig = cert.signatures.x509;
      sig.algo = key2.type + "-" + key2.defaultHashAlgorithm();
      if (SIGN_ALGS[sig.algo] === void 0)
        return false;
      var der = new asn1.BerWriter();
      writeTBSCert(cert, der);
      var blob = der.buffer;
      sig.cache = blob;
      var signer2 = key2.createSign();
      signer2.write(blob);
      cert.signatures.x509.signature = signer2.sign();
      return true;
    }
    function signAsync(cert, signer2, done) {
      if (cert.signatures.x509 === void 0)
        cert.signatures.x509 = {};
      var sig = cert.signatures.x509;
      var der = new asn1.BerWriter();
      writeTBSCert(cert, der);
      var blob = der.buffer;
      sig.cache = blob;
      signer2(blob, function(err, signature2) {
        if (err) {
          done(err);
          return;
        }
        sig.algo = signature2.type + "-" + signature2.hashAlgorithm;
        if (SIGN_ALGS[sig.algo] === void 0) {
          done(new Error('Invalid signing algorithm "' + sig.algo + '"'));
          return;
        }
        sig.signature = signature2;
        done();
      });
    }
    function write(cert, options) {
      var sig = cert.signatures.x509;
      assert.object(sig, "x509 signature");
      var der = new asn1.BerWriter();
      der.startSequence();
      if (sig.cache) {
        der._ensure(sig.cache.length);
        sig.cache.copy(der._buf, der._offset);
        der._offset += sig.cache.length;
      } else {
        writeTBSCert(cert, der);
      }
      der.startSequence();
      der.writeOID(SIGN_ALGS[sig.algo]);
      if (sig.algo.match(/^rsa-/))
        der.writeNull();
      der.endSequence();
      var sigData = sig.signature.toBuffer("asn1");
      var data2 = Buffer2.alloc(sigData.length + 1);
      data2[0] = 0;
      sigData.copy(data2, 1);
      der.writeBuffer(data2, asn1.Ber.BitString);
      der.endSequence();
      return der.buffer;
    }
    function writeTBSCert(cert, der) {
      var sig = cert.signatures.x509;
      assert.object(sig, "x509 signature");
      der.startSequence();
      der.startSequence(Local(0));
      der.writeInt(2);
      der.endSequence();
      der.writeBuffer(utils2.mpNormalize(cert.serial), asn1.Ber.Integer);
      der.startSequence();
      der.writeOID(SIGN_ALGS[sig.algo]);
      if (sig.algo.match(/^rsa-/))
        der.writeNull();
      der.endSequence();
      cert.issuer.toAsn1(der);
      der.startSequence();
      writeDate(der, cert.validFrom);
      writeDate(der, cert.validUntil);
      der.endSequence();
      var subject = cert.subjects[0];
      var altNames = cert.subjects.slice(1);
      subject.toAsn1(der);
      pkcs82.writePkcs8(der, cert.subjectKey);
      if (sig.extras && sig.extras.issuerUniqueID) {
        der.writeBuffer(sig.extras.issuerUniqueID, Local(1));
      }
      if (sig.extras && sig.extras.subjectUniqueID) {
        der.writeBuffer(sig.extras.subjectUniqueID, Local(2));
      }
      if (altNames.length > 0 || subject.type === "host" || cert.purposes !== void 0 && cert.purposes.length > 0 || sig.extras && sig.extras.exts) {
        der.startSequence(Local(3));
        der.startSequence();
        var exts = [];
        if (cert.purposes !== void 0 && cert.purposes.length > 0) {
          exts.push({
            oid: EXTS.basicConstraints,
            critical: true
          });
          exts.push({
            oid: EXTS.keyUsage,
            critical: true
          });
          exts.push({
            oid: EXTS.extKeyUsage,
            critical: true
          });
        }
        exts.push({ oid: EXTS.altName });
        if (sig.extras && sig.extras.exts)
          exts = sig.extras.exts;
        for (var i2 = 0; i2 < exts.length; ++i2) {
          der.startSequence();
          der.writeOID(exts[i2].oid);
          if (exts[i2].critical !== void 0)
            der.writeBoolean(exts[i2].critical);
          if (exts[i2].oid === EXTS.altName) {
            der.startSequence(asn1.Ber.OctetString);
            der.startSequence();
            if (subject.type === "host") {
              der.writeString(
                subject.hostname,
                Context(2)
              );
            }
            for (var j2 = 0; j2 < altNames.length; ++j2) {
              if (altNames[j2].type === "host") {
                der.writeString(
                  altNames[j2].hostname,
                  ALTNAME.DNSName
                );
              } else if (altNames[j2].type === "email") {
                der.writeString(
                  altNames[j2].email,
                  ALTNAME.RFC822Name
                );
              } else {
                der.startSequence(
                  ALTNAME.DirectoryName
                );
                altNames[j2].toAsn1(der);
                der.endSequence();
              }
            }
            der.endSequence();
            der.endSequence();
          } else if (exts[i2].oid === EXTS.basicConstraints) {
            der.startSequence(asn1.Ber.OctetString);
            der.startSequence();
            var ca = cert.purposes.indexOf("ca") !== -1;
            var pathLen = exts[i2].pathLen;
            der.writeBoolean(ca);
            if (pathLen !== void 0)
              der.writeInt(pathLen);
            der.endSequence();
            der.endSequence();
          } else if (exts[i2].oid === EXTS.extKeyUsage) {
            der.startSequence(asn1.Ber.OctetString);
            der.startSequence();
            cert.purposes.forEach(function(purpose) {
              if (purpose === "ca")
                return;
              if (KEYUSEBITS.indexOf(purpose) !== -1)
                return;
              var oid = purpose;
              if (EXTPURPOSE[purpose] !== void 0)
                oid = EXTPURPOSE[purpose];
              der.writeOID(oid);
            });
            der.endSequence();
            der.endSequence();
          } else if (exts[i2].oid === EXTS.keyUsage) {
            der.startSequence(asn1.Ber.OctetString);
            if (exts[i2].bits !== void 0) {
              der.writeBuffer(
                exts[i2].bits,
                asn1.Ber.BitString
              );
            } else {
              var bits = writeBitField(
                cert.purposes,
                KEYUSEBITS
              );
              der.writeBuffer(
                bits,
                asn1.Ber.BitString
              );
            }
            der.endSequence();
          } else {
            der.writeBuffer(
              exts[i2].data,
              asn1.Ber.OctetString
            );
          }
          der.endSequence();
        }
        der.endSequence();
        der.endSequence();
      }
      der.endSequence();
    }
    function readBitField(bits, bitIndex) {
      var bitLen = 8 * (bits.length - 1) - bits[0];
      var setBits = {};
      for (var i2 = 0; i2 < bitLen; ++i2) {
        var byteN = 1 + Math.floor(i2 / 8);
        var bit = 7 - i2 % 8;
        var mask = 1 << bit;
        var bitVal = (bits[byteN] & mask) !== 0;
        var name = bitIndex[i2];
        if (bitVal && typeof name === "string") {
          setBits[name] = true;
        }
      }
      return Object.keys(setBits);
    }
    function writeBitField(setBits, bitIndex) {
      var bitLen = bitIndex.length;
      var blen = Math.ceil(bitLen / 8);
      var unused = blen * 8 - bitLen;
      var bits = Buffer2.alloc(1 + blen);
      bits[0] = unused;
      for (var i2 = 0; i2 < bitLen; ++i2) {
        var byteN = 1 + Math.floor(i2 / 8);
        var bit = 7 - i2 % 8;
        var mask = 1 << bit;
        var name = bitIndex[i2];
        if (name === void 0)
          continue;
        var bitVal = setBits.indexOf(name) !== -1;
        if (bitVal) {
          bits[byteN] |= mask;
        }
      }
      return bits;
    }
    return x509;
  }
  var x509Pem;
  var hasRequiredX509Pem;
  function requireX509Pem() {
    if (hasRequiredX509Pem)
      return x509Pem;
    hasRequiredX509Pem = 1;
    var x5092 = requireX509();
    x509Pem = {
      read,
      verify: x5092.verify,
      sign: x5092.sign,
      write
    };
    var assert = requireAssert();
    requireLib$4();
    var Buffer2 = requireSafer().Buffer;
    requireAlgs();
    requireUtils$2();
    requireKey();
    requirePrivateKey();
    requirePem();
    requireIdentity();
    requireSignature();
    requireCertificate();
    function read(buf, options) {
      if (typeof buf !== "string") {
        assert.buffer(buf, "buf");
        buf = buf.toString("ascii");
      }
      var lines = buf.trim().split(/[\r\n]+/g);
      var m;
      var si = -1;
      while (!m && si < lines.length) {
        m = lines[++si].match(
          /*JSSTYLED*/
          /[-]+[ ]*BEGIN CERTIFICATE[ ]*[-]+/
        );
      }
      assert.ok(m, "invalid PEM header");
      var m2;
      var ei = lines.length;
      while (!m2 && ei > 0) {
        m2 = lines[--ei].match(
          /*JSSTYLED*/
          /[-]+[ ]*END CERTIFICATE[ ]*[-]+/
        );
      }
      assert.ok(m2, "invalid PEM footer");
      lines = lines.slice(si, ei + 1);
      var headers = {};
      while (true) {
        lines = lines.slice(1);
        m = lines[0].match(
          /*JSSTYLED*/
          /^([A-Za-z0-9-]+): (.+)$/
        );
        if (!m)
          break;
        headers[m[1].toLowerCase()] = m[2];
      }
      lines = lines.slice(0, -1).join("");
      buf = Buffer2.from(lines, "base64");
      return x5092.read(buf, options);
    }
    function write(cert, options) {
      var dbuf = x5092.write(cert, options);
      var header = "CERTIFICATE";
      var tmp = dbuf.toString("base64");
      var len = tmp.length + tmp.length / 64 + 18 + 16 + header.length * 2 + 10;
      var buf = Buffer2.alloc(len);
      var o = 0;
      o += buf.write("-----BEGIN " + header + "-----\n", o);
      for (var i2 = 0; i2 < tmp.length; ) {
        var limit = i2 + 64;
        if (limit > tmp.length)
          limit = tmp.length;
        o += buf.write(tmp.slice(i2, limit), o);
        buf[o++] = 10;
        i2 = limit;
      }
      o += buf.write("-----END " + header + "-----\n", o);
      return buf.slice(0, o);
    }
    return x509Pem;
  }
  var certificate;
  var hasRequiredCertificate;
  function requireCertificate() {
    if (hasRequiredCertificate)
      return certificate;
    hasRequiredCertificate = 1;
    certificate = Certificate;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var crypto2 = require$$0$2;
    var Fingerprint = requireFingerprint();
    requireSignature();
    var errs = requireErrors$1();
    var utils2 = requireUtils$2();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var Identity = requireIdentity();
    var formats2 = {};
    formats2["openssh"] = requireOpensshCert();
    formats2["x509"] = requireX509();
    formats2["pem"] = requireX509Pem();
    var CertificateParseError = errs.CertificateParseError;
    var InvalidAlgorithmError = errs.InvalidAlgorithmError;
    function Certificate(opts) {
      assert.object(opts, "options");
      assert.arrayOfObject(opts.subjects, "options.subjects");
      utils2.assertCompatible(
        opts.subjects[0],
        Identity,
        [1, 0],
        "options.subjects"
      );
      utils2.assertCompatible(
        opts.subjectKey,
        Key,
        [1, 0],
        "options.subjectKey"
      );
      utils2.assertCompatible(opts.issuer, Identity, [1, 0], "options.issuer");
      if (opts.issuerKey !== void 0) {
        utils2.assertCompatible(
          opts.issuerKey,
          Key,
          [1, 0],
          "options.issuerKey"
        );
      }
      assert.object(opts.signatures, "options.signatures");
      assert.buffer(opts.serial, "options.serial");
      assert.date(opts.validFrom, "options.validFrom");
      assert.date(opts.validUntil, "optons.validUntil");
      assert.optionalArrayOfString(opts.purposes, "options.purposes");
      this._hashCache = {};
      this.subjects = opts.subjects;
      this.issuer = opts.issuer;
      this.subjectKey = opts.subjectKey;
      this.issuerKey = opts.issuerKey;
      this.signatures = opts.signatures;
      this.serial = opts.serial;
      this.validFrom = opts.validFrom;
      this.validUntil = opts.validUntil;
      this.purposes = opts.purposes;
    }
    Certificate.formats = formats2;
    Certificate.prototype.toBuffer = function(format2, options) {
      if (format2 === void 0)
        format2 = "x509";
      assert.string(format2, "format");
      assert.object(formats2[format2], "formats[format]");
      assert.optionalObject(options, "options");
      return formats2[format2].write(this, options);
    };
    Certificate.prototype.toString = function(format2, options) {
      if (format2 === void 0)
        format2 = "pem";
      return this.toBuffer(format2, options).toString();
    };
    Certificate.prototype.fingerprint = function(algo) {
      if (algo === void 0)
        algo = "sha256";
      assert.string(algo, "algorithm");
      var opts = {
        type: "certificate",
        hash: this.hash(algo),
        algorithm: algo
      };
      return new Fingerprint(opts);
    };
    Certificate.prototype.hash = function(algo) {
      assert.string(algo, "algorithm");
      algo = algo.toLowerCase();
      if (algs2.hashAlgs[algo] === void 0)
        throw new InvalidAlgorithmError(algo);
      if (this._hashCache[algo])
        return this._hashCache[algo];
      var hash = crypto2.createHash(algo).update(this.toBuffer("x509")).digest();
      this._hashCache[algo] = hash;
      return hash;
    };
    Certificate.prototype.isExpired = function(when) {
      if (when === void 0)
        when = /* @__PURE__ */ new Date();
      return !(when.getTime() >= this.validFrom.getTime() && when.getTime() < this.validUntil.getTime());
    };
    Certificate.prototype.isSignedBy = function(issuerCert) {
      utils2.assertCompatible(issuerCert, Certificate, [1, 0], "issuer");
      if (!this.issuer.equals(issuerCert.subjects[0]))
        return false;
      if (this.issuer.purposes && this.issuer.purposes.length > 0 && this.issuer.purposes.indexOf("ca") === -1) {
        return false;
      }
      return this.isSignedByKey(issuerCert.subjectKey);
    };
    Certificate.prototype.getExtension = function(keyOrOid) {
      assert.string(keyOrOid, "keyOrOid");
      var ext = this.getExtensions().filter(function(maybeExt) {
        if (maybeExt.format === "x509")
          return maybeExt.oid === keyOrOid;
        if (maybeExt.format === "openssh")
          return maybeExt.name === keyOrOid;
        return false;
      })[0];
      return ext;
    };
    Certificate.prototype.getExtensions = function() {
      var exts = [];
      var x5092 = this.signatures.x509;
      if (x5092 && x5092.extras && x5092.extras.exts) {
        x5092.extras.exts.forEach(function(ext) {
          ext.format = "x509";
          exts.push(ext);
        });
      }
      var openssh = this.signatures.openssh;
      if (openssh && openssh.exts) {
        openssh.exts.forEach(function(ext) {
          ext.format = "openssh";
          exts.push(ext);
        });
      }
      return exts;
    };
    Certificate.prototype.isSignedByKey = function(issuerKey) {
      utils2.assertCompatible(issuerKey, Key, [1, 2], "issuerKey");
      if (this.issuerKey !== void 0) {
        return this.issuerKey.fingerprint("sha512").matches(issuerKey);
      }
      var fmt = Object.keys(this.signatures)[0];
      var valid = formats2[fmt].verify(this, issuerKey);
      if (valid)
        this.issuerKey = issuerKey;
      return valid;
    };
    Certificate.prototype.signWith = function(key2) {
      utils2.assertCompatible(key2, PrivateKey, [1, 2], "key");
      var fmts = Object.keys(formats2);
      var didOne = false;
      for (var i2 = 0; i2 < fmts.length; ++i2) {
        if (fmts[i2] !== "pem") {
          var ret = formats2[fmts[i2]].sign(this, key2);
          if (ret === true)
            didOne = true;
        }
      }
      if (!didOne) {
        throw new Error("Failed to sign the certificate for any available certificate formats");
      }
    };
    Certificate.createSelfSigned = function(subjectOrSubjects, key2, options) {
      var subjects;
      if (Array.isArray(subjectOrSubjects))
        subjects = subjectOrSubjects;
      else
        subjects = [subjectOrSubjects];
      assert.arrayOfObject(subjects);
      subjects.forEach(function(subject) {
        utils2.assertCompatible(subject, Identity, [1, 0], "subject");
      });
      utils2.assertCompatible(key2, PrivateKey, [1, 2], "private key");
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      assert.optionalObject(options.validFrom, "options.validFrom");
      assert.optionalObject(options.validUntil, "options.validUntil");
      var validFrom = options.validFrom;
      var validUntil = options.validUntil;
      if (validFrom === void 0)
        validFrom = /* @__PURE__ */ new Date();
      if (validUntil === void 0) {
        assert.optionalNumber(options.lifetime, "options.lifetime");
        var lifetime = options.lifetime;
        if (lifetime === void 0)
          lifetime = 10 * 365 * 24 * 3600;
        validUntil = /* @__PURE__ */ new Date();
        validUntil.setTime(validUntil.getTime() + lifetime * 1e3);
      }
      assert.optionalBuffer(options.serial, "options.serial");
      var serial = options.serial;
      if (serial === void 0)
        serial = Buffer2.from("0000000000000001", "hex");
      var purposes = options.purposes;
      if (purposes === void 0)
        purposes = [];
      if (purposes.indexOf("signature") === -1)
        purposes.push("signature");
      if (purposes.indexOf("ca") === -1)
        purposes.push("ca");
      if (purposes.indexOf("crl") === -1)
        purposes.push("crl");
      if (purposes.length <= 3) {
        var hostSubjects = subjects.filter(function(subject) {
          return subject.type === "host";
        });
        var userSubjects = subjects.filter(function(subject) {
          return subject.type === "user";
        });
        if (hostSubjects.length > 0) {
          if (purposes.indexOf("serverAuth") === -1)
            purposes.push("serverAuth");
        }
        if (userSubjects.length > 0) {
          if (purposes.indexOf("clientAuth") === -1)
            purposes.push("clientAuth");
        }
        if (userSubjects.length > 0 || hostSubjects.length > 0) {
          if (purposes.indexOf("keyAgreement") === -1)
            purposes.push("keyAgreement");
          if (key2.type === "rsa" && purposes.indexOf("encryption") === -1)
            purposes.push("encryption");
        }
      }
      var cert = new Certificate({
        subjects,
        issuer: subjects[0],
        subjectKey: key2.toPublic(),
        issuerKey: key2.toPublic(),
        signatures: {},
        serial,
        validFrom,
        validUntil,
        purposes
      });
      cert.signWith(key2);
      return cert;
    };
    Certificate.create = function(subjectOrSubjects, key2, issuer, issuerKey, options) {
      var subjects;
      if (Array.isArray(subjectOrSubjects))
        subjects = subjectOrSubjects;
      else
        subjects = [subjectOrSubjects];
      assert.arrayOfObject(subjects);
      subjects.forEach(function(subject) {
        utils2.assertCompatible(subject, Identity, [1, 0], "subject");
      });
      utils2.assertCompatible(key2, Key, [1, 0], "key");
      if (PrivateKey.isPrivateKey(key2))
        key2 = key2.toPublic();
      utils2.assertCompatible(issuer, Identity, [1, 0], "issuer");
      utils2.assertCompatible(issuerKey, PrivateKey, [1, 2], "issuer key");
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      assert.optionalObject(options.validFrom, "options.validFrom");
      assert.optionalObject(options.validUntil, "options.validUntil");
      var validFrom = options.validFrom;
      var validUntil = options.validUntil;
      if (validFrom === void 0)
        validFrom = /* @__PURE__ */ new Date();
      if (validUntil === void 0) {
        assert.optionalNumber(options.lifetime, "options.lifetime");
        var lifetime = options.lifetime;
        if (lifetime === void 0)
          lifetime = 10 * 365 * 24 * 3600;
        validUntil = /* @__PURE__ */ new Date();
        validUntil.setTime(validUntil.getTime() + lifetime * 1e3);
      }
      assert.optionalBuffer(options.serial, "options.serial");
      var serial = options.serial;
      if (serial === void 0)
        serial = Buffer2.from("0000000000000001", "hex");
      var purposes = options.purposes;
      if (purposes === void 0)
        purposes = [];
      if (purposes.indexOf("signature") === -1)
        purposes.push("signature");
      if (options.ca === true) {
        if (purposes.indexOf("ca") === -1)
          purposes.push("ca");
        if (purposes.indexOf("crl") === -1)
          purposes.push("crl");
      }
      var hostSubjects = subjects.filter(function(subject) {
        return subject.type === "host";
      });
      var userSubjects = subjects.filter(function(subject) {
        return subject.type === "user";
      });
      if (hostSubjects.length > 0) {
        if (purposes.indexOf("serverAuth") === -1)
          purposes.push("serverAuth");
      }
      if (userSubjects.length > 0) {
        if (purposes.indexOf("clientAuth") === -1)
          purposes.push("clientAuth");
      }
      if (userSubjects.length > 0 || hostSubjects.length > 0) {
        if (purposes.indexOf("keyAgreement") === -1)
          purposes.push("keyAgreement");
        if (key2.type === "rsa" && purposes.indexOf("encryption") === -1)
          purposes.push("encryption");
      }
      var cert = new Certificate({
        subjects,
        issuer,
        subjectKey: key2,
        issuerKey: issuerKey.toPublic(),
        signatures: {},
        serial,
        validFrom,
        validUntil,
        purposes
      });
      cert.signWith(issuerKey);
      return cert;
    };
    Certificate.parse = function(data2, format2, options) {
      if (typeof data2 !== "string")
        assert.buffer(data2, "data");
      if (format2 === void 0)
        format2 = "auto";
      assert.string(format2, "format");
      if (typeof options === "string")
        options = { filename: options };
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      assert.optionalString(options.filename, "options.filename");
      if (options.filename === void 0)
        options.filename = "(unnamed)";
      assert.object(formats2[format2], "formats[format]");
      try {
        var k = formats2[format2].read(data2, options);
        return k;
      } catch (e) {
        throw new CertificateParseError(options.filename, format2, e);
      }
    };
    Certificate.isCertificate = function(obj, ver) {
      return utils2.isCompatible(obj, Certificate, ver);
    };
    Certificate.prototype._sshpkApiVersion = [1, 1];
    Certificate._oldVersionDetect = function(obj) {
      return [1, 0];
    };
    return certificate;
  }
  var fingerprint;
  var hasRequiredFingerprint;
  function requireFingerprint() {
    if (hasRequiredFingerprint)
      return fingerprint;
    hasRequiredFingerprint = 1;
    fingerprint = Fingerprint;
    var assert = requireAssert();
    var Buffer2 = requireSafer().Buffer;
    var algs2 = requireAlgs();
    var crypto2 = require$$0$2;
    var errs = requireErrors$1();
    var Key = requireKey();
    var PrivateKey = requirePrivateKey();
    var Certificate = requireCertificate();
    var utils2 = requireUtils$2();
    var FingerprintFormatError = errs.FingerprintFormatError;
    var InvalidAlgorithmError = errs.InvalidAlgorithmError;
    function Fingerprint(opts) {
      assert.object(opts, "options");
      assert.string(opts.type, "options.type");
      assert.buffer(opts.hash, "options.hash");
      assert.string(opts.algorithm, "options.algorithm");
      this.algorithm = opts.algorithm.toLowerCase();
      if (algs2.hashAlgs[this.algorithm] !== true)
        throw new InvalidAlgorithmError(this.algorithm);
      this.hash = opts.hash;
      this.type = opts.type;
      this.hashType = opts.hashType;
    }
    Fingerprint.prototype.toString = function(format2) {
      if (format2 === void 0) {
        if (this.algorithm === "md5" || this.hashType === "spki")
          format2 = "hex";
        else
          format2 = "base64";
      }
      assert.string(format2);
      switch (format2) {
        case "hex":
          if (this.hashType === "spki")
            return this.hash.toString("hex");
          return addColons(this.hash.toString("hex"));
        case "base64":
          if (this.hashType === "spki")
            return this.hash.toString("base64");
          return sshBase64Format(
            this.algorithm,
            this.hash.toString("base64")
          );
        default:
          throw new FingerprintFormatError(void 0, format2);
      }
    };
    Fingerprint.prototype.matches = function(other) {
      assert.object(other, "key or certificate");
      if (this.type === "key" && this.hashType !== "ssh") {
        utils2.assertCompatible(other, Key, [1, 7], "key with spki");
        if (PrivateKey.isPrivateKey(other)) {
          utils2.assertCompatible(
            other,
            PrivateKey,
            [1, 6],
            "privatekey with spki support"
          );
        }
      } else if (this.type === "key") {
        utils2.assertCompatible(other, Key, [1, 0], "key");
      } else {
        utils2.assertCompatible(
          other,
          Certificate,
          [1, 0],
          "certificate"
        );
      }
      var theirHash = other.hash(this.algorithm, this.hashType);
      var theirHash2 = crypto2.createHash(this.algorithm).update(theirHash).digest("base64");
      if (this.hash2 === void 0)
        this.hash2 = crypto2.createHash(this.algorithm).update(this.hash).digest("base64");
      return this.hash2 === theirHash2;
    };
    var base64RE = /^[A-Za-z0-9+\/=]+$/;
    var hexRE = /^[a-fA-F0-9]+$/;
    Fingerprint.parse = function(fp, options) {
      assert.string(fp, "fingerprint");
      var alg, hash, enAlgs;
      if (Array.isArray(options)) {
        enAlgs = options;
        options = {};
      }
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      if (options.enAlgs !== void 0)
        enAlgs = options.enAlgs;
      if (options.algorithms !== void 0)
        enAlgs = options.algorithms;
      assert.optionalArrayOfString(enAlgs, "algorithms");
      var hashType = "ssh";
      if (options.hashType !== void 0)
        hashType = options.hashType;
      assert.string(hashType, "options.hashType");
      var parts = fp.split(":");
      if (parts.length == 2) {
        alg = parts[0].toLowerCase();
        if (!base64RE.test(parts[1]))
          throw new FingerprintFormatError(fp);
        try {
          hash = Buffer2.from(parts[1], "base64");
        } catch (e) {
          throw new FingerprintFormatError(fp);
        }
      } else if (parts.length > 2) {
        alg = "md5";
        if (parts[0].toLowerCase() === "md5")
          parts = parts.slice(1);
        parts = parts.map(function(p) {
          while (p.length < 2)
            p = "0" + p;
          if (p.length > 2)
            throw new FingerprintFormatError(fp);
          return p;
        });
        parts = parts.join("");
        if (!hexRE.test(parts) || parts.length % 2 !== 0)
          throw new FingerprintFormatError(fp);
        try {
          hash = Buffer2.from(parts, "hex");
        } catch (e) {
          throw new FingerprintFormatError(fp);
        }
      } else {
        if (hexRE.test(fp)) {
          hash = Buffer2.from(fp, "hex");
        } else if (base64RE.test(fp)) {
          hash = Buffer2.from(fp, "base64");
        } else {
          throw new FingerprintFormatError(fp);
        }
        switch (hash.length) {
          case 32:
            alg = "sha256";
            break;
          case 16:
            alg = "md5";
            break;
          case 20:
            alg = "sha1";
            break;
          case 64:
            alg = "sha512";
            break;
          default:
            throw new FingerprintFormatError(fp);
        }
        if (options.hashType === void 0)
          hashType = "spki";
      }
      if (alg === void 0)
        throw new FingerprintFormatError(fp);
      if (algs2.hashAlgs[alg] === void 0)
        throw new InvalidAlgorithmError(alg);
      if (enAlgs !== void 0) {
        enAlgs = enAlgs.map(function(a2) {
          return a2.toLowerCase();
        });
        if (enAlgs.indexOf(alg) === -1)
          throw new InvalidAlgorithmError(alg);
      }
      return new Fingerprint({
        algorithm: alg,
        hash,
        type: options.type || "key",
        hashType
      });
    };
    function addColons(s) {
      return s.replace(/(.{2})(?=.)/g, "$1:");
    }
    function base64Strip(s) {
      return s.replace(/=*$/, "");
    }
    function sshBase64Format(alg, h) {
      return alg.toUpperCase() + ":" + base64Strip(h);
    }
    Fingerprint.isFingerprint = function(obj, ver) {
      return utils2.isCompatible(obj, Fingerprint, ver);
    };
    Fingerprint.prototype._sshpkApiVersion = [1, 2];
    Fingerprint._oldVersionDetect = function(obj) {
      assert.func(obj.toString);
      assert.func(obj.matches);
      return [1, 0];
    };
    return fingerprint;
  }
  var key;
  var hasRequiredKey;
  function requireKey() {
    if (hasRequiredKey)
      return key;
    hasRequiredKey = 1;
    key = Key;
    var assert = requireAssert();
    var algs2 = requireAlgs();
    var crypto2 = require$$0$2;
    var Fingerprint = requireFingerprint();
    var Signature = requireSignature();
    var DiffieHellman = requireDhe().DiffieHellman;
    var errs = requireErrors$1();
    var utils2 = requireUtils$2();
    var PrivateKey = requirePrivateKey();
    var edCompat2;
    try {
      edCompat2 = requireEdCompat();
    } catch (e) {
    }
    var InvalidAlgorithmError = errs.InvalidAlgorithmError;
    var KeyParseError = errs.KeyParseError;
    var formats2 = {};
    formats2["auto"] = requireAuto();
    formats2["pem"] = requirePem();
    formats2["pkcs1"] = requirePkcs1();
    formats2["pkcs8"] = requirePkcs8();
    formats2["rfc4253"] = requireRfc4253();
    formats2["ssh"] = requireSsh();
    formats2["ssh-private"] = requireSshPrivate();
    formats2["openssh"] = formats2["ssh-private"];
    formats2["dnssec"] = requireDnssec();
    formats2["putty"] = requirePutty();
    formats2["ppk"] = formats2["putty"];
    function Key(opts) {
      assert.object(opts, "options");
      assert.arrayOfObject(opts.parts, "options.parts");
      assert.string(opts.type, "options.type");
      assert.optionalString(opts.comment, "options.comment");
      var algInfo = algs2.info[opts.type];
      if (typeof algInfo !== "object")
        throw new InvalidAlgorithmError(opts.type);
      var partLookup = {};
      for (var i2 = 0; i2 < opts.parts.length; ++i2) {
        var part = opts.parts[i2];
        partLookup[part.name] = part;
      }
      this.type = opts.type;
      this.parts = opts.parts;
      this.part = partLookup;
      this.comment = void 0;
      this.source = opts.source;
      this._rfc4253Cache = opts._rfc4253Cache;
      this._hashCache = {};
      var sz;
      this.curve = void 0;
      if (this.type === "ecdsa") {
        var curve = this.part.curve.data.toString();
        this.curve = curve;
        sz = algs2.curves[curve].size;
      } else if (this.type === "ed25519" || this.type === "curve25519") {
        sz = 256;
        this.curve = "curve25519";
      } else {
        var szPart = this.part[algInfo.sizePart];
        sz = szPart.data.length;
        sz = sz * 8 - utils2.countZeros(szPart.data);
      }
      this.size = sz;
    }
    Key.formats = formats2;
    Key.prototype.toBuffer = function(format2, options) {
      if (format2 === void 0)
        format2 = "ssh";
      assert.string(format2, "format");
      assert.object(formats2[format2], "formats[format]");
      assert.optionalObject(options, "options");
      if (format2 === "rfc4253") {
        if (this._rfc4253Cache === void 0)
          this._rfc4253Cache = formats2["rfc4253"].write(this);
        return this._rfc4253Cache;
      }
      return formats2[format2].write(this, options);
    };
    Key.prototype.toString = function(format2, options) {
      return this.toBuffer(format2, options).toString();
    };
    Key.prototype.hash = function(algo, type2) {
      assert.string(algo, "algorithm");
      assert.optionalString(type2, "type");
      if (type2 === void 0)
        type2 = "ssh";
      algo = algo.toLowerCase();
      if (algs2.hashAlgs[algo] === void 0)
        throw new InvalidAlgorithmError(algo);
      var cacheKey = algo + "||" + type2;
      if (this._hashCache[cacheKey])
        return this._hashCache[cacheKey];
      var buf;
      if (type2 === "ssh") {
        buf = this.toBuffer("rfc4253");
      } else if (type2 === "spki") {
        buf = formats2.pkcs8.pkcs8ToBuffer(this);
      } else {
        throw new Error("Hash type " + type2 + " not supported");
      }
      var hash = crypto2.createHash(algo).update(buf).digest();
      this._hashCache[cacheKey] = hash;
      return hash;
    };
    Key.prototype.fingerprint = function(algo, type2) {
      if (algo === void 0)
        algo = "sha256";
      if (type2 === void 0)
        type2 = "ssh";
      assert.string(algo, "algorithm");
      assert.string(type2, "type");
      var opts = {
        type: "key",
        hash: this.hash(algo, type2),
        algorithm: algo,
        hashType: type2
      };
      return new Fingerprint(opts);
    };
    Key.prototype.defaultHashAlgorithm = function() {
      var hashAlgo = "sha1";
      if (this.type === "rsa")
        hashAlgo = "sha256";
      if (this.type === "dsa" && this.size > 1024)
        hashAlgo = "sha256";
      if (this.type === "ed25519")
        hashAlgo = "sha512";
      if (this.type === "ecdsa") {
        if (this.size <= 256)
          hashAlgo = "sha256";
        else if (this.size <= 384)
          hashAlgo = "sha384";
        else
          hashAlgo = "sha512";
      }
      return hashAlgo;
    };
    Key.prototype.createVerify = function(hashAlgo) {
      if (hashAlgo === void 0)
        hashAlgo = this.defaultHashAlgorithm();
      assert.string(hashAlgo, "hash algorithm");
      if (this.type === "ed25519" && edCompat2 !== void 0)
        return new edCompat2.Verifier(this, hashAlgo);
      if (this.type === "curve25519")
        throw new Error("Curve25519 keys are not suitable for signing or verification");
      var v, nm, err;
      try {
        nm = hashAlgo.toUpperCase();
        v = crypto2.createVerify(nm);
      } catch (e) {
        err = e;
      }
      if (v === void 0 || err instanceof Error && err.message.match(/Unknown message digest/)) {
        nm = "RSA-";
        nm += hashAlgo.toUpperCase();
        v = crypto2.createVerify(nm);
      }
      assert.ok(v, "failed to create verifier");
      var oldVerify = v.verify.bind(v);
      var key2 = this.toBuffer("pkcs8");
      var curve = this.curve;
      var self2 = this;
      v.verify = function(signature2, fmt) {
        if (Signature.isSignature(signature2, [2, 0])) {
          if (signature2.type !== self2.type)
            return false;
          if (signature2.hashAlgorithm && signature2.hashAlgorithm !== hashAlgo)
            return false;
          if (signature2.curve && self2.type === "ecdsa" && signature2.curve !== curve)
            return false;
          return oldVerify(key2, signature2.toBuffer("asn1"));
        } else if (typeof signature2 === "string" || Buffer.isBuffer(signature2)) {
          return oldVerify(key2, signature2, fmt);
        } else if (Signature.isSignature(signature2, [1, 0])) {
          throw new Error("signature was created by too old a version of sshpk and cannot be verified");
        } else {
          throw new TypeError("signature must be a string, Buffer, or Signature object");
        }
      };
      return v;
    };
    Key.prototype.createDiffieHellman = function() {
      if (this.type === "rsa")
        throw new Error("RSA keys do not support Diffie-Hellman");
      return new DiffieHellman(this);
    };
    Key.prototype.createDH = Key.prototype.createDiffieHellman;
    Key.parse = function(data2, format2, options) {
      if (typeof data2 !== "string")
        assert.buffer(data2, "data");
      if (format2 === void 0)
        format2 = "auto";
      assert.string(format2, "format");
      if (typeof options === "string")
        options = { filename: options };
      assert.optionalObject(options, "options");
      if (options === void 0)
        options = {};
      assert.optionalString(options.filename, "options.filename");
      if (options.filename === void 0)
        options.filename = "(unnamed)";
      assert.object(formats2[format2], "formats[format]");
      try {
        var k = formats2[format2].read(data2, options);
        if (k instanceof PrivateKey)
          k = k.toPublic();
        if (!k.comment)
          k.comment = options.filename;
        return k;
      } catch (e) {
        if (e.name === "KeyEncryptedError")
          throw e;
        throw new KeyParseError(options.filename, format2, e);
      }
    };
    Key.isKey = function(obj, ver) {
      return utils2.isCompatible(obj, Key, ver);
    };
    Key.prototype._sshpkApiVersion = [1, 7];
    Key._oldVersionDetect = function(obj) {
      assert.func(obj.toBuffer);
      assert.func(obj.fingerprint);
      if (obj.createDH)
        return [1, 4];
      if (obj.defaultHashAlgorithm)
        return [1, 3];
      if (obj.formats["auto"])
        return [1, 2];
      if (obj.formats["pkcs1"])
        return [1, 1];
      return [1, 0];
    };
    return key;
  }
  var lib$3;
  var hasRequiredLib$3;
  function requireLib$3() {
    if (hasRequiredLib$3)
      return lib$3;
    hasRequiredLib$3 = 1;
    var Key = requireKey();
    var Fingerprint = requireFingerprint();
    var Signature = requireSignature();
    var PrivateKey = requirePrivateKey();
    var Certificate = requireCertificate();
    var Identity = requireIdentity();
    var errs = requireErrors$1();
    lib$3 = {
      /* top-level classes */
      Key,
      parseKey: Key.parse,
      Fingerprint,
      parseFingerprint: Fingerprint.parse,
      Signature,
      parseSignature: Signature.parse,
      PrivateKey,
      parsePrivateKey: PrivateKey.parse,
      generatePrivateKey: PrivateKey.generate,
      Certificate,
      parseCertificate: Certificate.parse,
      createSelfSignedCertificate: Certificate.createSelfSigned,
      createCertificate: Certificate.create,
      Identity,
      identityFromDN: Identity.parseDN,
      identityForHost: Identity.forHost,
      identityForUser: Identity.forUser,
      identityForEmail: Identity.forEmail,
      identityFromArray: Identity.fromArray,
      /* errors */
      FingerprintFormatError: errs.FingerprintFormatError,
      InvalidAlgorithmError: errs.InvalidAlgorithmError,
      KeyParseError: errs.KeyParseError,
      SignatureParseError: errs.SignatureParseError,
      KeyEncryptedError: errs.KeyEncryptedError,
      CertificateParseError: errs.CertificateParseError
    };
    return lib$3;
  }
  var utils$1;
  var hasRequiredUtils$1;
  function requireUtils$1() {
    if (hasRequiredUtils$1)
      return utils$1;
    hasRequiredUtils$1 = 1;
    var assert = requireAssert();
    var sshpk = requireLib$3();
    var util2 = require$$0$2;
    var HASH_ALGOS = {
      "sha1": true,
      "sha256": true,
      "sha512": true
    };
    var PK_ALGOS = {
      "rsa": true,
      "dsa": true,
      "ecdsa": true
    };
    function HttpSignatureError(message, caller) {
      if (Error.captureStackTrace)
        Error.captureStackTrace(this, caller || HttpSignatureError);
      this.message = message;
      this.name = caller.name;
    }
    util2.inherits(HttpSignatureError, Error);
    function InvalidAlgorithmError(message) {
      HttpSignatureError.call(this, message, InvalidAlgorithmError);
    }
    util2.inherits(InvalidAlgorithmError, HttpSignatureError);
    function validateAlgorithm(algorithm) {
      var alg = algorithm.toLowerCase().split("-");
      if (alg.length !== 2) {
        throw new InvalidAlgorithmError(alg[0].toUpperCase() + " is not a valid algorithm");
      }
      if (alg[0] !== "hmac" && !PK_ALGOS[alg[0]]) {
        throw new InvalidAlgorithmError(alg[0].toUpperCase() + " type keys are not supported");
      }
      if (!HASH_ALGOS[alg[1]]) {
        throw new InvalidAlgorithmError(alg[1].toUpperCase() + " is not a supported hash algorithm");
      }
      return alg;
    }
    utils$1 = {
      HASH_ALGOS,
      PK_ALGOS,
      HttpSignatureError,
      InvalidAlgorithmError,
      validateAlgorithm,
      /**
       * Converts an OpenSSH public key (rsa only) to a PKCS#8 PEM file.
       *
       * The intent of this module is to interoperate with OpenSSL only,
       * specifically the node crypto module's `verify` method.
       *
       * @param {String} key an OpenSSH public key.
       * @return {String} PEM encoded form of the RSA public key.
       * @throws {TypeError} on bad input.
       * @throws {Error} on invalid ssh key formatted data.
       */
      sshKeyToPEM: function sshKeyToPEM(key2) {
        assert.string(key2, "ssh_key");
        var k = sshpk.parseKey(key2, "ssh");
        return k.toString("pem");
      },
      /**
       * Generates an OpenSSH fingerprint from an ssh public key.
       *
       * @param {String} key an OpenSSH public key.
       * @return {String} key fingerprint.
       * @throws {TypeError} on bad input.
       * @throws {Error} if what you passed doesn't look like an ssh public key.
       */
      fingerprint: function fingerprint2(key2) {
        assert.string(key2, "ssh_key");
        var k = sshpk.parseKey(key2, "ssh");
        return k.fingerprint("md5").toString("hex");
      },
      /**
       * Converts a PKGCS#8 PEM file to an OpenSSH public key (rsa)
       *
       * The reverse of the above function.
       */
      pemToRsaSSHKey: function pemToRsaSSHKey(pem2, comment2) {
        assert.equal("string", typeof pem2, "typeof pem");
        var k = sshpk.parseKey(pem2, "pem");
        k.comment = comment2;
        return k.toString("ssh");
      }
    };
    return utils$1;
  }
  var parser;
  var hasRequiredParser;
  function requireParser() {
    if (hasRequiredParser)
      return parser;
    hasRequiredParser = 1;
    var assert = requireAssert();
    var util2 = require$$0$2;
    var utils2 = requireUtils$1();
    utils2.HASH_ALGOS;
    utils2.PK_ALGOS;
    var HttpSignatureError = utils2.HttpSignatureError;
    var InvalidAlgorithmError = utils2.InvalidAlgorithmError;
    var validateAlgorithm = utils2.validateAlgorithm;
    var State = {
      New: 0,
      Params: 1
    };
    var ParamsState = {
      Name: 0,
      Quote: 1,
      Value: 2,
      Comma: 3
    };
    function ExpiredRequestError(message) {
      HttpSignatureError.call(this, message, ExpiredRequestError);
    }
    util2.inherits(ExpiredRequestError, HttpSignatureError);
    function InvalidHeaderError(message) {
      HttpSignatureError.call(this, message, InvalidHeaderError);
    }
    util2.inherits(InvalidHeaderError, HttpSignatureError);
    function InvalidParamsError(message) {
      HttpSignatureError.call(this, message, InvalidParamsError);
    }
    util2.inherits(InvalidParamsError, HttpSignatureError);
    function MissingHeaderError(message) {
      HttpSignatureError.call(this, message, MissingHeaderError);
    }
    util2.inherits(MissingHeaderError, HttpSignatureError);
    function StrictParsingError(message) {
      HttpSignatureError.call(this, message, StrictParsingError);
    }
    util2.inherits(StrictParsingError, HttpSignatureError);
    parser = {
      /**
       * Parses the 'Authorization' header out of an http.ServerRequest object.
       *
       * Note that this API will fully validate the Authorization header, and throw
       * on any error.  It will not however check the signature, or the keyId format
       * as those are specific to your environment.  You can use the options object
       * to pass in extra constraints.
       *
       * As a response object you can expect this:
       *
       *     {
       *       "scheme": "Signature",
       *       "params": {
       *         "keyId": "foo",
       *         "algorithm": "rsa-sha256",
       *         "headers": [
       *           "date" or "x-date",
       *           "digest"
       *         ],
       *         "signature": "base64"
       *       },
       *       "signingString": "ready to be passed to crypto.verify()"
       *     }
       *
       * @param {Object} request an http.ServerRequest.
       * @param {Object} options an optional options object with:
       *                   - clockSkew: allowed clock skew in seconds (default 300).
       *                   - headers: required header names (def: date or x-date)
       *                   - algorithms: algorithms to support (default: all).
       *                   - strict: should enforce latest spec parsing
       *                             (default: false).
       * @return {Object} parsed out object (see above).
       * @throws {TypeError} on invalid input.
       * @throws {InvalidHeaderError} on an invalid Authorization header error.
       * @throws {InvalidParamsError} if the params in the scheme are invalid.
       * @throws {MissingHeaderError} if the params indicate a header not present,
       *                              either in the request headers from the params,
       *                              or not in the params from a required header
       *                              in options.
       * @throws {StrictParsingError} if old attributes are used in strict parsing
       *                              mode.
       * @throws {ExpiredRequestError} if the value of date or x-date exceeds skew.
       */
      parseRequest: function parseRequest(request2, options) {
        assert.object(request2, "request");
        assert.object(request2.headers, "request.headers");
        if (options === void 0) {
          options = {};
        }
        if (options.headers === void 0) {
          options.headers = [request2.headers["x-date"] ? "x-date" : "date"];
        }
        assert.object(options, "options");
        assert.arrayOfString(options.headers, "options.headers");
        assert.optionalFinite(options.clockSkew, "options.clockSkew");
        var authzHeaderName = options.authorizationHeaderName || "authorization";
        if (!request2.headers[authzHeaderName]) {
          throw new MissingHeaderError("no " + authzHeaderName + " header present in the request");
        }
        options.clockSkew = options.clockSkew || 300;
        var i2 = 0;
        var state = State.New;
        var substate = ParamsState.Name;
        var tmpName = "";
        var tmpValue = "";
        var parsed = {
          scheme: "",
          params: {},
          signingString: ""
        };
        var authz = request2.headers[authzHeaderName];
        for (i2 = 0; i2 < authz.length; i2++) {
          var c2 = authz.charAt(i2);
          switch (Number(state)) {
            case State.New:
              if (c2 !== " ")
                parsed.scheme += c2;
              else
                state = State.Params;
              break;
            case State.Params:
              switch (Number(substate)) {
                case ParamsState.Name:
                  var code = c2.charCodeAt(0);
                  if (code >= 65 && code <= 90 || // A-Z
                  code >= 97 && code <= 122) {
                    tmpName += c2;
                  } else if (c2 === "=") {
                    if (tmpName.length === 0)
                      throw new InvalidHeaderError("bad param format");
                    substate = ParamsState.Quote;
                  } else {
                    throw new InvalidHeaderError("bad param format");
                  }
                  break;
                case ParamsState.Quote:
                  if (c2 === '"') {
                    tmpValue = "";
                    substate = ParamsState.Value;
                  } else {
                    throw new InvalidHeaderError("bad param format");
                  }
                  break;
                case ParamsState.Value:
                  if (c2 === '"') {
                    parsed.params[tmpName] = tmpValue;
                    substate = ParamsState.Comma;
                  } else {
                    tmpValue += c2;
                  }
                  break;
                case ParamsState.Comma:
                  if (c2 === ",") {
                    tmpName = "";
                    substate = ParamsState.Name;
                  } else {
                    throw new InvalidHeaderError("bad param format");
                  }
                  break;
                default:
                  throw new Error("Invalid substate");
              }
              break;
            default:
              throw new Error("Invalid substate");
          }
        }
        if (!parsed.params.headers || parsed.params.headers === "") {
          if (request2.headers["x-date"]) {
            parsed.params.headers = ["x-date"];
          } else {
            parsed.params.headers = ["date"];
          }
        } else {
          parsed.params.headers = parsed.params.headers.split(" ");
        }
        if (!parsed.scheme || parsed.scheme !== "Signature")
          throw new InvalidHeaderError('scheme was not "Signature"');
        if (!parsed.params.keyId)
          throw new InvalidHeaderError("keyId was not specified");
        if (!parsed.params.algorithm)
          throw new InvalidHeaderError("algorithm was not specified");
        if (!parsed.params.signature)
          throw new InvalidHeaderError("signature was not specified");
        parsed.params.algorithm = parsed.params.algorithm.toLowerCase();
        try {
          validateAlgorithm(parsed.params.algorithm);
        } catch (e) {
          if (e instanceof InvalidAlgorithmError)
            throw new InvalidParamsError(parsed.params.algorithm + " is not supported");
          else
            throw e;
        }
        for (i2 = 0; i2 < parsed.params.headers.length; i2++) {
          var h = parsed.params.headers[i2].toLowerCase();
          parsed.params.headers[i2] = h;
          if (h === "request-line") {
            if (!options.strict) {
              parsed.signingString += request2.method + " " + request2.url + " HTTP/" + request2.httpVersion;
            } else {
              throw new StrictParsingError("request-line is not a valid header with strict parsing enabled.");
            }
          } else if (h === "(request-target)") {
            parsed.signingString += "(request-target): " + request2.method.toLowerCase() + " " + request2.url;
          } else {
            var value = request2.headers[h];
            if (value === void 0)
              throw new MissingHeaderError(h + " was not in the request");
            parsed.signingString += h + ": " + value;
          }
          if (i2 + 1 < parsed.params.headers.length)
            parsed.signingString += "\n";
        }
        var date;
        if (request2.headers.date || request2.headers["x-date"]) {
          if (request2.headers["x-date"]) {
            date = new Date(request2.headers["x-date"]);
          } else {
            date = new Date(request2.headers.date);
          }
          var now = /* @__PURE__ */ new Date();
          var skew2 = Math.abs(now.getTime() - date.getTime());
          if (skew2 > options.clockSkew * 1e3) {
            throw new ExpiredRequestError("clock skew of " + skew2 / 1e3 + "s was greater than " + options.clockSkew + "s");
          }
        }
        options.headers.forEach(function(hdr) {
          if (parsed.params.headers.indexOf(hdr.toLowerCase()) < 0)
            throw new MissingHeaderError(hdr + " was not a signed header");
        });
        if (options.algorithms) {
          if (options.algorithms.indexOf(parsed.params.algorithm) === -1)
            throw new InvalidParamsError(parsed.params.algorithm + " is not a supported algorithm");
        }
        parsed.algorithm = parsed.params.algorithm.toUpperCase();
        parsed.keyId = parsed.params.keyId;
        return parsed;
      }
    };
    return parser;
  }
  var jsprim = {};
  var extsprintf = {};
  var hasRequiredExtsprintf;
  function requireExtsprintf() {
    if (hasRequiredExtsprintf)
      return extsprintf;
    hasRequiredExtsprintf = 1;
    var mod_assert = require$$0$2;
    var mod_util = require$$0$2;
    extsprintf.sprintf = jsSprintf;
    extsprintf.printf = jsPrintf;
    extsprintf.fprintf = jsFprintf;
    function jsSprintf(fmt) {
      var regex = [
        "([^%]*)",
        /* normal text */
        "%",
        /* start of format */
        "(['\\-+ #0]*?)",
        /* flags (optional) */
        "([1-9]\\d*)?",
        /* width (optional) */
        "(\\.([1-9]\\d*))?",
        /* precision (optional) */
        "[lhjztL]*?",
        /* length mods (ignored) */
        "([diouxXfFeEgGaAcCsSp%jr])"
        /* conversion */
      ].join("");
      var re = new RegExp(regex);
      var args = Array.prototype.slice.call(arguments, 1);
      var flags, width, precision, conversion;
      var left, pad, sign, arg, match;
      var ret = "";
      var argn = 1;
      mod_assert.equal("string", typeof fmt);
      while ((match = re.exec(fmt)) !== null) {
        ret += match[1];
        fmt = fmt.substring(match[0].length);
        flags = match[2] || "";
        width = match[3] || 0;
        precision = match[4] || "";
        conversion = match[6];
        left = false;
        sign = false;
        pad = " ";
        if (conversion == "%") {
          ret += "%";
          continue;
        }
        if (args.length === 0)
          throw new Error("too few args to sprintf");
        arg = args.shift();
        argn++;
        if (flags.match(/[\' #]/))
          throw new Error(
            "unsupported flags: " + flags
          );
        if (precision.length > 0)
          throw new Error(
            "non-zero precision not supported"
          );
        if (flags.match(/-/))
          left = true;
        if (flags.match(/0/))
          pad = "0";
        if (flags.match(/\+/))
          sign = true;
        switch (conversion) {
          case "s":
            if (arg === void 0 || arg === null)
              throw new Error("argument " + argn + ": attempted to print undefined or null as a string");
            ret += doPad(pad, width, left, arg.toString());
            break;
          case "d":
            arg = Math.floor(arg);
          case "f":
            sign = sign && arg > 0 ? "+" : "";
            ret += sign + doPad(
              pad,
              width,
              left,
              arg.toString()
            );
            break;
          case "x":
            ret += doPad(pad, width, left, arg.toString(16));
            break;
          case "j":
            if (width === 0)
              width = 10;
            ret += mod_util.inspect(arg, false, width);
            break;
          case "r":
            ret += dumpException(arg);
            break;
          default:
            throw new Error("unsupported conversion: " + conversion);
        }
      }
      ret += fmt;
      return ret;
    }
    function jsPrintf() {
      var args = Array.prototype.slice.call(arguments);
      args.unshift(process.stdout);
      jsFprintf.apply(null, args);
    }
    function jsFprintf(stream) {
      var args = Array.prototype.slice.call(arguments, 1);
      return stream.write(jsSprintf.apply(this, args));
    }
    function doPad(chr, width, left, str) {
      var ret = str;
      while (ret.length < width) {
        if (left)
          ret += chr;
        else
          ret = chr + ret;
      }
      return ret;
    }
    function dumpException(ex) {
      var ret;
      if (!(ex instanceof Error))
        throw new Error(jsSprintf("invalid type for %%r: %j", ex));
      ret = "EXCEPTION: " + ex.constructor.name + ": " + ex.stack;
      if (ex.cause && typeof ex.cause === "function") {
        var cex = ex.cause();
        if (cex) {
          ret += "\nCaused by: " + dumpException(cex);
        }
      }
      return ret;
    }
    return extsprintf;
  }
  var util$1 = {};
  var hasRequiredUtil$1;
  function requireUtil$1() {
    if (hasRequiredUtil$1)
      return util$1;
    hasRequiredUtil$1 = 1;
    function isArray3(arg) {
      if (Array.isArray) {
        return Array.isArray(arg);
      }
      return objectToString(arg) === "[object Array]";
    }
    util$1.isArray = isArray3;
    function isBoolean(arg) {
      return typeof arg === "boolean";
    }
    util$1.isBoolean = isBoolean;
    function isNull(arg) {
      return arg === null;
    }
    util$1.isNull = isNull;
    function isNullOrUndefined(arg) {
      return arg == null;
    }
    util$1.isNullOrUndefined = isNullOrUndefined;
    function isNumber(arg) {
      return typeof arg === "number";
    }
    util$1.isNumber = isNumber;
    function isString(arg) {
      return typeof arg === "string";
    }
    util$1.isString = isString;
    function isSymbol(arg) {
      return typeof arg === "symbol";
    }
    util$1.isSymbol = isSymbol;
    function isUndefined(arg) {
      return arg === void 0;
    }
    util$1.isUndefined = isUndefined;
    function isRegExp(re) {
      return objectToString(re) === "[object RegExp]";
    }
    util$1.isRegExp = isRegExp;
    function isObject(arg) {
      return typeof arg === "object" && arg !== null;
    }
    util$1.isObject = isObject;
    function isDate(d2) {
      return objectToString(d2) === "[object Date]";
    }
    util$1.isDate = isDate;
    function isError(e) {
      return objectToString(e) === "[object Error]" || e instanceof Error;
    }
    util$1.isError = isError;
    function isFunction(arg) {
      return typeof arg === "function";
    }
    util$1.isFunction = isFunction;
    function isPrimitive(arg) {
      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
      typeof arg === "undefined";
    }
    util$1.isPrimitive = isPrimitive;
    util$1.isBuffer = Buffer.isBuffer;
    function objectToString(o) {
      return Object.prototype.toString.call(o);
    }
    return util$1;
  }
  var verror;
  var hasRequiredVerror;
  function requireVerror() {
    if (hasRequiredVerror)
      return verror;
    hasRequiredVerror = 1;
    var mod_assertplus = requireAssert();
    var mod_util = require$$0$2;
    var mod_extsprintf = requireExtsprintf();
    var mod_isError = requireUtil$1().isError;
    var sprintf = mod_extsprintf.sprintf;
    verror = VError;
    VError.VError = VError;
    VError.SError = SError;
    VError.WError = WError;
    VError.MultiError = MultiError;
    function parseConstructorArguments(args) {
      var argv, options, sprintf_args, shortmessage, k;
      mod_assertplus.object(args, "args");
      mod_assertplus.bool(args.strict, "args.strict");
      mod_assertplus.array(args.argv, "args.argv");
      argv = args.argv;
      if (argv.length === 0) {
        options = {};
        sprintf_args = [];
      } else if (mod_isError(argv[0])) {
        options = { "cause": argv[0] };
        sprintf_args = argv.slice(1);
      } else if (typeof argv[0] === "object") {
        options = {};
        for (k in argv[0]) {
          options[k] = argv[0][k];
        }
        sprintf_args = argv.slice(1);
      } else {
        mod_assertplus.string(
          argv[0],
          "first argument to VError, SError, or WError constructor must be a string, object, or Error"
        );
        options = {};
        sprintf_args = argv;
      }
      mod_assertplus.object(options);
      if (!options.strict && !args.strict) {
        sprintf_args = sprintf_args.map(function(a2) {
          return a2 === null ? "null" : a2 === void 0 ? "undefined" : a2;
        });
      }
      if (sprintf_args.length === 0) {
        shortmessage = "";
      } else {
        shortmessage = sprintf.apply(null, sprintf_args);
      }
      return {
        "options": options,
        "shortmessage": shortmessage
      };
    }
    function VError() {
      var args, obj, parsed, cause, ctor, message, k;
      args = Array.prototype.slice.call(arguments, 0);
      if (!(this instanceof VError)) {
        obj = Object.create(VError.prototype);
        VError.apply(obj, arguments);
        return obj;
      }
      parsed = parseConstructorArguments({
        "argv": args,
        "strict": false
      });
      if (parsed.options.name) {
        mod_assertplus.string(
          parsed.options.name,
          `error's "name" must be a string`
        );
        this.name = parsed.options.name;
      }
      this.jse_shortmsg = parsed.shortmessage;
      message = parsed.shortmessage;
      cause = parsed.options.cause;
      if (cause) {
        mod_assertplus.ok(mod_isError(cause), "cause is not an Error");
        this.jse_cause = cause;
        if (!parsed.options.skipCauseMessage) {
          message += ": " + cause.message;
        }
      }
      this.jse_info = {};
      if (parsed.options.info) {
        for (k in parsed.options.info) {
          this.jse_info[k] = parsed.options.info[k];
        }
      }
      this.message = message;
      Error.call(this, message);
      if (Error.captureStackTrace) {
        ctor = parsed.options.constructorOpt || this.constructor;
        Error.captureStackTrace(this, ctor);
      }
      return this;
    }
    mod_util.inherits(VError, Error);
    VError.prototype.name = "VError";
    VError.prototype.toString = function ve_toString() {
      var str = this.hasOwnProperty("name") && this.name || this.constructor.name || this.constructor.prototype.name;
      if (this.message)
        str += ": " + this.message;
      return str;
    };
    VError.prototype.cause = function ve_cause() {
      var cause = VError.cause(this);
      return cause === null ? void 0 : cause;
    };
    VError.cause = function(err) {
      mod_assertplus.ok(mod_isError(err), "err must be an Error");
      return mod_isError(err.jse_cause) ? err.jse_cause : null;
    };
    VError.info = function(err) {
      var rv, cause, k;
      mod_assertplus.ok(mod_isError(err), "err must be an Error");
      cause = VError.cause(err);
      if (cause !== null) {
        rv = VError.info(cause);
      } else {
        rv = {};
      }
      if (typeof err.jse_info == "object" && err.jse_info !== null) {
        for (k in err.jse_info) {
          rv[k] = err.jse_info[k];
        }
      }
      return rv;
    };
    VError.findCauseByName = function(err, name) {
      var cause;
      mod_assertplus.ok(mod_isError(err), "err must be an Error");
      mod_assertplus.string(name, "name");
      mod_assertplus.ok(name.length > 0, "name cannot be empty");
      for (cause = err; cause !== null; cause = VError.cause(cause)) {
        mod_assertplus.ok(mod_isError(cause));
        if (cause.name == name) {
          return cause;
        }
      }
      return null;
    };
    VError.hasCauseWithName = function(err, name) {
      return VError.findCauseByName(err, name) !== null;
    };
    VError.fullStack = function(err) {
      mod_assertplus.ok(mod_isError(err), "err must be an Error");
      var cause = VError.cause(err);
      if (cause) {
        return err.stack + "\ncaused by: " + VError.fullStack(cause);
      }
      return err.stack;
    };
    VError.errorFromList = function(errors2) {
      mod_assertplus.arrayOfObject(errors2, "errors");
      if (errors2.length === 0) {
        return null;
      }
      errors2.forEach(function(e) {
        mod_assertplus.ok(mod_isError(e));
      });
      if (errors2.length == 1) {
        return errors2[0];
      }
      return new MultiError(errors2);
    };
    VError.errorForEach = function(err, func) {
      mod_assertplus.ok(mod_isError(err), "err must be an Error");
      mod_assertplus.func(func, "func");
      if (err instanceof MultiError) {
        err.errors().forEach(function iterError(e) {
          func(e);
        });
      } else {
        func(err);
      }
    };
    function SError() {
      var args, obj, parsed, options;
      args = Array.prototype.slice.call(arguments, 0);
      if (!(this instanceof SError)) {
        obj = Object.create(SError.prototype);
        SError.apply(obj, arguments);
        return obj;
      }
      parsed = parseConstructorArguments({
        "argv": args,
        "strict": true
      });
      options = parsed.options;
      VError.call(this, options, "%s", parsed.shortmessage);
      return this;
    }
    mod_util.inherits(SError, VError);
    function MultiError(errors2) {
      mod_assertplus.array(errors2, "list of errors");
      mod_assertplus.ok(errors2.length > 0, "must be at least one error");
      this.ase_errors = errors2;
      VError.call(this, {
        "cause": errors2[0]
      }, "first of %d error%s", errors2.length, errors2.length == 1 ? "" : "s");
    }
    mod_util.inherits(MultiError, VError);
    MultiError.prototype.name = "MultiError";
    MultiError.prototype.errors = function me_errors() {
      return this.ase_errors.slice(0);
    };
    function WError() {
      var args, obj, parsed, options;
      args = Array.prototype.slice.call(arguments, 0);
      if (!(this instanceof WError)) {
        obj = Object.create(WError.prototype);
        WError.apply(obj, args);
        return obj;
      }
      parsed = parseConstructorArguments({
        "argv": args,
        "strict": false
      });
      options = parsed.options;
      options["skipCauseMessage"] = true;
      VError.call(this, options, "%s", parsed.shortmessage);
      return this;
    }
    mod_util.inherits(WError, VError);
    WError.prototype.name = "WError";
    WError.prototype.toString = function we_toString() {
      var str = this.hasOwnProperty("name") && this.name || this.constructor.name || this.constructor.prototype.name;
      if (this.message)
        str += ": " + this.message;
      if (this.jse_cause && this.jse_cause.message)
        str += "; caused by " + this.jse_cause.toString();
      return str;
    };
    WError.prototype.cause = function we_cause(c2) {
      if (mod_isError(c2))
        this.jse_cause = c2;
      return this.jse_cause;
    };
    return verror;
  }
  var validate$1 = { exports: {} };
  var hasRequiredValidate$1;
  function requireValidate$1() {
    if (hasRequiredValidate$1)
      return validate$1.exports;
    hasRequiredValidate$1 = 1;
    (function(module) {
      (function(root, factory) {
        if (module.exports) {
          module.exports = factory();
        } else {
          root.jsonSchema = factory();
        }
      })(commonjsGlobal, function() {
        var exports = validate3;
        exports.Integer = { type: "integer" };
        var primitiveConstructors = {
          String,
          Boolean,
          Number,
          Object,
          Array,
          Date
        };
        exports.validate = validate3;
        function validate3(instance, schema) {
          return validate3(instance, schema, { changing: false });
        }
        exports.checkPropertyChange = function(value, schema, property) {
          return validate3(value, schema, { changing: property || "property" });
        };
        var validate3 = exports._validate = function(instance, schema, options) {
          if (!options)
            options = {};
          var _changing = options.changing;
          function getType(schema2) {
            return schema2.type || primitiveConstructors[schema2.name] == schema2 && schema2.name.toLowerCase();
          }
          var errors2 = [];
          function checkProp(value, schema2, path, i2) {
            var l;
            path += path ? typeof i2 == "number" ? "[" + i2 + "]" : typeof i2 == "undefined" ? "" : "." + i2 : i2;
            function addError(message) {
              errors2.push({ property: path, message });
            }
            if ((typeof schema2 != "object" || schema2 instanceof Array) && (path || typeof schema2 != "function") && !(schema2 && getType(schema2))) {
              if (typeof schema2 == "function") {
                if (!(value instanceof schema2)) {
                  addError("is not an instance of the class/constructor " + schema2.name);
                }
              } else if (schema2) {
                addError("Invalid schema/property definition " + schema2);
              }
              return null;
            }
            if (_changing && schema2.readonly) {
              addError("is a readonly field, it can not be changed");
            }
            if (schema2["extends"]) {
              checkProp(value, schema2["extends"], path, i2);
            }
            function checkType(type2, value2) {
              if (type2) {
                if (typeof type2 == "string" && type2 != "any" && (type2 == "null" ? value2 !== null : typeof value2 != type2) && !(value2 instanceof Array && type2 == "array") && !(value2 instanceof Date && type2 == "date") && !(type2 == "integer" && value2 % 1 === 0)) {
                  return [{ property: path, message: value2 + " - " + typeof value2 + " value found, but a " + type2 + " is required" }];
                }
                if (type2 instanceof Array) {
                  var unionErrors = [];
                  for (var j3 = 0; j3 < type2.length; j3++) {
                    if (!(unionErrors = checkType(type2[j3], value2)).length) {
                      break;
                    }
                  }
                  if (unionErrors.length) {
                    return unionErrors;
                  }
                } else if (typeof type2 == "object") {
                  var priorErrors = errors2;
                  errors2 = [];
                  checkProp(value2, type2, path);
                  var theseErrors = errors2;
                  errors2 = priorErrors;
                  return theseErrors;
                }
              }
              return [];
            }
            if (value === void 0) {
              if (schema2.required) {
                addError("is missing and it is required");
              }
            } else {
              errors2 = errors2.concat(checkType(getType(schema2), value));
              if (schema2.disallow && !checkType(schema2.disallow, value).length) {
                addError(" disallowed value was matched");
              }
              if (value !== null) {
                if (value instanceof Array) {
                  if (schema2.items) {
                    var itemsIsArray = schema2.items instanceof Array;
                    var propDef = schema2.items;
                    for (i2 = 0, l = value.length; i2 < l; i2 += 1) {
                      if (itemsIsArray)
                        propDef = schema2.items[i2];
                      if (options.coerce)
                        value[i2] = options.coerce(value[i2], propDef);
                      errors2.concat(checkProp(value[i2], propDef, path, i2));
                    }
                  }
                  if (schema2.minItems && value.length < schema2.minItems) {
                    addError("There must be a minimum of " + schema2.minItems + " in the array");
                  }
                  if (schema2.maxItems && value.length > schema2.maxItems) {
                    addError("There must be a maximum of " + schema2.maxItems + " in the array");
                  }
                } else if (schema2.properties || schema2.additionalProperties) {
                  errors2.concat(checkObj(value, schema2.properties, path, schema2.additionalProperties));
                }
                if (schema2.pattern && typeof value == "string" && !value.match(schema2.pattern)) {
                  addError("does not match the regex pattern " + schema2.pattern);
                }
                if (schema2.maxLength && typeof value == "string" && value.length > schema2.maxLength) {
                  addError("may only be " + schema2.maxLength + " characters long");
                }
                if (schema2.minLength && typeof value == "string" && value.length < schema2.minLength) {
                  addError("must be at least " + schema2.minLength + " characters long");
                }
                if (typeof schema2.minimum !== "undefined" && typeof value == typeof schema2.minimum && schema2.minimum > value) {
                  addError("must have a minimum value of " + schema2.minimum);
                }
                if (typeof schema2.maximum !== "undefined" && typeof value == typeof schema2.maximum && schema2.maximum < value) {
                  addError("must have a maximum value of " + schema2.maximum);
                }
                if (schema2["enum"]) {
                  var enumer = schema2["enum"];
                  l = enumer.length;
                  var found;
                  for (var j2 = 0; j2 < l; j2++) {
                    if (enumer[j2] === value) {
                      found = 1;
                      break;
                    }
                  }
                  if (!found) {
                    addError("does not have a value in the enumeration " + enumer.join(", "));
                  }
                }
                if (typeof schema2.maxDecimal == "number" && value.toString().match(new RegExp("\\.[0-9]{" + (schema2.maxDecimal + 1) + ",}"))) {
                  addError("may only have " + schema2.maxDecimal + " digits of decimal places");
                }
              }
            }
            return null;
          }
          function checkObj(instance2, objTypeDef, path, additionalProp) {
            if (typeof objTypeDef == "object") {
              if (typeof instance2 != "object" || instance2 instanceof Array) {
                errors2.push({ property: path, message: "an object is required" });
              }
              for (var i2 in objTypeDef) {
                if (objTypeDef.hasOwnProperty(i2) && i2 != "__proto__" && i2 != "constructor") {
                  var value = instance2.hasOwnProperty(i2) ? instance2[i2] : void 0;
                  if (value === void 0 && options.existingOnly)
                    continue;
                  var propDef = objTypeDef[i2];
                  if (value === void 0 && propDef["default"]) {
                    value = instance2[i2] = propDef["default"];
                  }
                  if (options.coerce && i2 in instance2) {
                    value = instance2[i2] = options.coerce(value, propDef);
                  }
                  checkProp(value, propDef, path, i2);
                }
              }
            }
            for (i2 in instance2) {
              if (instance2.hasOwnProperty(i2) && !(i2.charAt(0) == "_" && i2.charAt(1) == "_") && objTypeDef && !objTypeDef[i2] && additionalProp === false) {
                if (options.filter) {
                  delete instance2[i2];
                  continue;
                } else {
                  errors2.push({ property: path, message: "The property " + i2 + " is not defined in the schema and the schema does not allow additional properties" });
                }
              }
              var requires = objTypeDef && objTypeDef[i2] && objTypeDef[i2].requires;
              if (requires && !(requires in instance2)) {
                errors2.push({ property: path, message: "the presence of the property " + i2 + " requires that " + requires + " also be present" });
              }
              value = instance2[i2];
              if (additionalProp && (!(objTypeDef && typeof objTypeDef == "object") || !(i2 in objTypeDef))) {
                if (options.coerce) {
                  value = instance2[i2] = options.coerce(value, additionalProp);
                }
                checkProp(value, additionalProp, path, i2);
              }
              if (!_changing && value && value.$schema) {
                errors2 = errors2.concat(checkProp(value, value.$schema, path, i2));
              }
            }
            return errors2;
          }
          if (schema) {
            checkProp(instance, schema, "", _changing || "");
          }
          if (!_changing && instance && instance.$schema) {
            checkProp(instance, instance.$schema, "", "");
          }
          return { valid: !errors2.length, errors: errors2 };
        };
        exports.mustBeValid = function(result2) {
          if (!result2.valid) {
            throw new TypeError(result2.errors.map(function(error2) {
              return "for property " + error2.property + ": " + error2.message;
            }).join(", \n"));
          }
        };
        return exports;
      });
    })(validate$1);
    return validate$1.exports;
  }
  var hasRequiredJsprim;
  function requireJsprim() {
    if (hasRequiredJsprim)
      return jsprim;
    hasRequiredJsprim = 1;
    var mod_assert = requireAssert();
    var mod_extsprintf = requireExtsprintf();
    var mod_verror = requireVerror();
    var mod_jsonschema = requireValidate$1();
    jsprim.deepCopy = deepCopy;
    jsprim.deepEqual = deepEqual;
    jsprim.isEmpty = isEmpty;
    jsprim.hasKey = hasKey;
    jsprim.forEachKey = forEachKey;
    jsprim.pluck = pluck;
    jsprim.flattenObject = flattenObject;
    jsprim.flattenIter = flattenIter;
    jsprim.validateJsonObject = validateJsonObjectJS;
    jsprim.validateJsonObjectJS = validateJsonObjectJS;
    jsprim.randElt = randElt;
    jsprim.extraProperties = extraProperties;
    jsprim.mergeObjects = mergeObjects;
    jsprim.startsWith = startsWith;
    jsprim.endsWith = endsWith;
    jsprim.parseInteger = parseInteger;
    jsprim.iso8601 = iso8601;
    jsprim.rfc1123 = rfc1123;
    jsprim.parseDateTime = parseDateTime;
    jsprim.hrtimediff = hrtimeDiff;
    jsprim.hrtimeDiff = hrtimeDiff;
    jsprim.hrtimeAccum = hrtimeAccum;
    jsprim.hrtimeAdd = hrtimeAdd;
    jsprim.hrtimeNanosec = hrtimeNanosec;
    jsprim.hrtimeMicrosec = hrtimeMicrosec;
    jsprim.hrtimeMillisec = hrtimeMillisec;
    function deepCopy(obj) {
      var ret, key2;
      var marker = "__deepCopy";
      if (obj && obj[marker])
        throw new Error("attempted deep copy of cyclic object");
      if (obj && obj.constructor == Object) {
        ret = {};
        obj[marker] = true;
        for (key2 in obj) {
          if (key2 == marker)
            continue;
          ret[key2] = deepCopy(obj[key2]);
        }
        delete obj[marker];
        return ret;
      }
      if (obj && obj.constructor == Array) {
        ret = [];
        obj[marker] = true;
        for (key2 = 0; key2 < obj.length; key2++)
          ret.push(deepCopy(obj[key2]));
        delete obj[marker];
        return ret;
      }
      return obj;
    }
    function deepEqual(obj1, obj2) {
      if (typeof obj1 != typeof obj2)
        return false;
      if (obj1 === null || obj2 === null || typeof obj1 != "object")
        return obj1 === obj2;
      if (obj1.constructor != obj2.constructor)
        return false;
      var k;
      for (k in obj1) {
        if (!obj2.hasOwnProperty(k))
          return false;
        if (!deepEqual(obj1[k], obj2[k]))
          return false;
      }
      for (k in obj2) {
        if (!obj1.hasOwnProperty(k))
          return false;
      }
      return true;
    }
    function isEmpty(obj) {
      var key2;
      for (key2 in obj)
        return false;
      return true;
    }
    function hasKey(obj, key2) {
      mod_assert.equal(typeof key2, "string");
      return Object.prototype.hasOwnProperty.call(obj, key2);
    }
    function forEachKey(obj, callback) {
      for (var key2 in obj) {
        if (hasKey(obj, key2)) {
          callback(key2, obj[key2]);
        }
      }
    }
    function pluck(obj, key2) {
      mod_assert.equal(typeof key2, "string");
      return pluckv(obj, key2);
    }
    function pluckv(obj, key2) {
      if (obj === null || typeof obj !== "object")
        return void 0;
      if (obj.hasOwnProperty(key2))
        return obj[key2];
      var i2 = key2.indexOf(".");
      if (i2 == -1)
        return void 0;
      var key1 = key2.substr(0, i2);
      if (!obj.hasOwnProperty(key1))
        return void 0;
      return pluckv(obj[key1], key2.substr(i2 + 1));
    }
    function flattenIter(data2, depth, callback) {
      doFlattenIter(data2, depth, [], callback);
    }
    function doFlattenIter(data2, depth, accum, callback) {
      var each;
      var key2;
      if (depth === 0) {
        each = accum.slice(0);
        each.push(data2);
        callback(each);
        return;
      }
      mod_assert.ok(data2 !== null);
      mod_assert.equal(typeof data2, "object");
      mod_assert.equal(typeof depth, "number");
      mod_assert.ok(depth >= 0);
      for (key2 in data2) {
        each = accum.slice(0);
        each.push(key2);
        doFlattenIter(data2[key2], depth - 1, each, callback);
      }
    }
    function flattenObject(data2, depth) {
      if (depth === 0)
        return [data2];
      mod_assert.ok(data2 !== null);
      mod_assert.equal(typeof data2, "object");
      mod_assert.equal(typeof depth, "number");
      mod_assert.ok(depth >= 0);
      var rv = [];
      var key2;
      for (key2 in data2) {
        flattenObject(data2[key2], depth - 1).forEach(function(p) {
          rv.push([key2].concat(p));
        });
      }
      return rv;
    }
    function startsWith(str, prefix) {
      return str.substr(0, prefix.length) == prefix;
    }
    function endsWith(str, suffix) {
      return str.substr(
        str.length - suffix.length,
        suffix.length
      ) == suffix;
    }
    function iso8601(d2) {
      if (typeof d2 == "number")
        d2 = new Date(d2);
      mod_assert.ok(d2.constructor === Date);
      return mod_extsprintf.sprintf(
        "%4d-%02d-%02dT%02d:%02d:%02d.%03dZ",
        d2.getUTCFullYear(),
        d2.getUTCMonth() + 1,
        d2.getUTCDate(),
        d2.getUTCHours(),
        d2.getUTCMinutes(),
        d2.getUTCSeconds(),
        d2.getUTCMilliseconds()
      );
    }
    var RFC1123_MONTHS = [
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec"
    ];
    var RFC1123_DAYS = [
      "Sun",
      "Mon",
      "Tue",
      "Wed",
      "Thu",
      "Fri",
      "Sat"
    ];
    function rfc1123(date) {
      return mod_extsprintf.sprintf(
        "%s, %02d %s %04d %02d:%02d:%02d GMT",
        RFC1123_DAYS[date.getUTCDay()],
        date.getUTCDate(),
        RFC1123_MONTHS[date.getUTCMonth()],
        date.getUTCFullYear(),
        date.getUTCHours(),
        date.getUTCMinutes(),
        date.getUTCSeconds()
      );
    }
    function parseDateTime(str) {
      var numeric = +str;
      if (!isNaN(numeric)) {
        return new Date(numeric);
      } else {
        return new Date(str);
      }
    }
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
    var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -9007199254740991;
    var PI_DEFAULTS = {
      base: 10,
      allowSign: true,
      allowPrefix: false,
      allowTrailing: false,
      allowImprecise: false,
      trimWhitespace: false,
      leadingZeroIsOctal: false
    };
    var CP_0 = 48;
    var CP_9 = 57;
    var CP_A = 65;
    var CP_B = 66;
    var CP_O = 79;
    var CP_T = 84;
    var CP_X = 88;
    var CP_Z = 90;
    var CP_a = 97;
    var CP_b = 98;
    var CP_o = 111;
    var CP_t = 116;
    var CP_x = 120;
    var CP_z = 122;
    var PI_CONV_DEC = 48;
    var PI_CONV_UC = 55;
    var PI_CONV_LC = 87;
    function parseInteger(str, uopts) {
      mod_assert.string(str, "str");
      mod_assert.optionalObject(uopts, "options");
      var baseOverride = false;
      var options = PI_DEFAULTS;
      if (uopts) {
        baseOverride = hasKey(uopts, "base");
        options = mergeObjects(options, uopts);
        mod_assert.number(options.base, "options.base");
        mod_assert.ok(options.base >= 2, "options.base >= 2");
        mod_assert.ok(options.base <= 36, "options.base <= 36");
        mod_assert.bool(options.allowSign, "options.allowSign");
        mod_assert.bool(options.allowPrefix, "options.allowPrefix");
        mod_assert.bool(
          options.allowTrailing,
          "options.allowTrailing"
        );
        mod_assert.bool(
          options.allowImprecise,
          "options.allowImprecise"
        );
        mod_assert.bool(
          options.trimWhitespace,
          "options.trimWhitespace"
        );
        mod_assert.bool(
          options.leadingZeroIsOctal,
          "options.leadingZeroIsOctal"
        );
        if (options.leadingZeroIsOctal) {
          mod_assert.ok(
            !baseOverride,
            '"base" and "leadingZeroIsOctal" are mutually exclusive'
          );
        }
      }
      var c2;
      var pbase = -1;
      var base2 = options.base;
      var start;
      var mult = 1;
      var value = 0;
      var idx = 0;
      var len = str.length;
      if (options.trimWhitespace) {
        while (idx < len && isSpace(str.charCodeAt(idx))) {
          ++idx;
        }
      }
      if (options.allowSign) {
        if (str[idx] === "-") {
          idx += 1;
          mult = -1;
        } else if (str[idx] === "+") {
          idx += 1;
        }
      }
      if (str[idx] === "0") {
        if (options.allowPrefix) {
          pbase = prefixToBase(str.charCodeAt(idx + 1));
          if (pbase !== -1 && (!baseOverride || pbase === base2)) {
            base2 = pbase;
            idx += 2;
          }
        }
        if (pbase === -1 && options.leadingZeroIsOctal) {
          base2 = 8;
        }
      }
      for (start = idx; idx < len; ++idx) {
        c2 = translateDigit(str.charCodeAt(idx));
        if (c2 !== -1 && c2 < base2) {
          value *= base2;
          value += c2;
        } else {
          break;
        }
      }
      if (start === idx) {
        return new Error("invalid number: " + JSON.stringify(str));
      }
      if (options.trimWhitespace) {
        while (idx < len && isSpace(str.charCodeAt(idx))) {
          ++idx;
        }
      }
      if (idx < len && !options.allowTrailing) {
        return new Error("trailing characters after number: " + JSON.stringify(str.slice(idx)));
      }
      if (value === 0) {
        return 0;
      }
      var result2 = value * mult;
      if (!options.allowImprecise && (value > MAX_SAFE_INTEGER || result2 < MIN_SAFE_INTEGER)) {
        return new Error("number is outside of the supported range: " + JSON.stringify(str.slice(start, idx)));
      }
      return result2;
    }
    function translateDigit(d2) {
      if (d2 >= CP_0 && d2 <= CP_9) {
        return d2 - PI_CONV_DEC;
      } else if (d2 >= CP_A && d2 <= CP_Z) {
        return d2 - PI_CONV_UC;
      } else if (d2 >= CP_a && d2 <= CP_z) {
        return d2 - PI_CONV_LC;
      } else {
        return -1;
      }
    }
    function isSpace(c2) {
      return c2 === 32 || c2 >= 9 && c2 <= 13 || c2 === 160 || c2 === 5760 || c2 === 6158 || c2 >= 8192 && c2 <= 8202 || c2 === 8232 || c2 === 8233 || c2 === 8239 || c2 === 8287 || c2 === 12288 || c2 === 65279;
    }
    function prefixToBase(c2) {
      if (c2 === CP_b || c2 === CP_B) {
        return 2;
      } else if (c2 === CP_o || c2 === CP_O) {
        return 8;
      } else if (c2 === CP_t || c2 === CP_T) {
        return 10;
      } else if (c2 === CP_x || c2 === CP_X) {
        return 16;
      } else {
        return -1;
      }
    }
    function validateJsonObjectJS(schema, input) {
      var report = mod_jsonschema.validate(input, schema);
      if (report.errors.length === 0)
        return null;
      var error2 = report.errors[0];
      var propname = error2["property"];
      var reason = error2["message"].toLowerCase();
      var i2, j2;
      if ((i2 = reason.indexOf("the property ")) != -1 && (j2 = reason.indexOf(" is not defined in the schema and the schema does not allow additional properties")) != -1) {
        i2 += "the property ".length;
        if (propname === "")
          propname = reason.substr(i2, j2 - i2);
        else
          propname = propname + "." + reason.substr(i2, j2 - i2);
        reason = "unsupported property";
      }
      var rv = new mod_verror.VError('property "%s": %s', propname, reason);
      rv.jsv_details = error2;
      return rv;
    }
    function randElt(arr) {
      mod_assert.ok(
        Array.isArray(arr) && arr.length > 0,
        "randElt argument must be a non-empty array"
      );
      return arr[Math.floor(Math.random() * arr.length)];
    }
    function assertHrtime(a2) {
      mod_assert.ok(
        a2[0] >= 0 && a2[1] >= 0,
        "negative numbers not allowed in hrtimes"
      );
      mod_assert.ok(a2[1] < 1e9, "nanoseconds column overflow");
    }
    function hrtimeDiff(a2, b2) {
      assertHrtime(a2);
      assertHrtime(b2);
      mod_assert.ok(
        a2[0] > b2[0] || a2[0] == b2[0] && a2[1] >= b2[1],
        "negative differences not allowed"
      );
      var rv = [a2[0] - b2[0], 0];
      if (a2[1] >= b2[1]) {
        rv[1] = a2[1] - b2[1];
      } else {
        rv[0]--;
        rv[1] = 1e9 - (b2[1] - a2[1]);
      }
      return rv;
    }
    function hrtimeNanosec(a2) {
      assertHrtime(a2);
      return Math.floor(a2[0] * 1e9 + a2[1]);
    }
    function hrtimeMicrosec(a2) {
      assertHrtime(a2);
      return Math.floor(a2[0] * 1e6 + a2[1] / 1e3);
    }
    function hrtimeMillisec(a2) {
      assertHrtime(a2);
      return Math.floor(a2[0] * 1e3 + a2[1] / 1e6);
    }
    function hrtimeAccum(a2, b2) {
      assertHrtime(a2);
      assertHrtime(b2);
      a2[1] += b2[1];
      if (a2[1] >= 1e9) {
        a2[0]++;
        a2[1] -= 1e9;
      }
      a2[0] += b2[0];
      return a2;
    }
    function hrtimeAdd(a2, b2) {
      assertHrtime(a2);
      var rv = [a2[0], a2[1]];
      return hrtimeAccum(rv, b2);
    }
    function extraProperties(obj, allowed) {
      mod_assert.ok(
        typeof obj === "object" && obj !== null,
        "obj argument must be a non-null object"
      );
      mod_assert.ok(
        Array.isArray(allowed),
        "allowed argument must be an array of strings"
      );
      for (var i2 = 0; i2 < allowed.length; i2++) {
        mod_assert.ok(
          typeof allowed[i2] === "string",
          "allowed argument must be an array of strings"
        );
      }
      return Object.keys(obj).filter(function(key2) {
        return allowed.indexOf(key2) === -1;
      });
    }
    function mergeObjects(provided, overrides, defaults) {
      var rv, k;
      rv = {};
      if (defaults) {
        for (k in defaults)
          rv[k] = defaults[k];
      }
      if (provided) {
        for (k in provided)
          rv[k] = provided[k];
      }
      if (overrides) {
        for (k in overrides)
          rv[k] = overrides[k];
      }
      return rv;
    }
    return jsprim;
  }
  var signer;
  var hasRequiredSigner;
  function requireSigner() {
    if (hasRequiredSigner)
      return signer;
    hasRequiredSigner = 1;
    var assert = requireAssert();
    var crypto2 = require$$0$2;
    var util2 = require$$0$2;
    var sshpk = requireLib$3();
    var jsprim2 = requireJsprim();
    var utils2 = requireUtils$1();
    var sprintf = require$$0$2.format;
    var HASH_ALGOS = utils2.HASH_ALGOS;
    var PK_ALGOS = utils2.PK_ALGOS;
    var InvalidAlgorithmError = utils2.InvalidAlgorithmError;
    var HttpSignatureError = utils2.HttpSignatureError;
    var validateAlgorithm = utils2.validateAlgorithm;
    var AUTHZ_FMT = 'Signature keyId="%s",algorithm="%s",headers="%s",signature="%s"';
    function MissingHeaderError(message) {
      HttpSignatureError.call(this, message, MissingHeaderError);
    }
    util2.inherits(MissingHeaderError, HttpSignatureError);
    function StrictParsingError(message) {
      HttpSignatureError.call(this, message, StrictParsingError);
    }
    util2.inherits(StrictParsingError, HttpSignatureError);
    function RequestSigner(options) {
      assert.object(options, "options");
      var alg = [];
      if (options.algorithm !== void 0) {
        assert.string(options.algorithm, "options.algorithm");
        alg = validateAlgorithm(options.algorithm);
      }
      this.rs_alg = alg;
      if (options.sign !== void 0) {
        assert.func(options.sign, "options.sign");
        this.rs_signFunc = options.sign;
      } else if (alg[0] === "hmac" && options.key !== void 0) {
        assert.string(options.keyId, "options.keyId");
        this.rs_keyId = options.keyId;
        if (typeof options.key !== "string" && !Buffer.isBuffer(options.key))
          throw new TypeError("options.key for HMAC must be a string or Buffer");
        this.rs_signer = crypto2.createHmac(alg[1].toUpperCase(), options.key);
        this.rs_signer.sign = function() {
          var digest = this.digest("base64");
          return {
            hashAlgorithm: alg[1],
            toString: function() {
              return digest;
            }
          };
        };
      } else if (options.key !== void 0) {
        var key2 = options.key;
        if (typeof key2 === "string" || Buffer.isBuffer(key2))
          key2 = sshpk.parsePrivateKey(key2);
        assert.ok(
          sshpk.PrivateKey.isPrivateKey(key2, [1, 2]),
          "options.key must be a sshpk.PrivateKey"
        );
        this.rs_key = key2;
        assert.string(options.keyId, "options.keyId");
        this.rs_keyId = options.keyId;
        if (!PK_ALGOS[key2.type]) {
          throw new InvalidAlgorithmError(key2.type.toUpperCase() + " type keys are not supported");
        }
        if (alg[0] !== void 0 && key2.type !== alg[0]) {
          throw new InvalidAlgorithmError("options.key must be a " + alg[0].toUpperCase() + " key, was given a " + key2.type.toUpperCase() + " key instead");
        }
        this.rs_signer = key2.createSign(alg[1]);
      } else {
        throw new TypeError("options.sign (func) or options.key is required");
      }
      this.rs_headers = [];
      this.rs_lines = [];
    }
    RequestSigner.prototype.writeHeader = function(header, value) {
      assert.string(header, "header");
      header = header.toLowerCase();
      assert.string(value, "value");
      this.rs_headers.push(header);
      if (this.rs_signFunc) {
        this.rs_lines.push(header + ": " + value);
      } else {
        var line = header + ": " + value;
        if (this.rs_headers.length > 0)
          line = "\n" + line;
        this.rs_signer.update(line);
      }
      return value;
    };
    RequestSigner.prototype.writeDateHeader = function() {
      return this.writeHeader("date", jsprim2.rfc1123(/* @__PURE__ */ new Date()));
    };
    RequestSigner.prototype.writeTarget = function(method, path) {
      assert.string(method, "method");
      assert.string(path, "path");
      method = method.toLowerCase();
      this.writeHeader("(request-target)", method + " " + path);
    };
    RequestSigner.prototype.sign = function(cb) {
      assert.func(cb, "callback");
      if (this.rs_headers.length < 1)
        throw new Error("At least one header must be signed");
      var alg, authz;
      if (this.rs_signFunc) {
        var data2 = this.rs_lines.join("\n");
        var self2 = this;
        this.rs_signFunc(data2, function(err, sig) {
          if (err) {
            cb(err);
            return;
          }
          try {
            assert.object(sig, "signature");
            assert.string(sig.keyId, "signature.keyId");
            assert.string(sig.algorithm, "signature.algorithm");
            assert.string(sig.signature, "signature.signature");
            alg = validateAlgorithm(sig.algorithm);
            authz = sprintf(
              AUTHZ_FMT,
              sig.keyId,
              sig.algorithm,
              self2.rs_headers.join(" "),
              sig.signature
            );
          } catch (e) {
            cb(e);
            return;
          }
          cb(null, authz);
        });
      } else {
        try {
          var sigObj = this.rs_signer.sign();
        } catch (e) {
          cb(e);
          return;
        }
        alg = (this.rs_alg[0] || this.rs_key.type) + "-" + sigObj.hashAlgorithm;
        var signature2 = sigObj.toString();
        authz = sprintf(
          AUTHZ_FMT,
          this.rs_keyId,
          alg,
          this.rs_headers.join(" "),
          signature2
        );
        cb(null, authz);
      }
    };
    signer = {
      /**
       * Identifies whether a given object is a request signer or not.
       *
       * @param {Object} object, the object to identify
       * @returns {Boolean}
       */
      isSigner: function(obj) {
        if (typeof obj === "object" && obj instanceof RequestSigner)
          return true;
        return false;
      },
      /**
       * Creates a request signer, used to asynchronously build a signature
       * for a request (does not have to be an http.ClientRequest).
       *
       * @param {Object} options, either:
       *                   - {String} keyId
       *                   - {String|Buffer} key
       *                   - {String} algorithm (optional, required for HMAC)
       *                 or:
       *                   - {Func} sign (data, cb)
       * @return {RequestSigner}
       */
      createSigner: function createSigner(options) {
        return new RequestSigner(options);
      },
      /**
       * Adds an 'Authorization' header to an http.ClientRequest object.
       *
       * Note that this API will add a Date header if it's not already set. Any
       * other headers in the options.headers array MUST be present, or this
       * will throw.
       *
       * You shouldn't need to check the return type; it's just there if you want
       * to be pedantic.
       *
       * The optional flag indicates whether parsing should use strict enforcement
       * of the version draft-cavage-http-signatures-04 of the spec or beyond.
       * The default is to be loose and support
       * older versions for compatibility.
       *
       * @param {Object} request an instance of http.ClientRequest.
       * @param {Object} options signing parameters object:
       *                   - {String} keyId required.
       *                   - {String} key required (either a PEM or HMAC key).
       *                   - {Array} headers optional; defaults to ['date'].
       *                   - {String} algorithm optional (unless key is HMAC);
       *                              default is the same as the sshpk default
       *                              signing algorithm for the type of key given
       *                   - {String} httpVersion optional; defaults to '1.1'.
       *                   - {Boolean} strict optional; defaults to 'false'.
       * @return {Boolean} true if Authorization (and optionally Date) were added.
       * @throws {TypeError} on bad parameter types (input).
       * @throws {InvalidAlgorithmError} if algorithm was bad or incompatible with
       *                                 the given key.
       * @throws {sshpk.KeyParseError} if key was bad.
       * @throws {MissingHeaderError} if a header to be signed was specified but
       *                              was not present.
       */
      signRequest: function signRequest(request2, options) {
        assert.object(request2, "request");
        assert.object(options, "options");
        assert.optionalString(options.algorithm, "options.algorithm");
        assert.string(options.keyId, "options.keyId");
        assert.optionalArrayOfString(options.headers, "options.headers");
        assert.optionalString(options.httpVersion, "options.httpVersion");
        if (!request2.getHeader("Date"))
          request2.setHeader("Date", jsprim2.rfc1123(/* @__PURE__ */ new Date()));
        if (!options.headers)
          options.headers = ["date"];
        if (!options.httpVersion)
          options.httpVersion = "1.1";
        var alg = [];
        if (options.algorithm) {
          options.algorithm = options.algorithm.toLowerCase();
          alg = validateAlgorithm(options.algorithm);
        }
        var i2;
        var stringToSign = "";
        for (i2 = 0; i2 < options.headers.length; i2++) {
          if (typeof options.headers[i2] !== "string")
            throw new TypeError("options.headers must be an array of Strings");
          var h = options.headers[i2].toLowerCase();
          if (h === "request-line") {
            if (!options.strict) {
              stringToSign += request2.method + " " + request2.path + " HTTP/" + options.httpVersion;
            } else {
              throw new StrictParsingError("request-line is not a valid header with strict parsing enabled.");
            }
          } else if (h === "(request-target)") {
            stringToSign += "(request-target): " + request2.method.toLowerCase() + " " + request2.path;
          } else {
            var value = request2.getHeader(h);
            if (value === void 0 || value === "") {
              throw new MissingHeaderError(h + " was not in the request");
            }
            stringToSign += h + ": " + value;
          }
          if (i2 + 1 < options.headers.length)
            stringToSign += "\n";
        }
        if (request2.hasOwnProperty("_stringToSign")) {
          request2._stringToSign = stringToSign;
        }
        var signature2;
        if (alg[0] === "hmac") {
          if (typeof options.key !== "string" && !Buffer.isBuffer(options.key))
            throw new TypeError("options.key must be a string or Buffer");
          var hmac2 = crypto2.createHmac(alg[1].toUpperCase(), options.key);
          hmac2.update(stringToSign);
          signature2 = hmac2.digest("base64");
        } else {
          var key2 = options.key;
          if (typeof key2 === "string" || Buffer.isBuffer(key2))
            key2 = sshpk.parsePrivateKey(options.key);
          assert.ok(
            sshpk.PrivateKey.isPrivateKey(key2, [1, 2]),
            "options.key must be a sshpk.PrivateKey"
          );
          if (!PK_ALGOS[key2.type]) {
            throw new InvalidAlgorithmError(key2.type.toUpperCase() + " type keys are not supported");
          }
          if (alg[0] !== void 0 && key2.type !== alg[0]) {
            throw new InvalidAlgorithmError("options.key must be a " + alg[0].toUpperCase() + " key, was given a " + key2.type.toUpperCase() + " key instead");
          }
          var signer2 = key2.createSign(alg[1]);
          signer2.update(stringToSign);
          var sigObj = signer2.sign();
          if (!HASH_ALGOS[sigObj.hashAlgorithm]) {
            throw new InvalidAlgorithmError(sigObj.hashAlgorithm.toUpperCase() + " is not a supported hash algorithm");
          }
          options.algorithm = key2.type + "-" + sigObj.hashAlgorithm;
          signature2 = sigObj.toString();
          assert.notStrictEqual(signature2, "", "empty signature produced");
        }
        var authzHeaderName = options.authorizationHeaderName || "Authorization";
        request2.setHeader(authzHeaderName, sprintf(
          AUTHZ_FMT,
          options.keyId,
          options.algorithm,
          options.headers.join(" "),
          signature2
        ));
        return true;
      }
    };
    return signer;
  }
  var verify;
  var hasRequiredVerify;
  function requireVerify() {
    if (hasRequiredVerify)
      return verify;
    hasRequiredVerify = 1;
    var assert = requireAssert();
    var crypto2 = require$$0$2;
    var sshpk = requireLib$3();
    var utils2 = requireUtils$1();
    utils2.HASH_ALGOS;
    utils2.PK_ALGOS;
    utils2.InvalidAlgorithmError;
    utils2.HttpSignatureError;
    var validateAlgorithm = utils2.validateAlgorithm;
    verify = {
      /**
       * Verify RSA/DSA signature against public key.  You are expected to pass in
       * an object that was returned from `parse()`.
       *
       * @param {Object} parsedSignature the object you got from `parse`.
       * @param {String} pubkey RSA/DSA private key PEM.
       * @return {Boolean} true if valid, false otherwise.
       * @throws {TypeError} if you pass in bad arguments.
       * @throws {InvalidAlgorithmError}
       */
      verifySignature: function verifySignature(parsedSignature, pubkey) {
        assert.object(parsedSignature, "parsedSignature");
        if (typeof pubkey === "string" || Buffer.isBuffer(pubkey))
          pubkey = sshpk.parseKey(pubkey);
        assert.ok(sshpk.Key.isKey(pubkey, [1, 1]), "pubkey must be a sshpk.Key");
        var alg = validateAlgorithm(parsedSignature.algorithm);
        if (alg[0] === "hmac" || alg[0] !== pubkey.type)
          return false;
        var v = pubkey.createVerify(alg[1]);
        v.update(parsedSignature.signingString);
        return v.verify(parsedSignature.params.signature, "base64");
      },
      /**
       * Verify HMAC against shared secret.  You are expected to pass in an object
       * that was returned from `parse()`.
       *
       * @param {Object} parsedSignature the object you got from `parse`.
       * @param {String} secret HMAC shared secret.
       * @return {Boolean} true if valid, false otherwise.
       * @throws {TypeError} if you pass in bad arguments.
       * @throws {InvalidAlgorithmError}
       */
      verifyHMAC: function verifyHMAC(parsedSignature, secret) {
        assert.object(parsedSignature, "parsedHMAC");
        assert.string(secret, "secret");
        var alg = validateAlgorithm(parsedSignature.algorithm);
        if (alg[0] !== "hmac")
          return false;
        var hashAlg = alg[1].toUpperCase();
        var hmac2 = crypto2.createHmac(hashAlg, secret);
        hmac2.update(parsedSignature.signingString);
        var h1 = crypto2.createHmac(hashAlg, secret);
        h1.update(hmac2.digest());
        h1 = h1.digest();
        var h2 = crypto2.createHmac(hashAlg, secret);
        h2.update(new Buffer(parsedSignature.params.signature, "base64"));
        h2 = h2.digest();
        if (typeof h1 === "string")
          return h1 === h2;
        if (Buffer.isBuffer(h1) && !h1.equals)
          return h1.toString("binary") === h2.toString("binary");
        return h1.equals(h2);
      }
    };
    return verify;
  }
  var lib$2;
  var hasRequiredLib$2;
  function requireLib$2() {
    if (hasRequiredLib$2)
      return lib$2;
    hasRequiredLib$2 = 1;
    var parser2 = requireParser();
    var signer2 = requireSigner();
    var verify2 = requireVerify();
    var utils2 = requireUtils$1();
    lib$2 = {
      parse: parser2.parseRequest,
      parseRequest: parser2.parseRequest,
      sign: signer2.signRequest,
      signRequest: signer2.signRequest,
      createSigner: signer2.createSigner,
      isSigner: signer2.isSigner,
      sshKeyToPEM: utils2.sshKeyToPEM,
      sshKeyFingerprint: utils2.fingerprint,
      pemToRsaSSHKey: utils2.pemToRsaSSHKey,
      verify: verify2.verifySignature,
      verifySignature: verify2.verifySignature,
      verifyHMAC: verify2.verifyHMAC
    };
    return lib$2;
  }
  var mimeTypes = {};
  const require$$0$1 = {
    "application/1d-interleaved-parityfec": {
      source: "iana"
    },
    "application/3gpdash-qoe-report+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/3gpp-ims+xml": {
      source: "iana",
      compressible: true
    },
    "application/3gpphal+json": {
      source: "iana",
      compressible: true
    },
    "application/3gpphalforms+json": {
      source: "iana",
      compressible: true
    },
    "application/a2l": {
      source: "iana"
    },
    "application/ace+cbor": {
      source: "iana"
    },
    "application/activemessage": {
      source: "iana"
    },
    "application/activity+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-costmap+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-costmapfilter+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-directory+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-endpointcost+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-endpointcostparams+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-endpointprop+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-endpointpropparams+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-error+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-networkmap+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-networkmapfilter+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-updatestreamcontrol+json": {
      source: "iana",
      compressible: true
    },
    "application/alto-updatestreamparams+json": {
      source: "iana",
      compressible: true
    },
    "application/aml": {
      source: "iana"
    },
    "application/andrew-inset": {
      source: "iana",
      extensions: [
        "ez"
      ]
    },
    "application/applefile": {
      source: "iana"
    },
    "application/applixware": {
      source: "apache",
      extensions: [
        "aw"
      ]
    },
    "application/at+jwt": {
      source: "iana"
    },
    "application/atf": {
      source: "iana"
    },
    "application/atfx": {
      source: "iana"
    },
    "application/atom+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "atom"
      ]
    },
    "application/atomcat+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "atomcat"
      ]
    },
    "application/atomdeleted+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "atomdeleted"
      ]
    },
    "application/atomicmail": {
      source: "iana"
    },
    "application/atomsvc+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "atomsvc"
      ]
    },
    "application/atsc-dwd+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "dwd"
      ]
    },
    "application/atsc-dynamic-event-message": {
      source: "iana"
    },
    "application/atsc-held+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "held"
      ]
    },
    "application/atsc-rdt+json": {
      source: "iana",
      compressible: true
    },
    "application/atsc-rsat+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rsat"
      ]
    },
    "application/atxml": {
      source: "iana"
    },
    "application/auth-policy+xml": {
      source: "iana",
      compressible: true
    },
    "application/bacnet-xdd+zip": {
      source: "iana",
      compressible: false
    },
    "application/batch-smtp": {
      source: "iana"
    },
    "application/bdoc": {
      compressible: false,
      extensions: [
        "bdoc"
      ]
    },
    "application/beep+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/calendar+json": {
      source: "iana",
      compressible: true
    },
    "application/calendar+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xcs"
      ]
    },
    "application/call-completion": {
      source: "iana"
    },
    "application/cals-1840": {
      source: "iana"
    },
    "application/captive+json": {
      source: "iana",
      compressible: true
    },
    "application/cbor": {
      source: "iana"
    },
    "application/cbor-seq": {
      source: "iana"
    },
    "application/cccex": {
      source: "iana"
    },
    "application/ccmp+xml": {
      source: "iana",
      compressible: true
    },
    "application/ccxml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "ccxml"
      ]
    },
    "application/cdfx+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "cdfx"
      ]
    },
    "application/cdmi-capability": {
      source: "iana",
      extensions: [
        "cdmia"
      ]
    },
    "application/cdmi-container": {
      source: "iana",
      extensions: [
        "cdmic"
      ]
    },
    "application/cdmi-domain": {
      source: "iana",
      extensions: [
        "cdmid"
      ]
    },
    "application/cdmi-object": {
      source: "iana",
      extensions: [
        "cdmio"
      ]
    },
    "application/cdmi-queue": {
      source: "iana",
      extensions: [
        "cdmiq"
      ]
    },
    "application/cdni": {
      source: "iana"
    },
    "application/cea": {
      source: "iana"
    },
    "application/cea-2018+xml": {
      source: "iana",
      compressible: true
    },
    "application/cellml+xml": {
      source: "iana",
      compressible: true
    },
    "application/cfw": {
      source: "iana"
    },
    "application/city+json": {
      source: "iana",
      compressible: true
    },
    "application/clr": {
      source: "iana"
    },
    "application/clue+xml": {
      source: "iana",
      compressible: true
    },
    "application/clue_info+xml": {
      source: "iana",
      compressible: true
    },
    "application/cms": {
      source: "iana"
    },
    "application/cnrp+xml": {
      source: "iana",
      compressible: true
    },
    "application/coap-group+json": {
      source: "iana",
      compressible: true
    },
    "application/coap-payload": {
      source: "iana"
    },
    "application/commonground": {
      source: "iana"
    },
    "application/conference-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/cose": {
      source: "iana"
    },
    "application/cose-key": {
      source: "iana"
    },
    "application/cose-key-set": {
      source: "iana"
    },
    "application/cpl+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "cpl"
      ]
    },
    "application/csrattrs": {
      source: "iana"
    },
    "application/csta+xml": {
      source: "iana",
      compressible: true
    },
    "application/cstadata+xml": {
      source: "iana",
      compressible: true
    },
    "application/csvm+json": {
      source: "iana",
      compressible: true
    },
    "application/cu-seeme": {
      source: "apache",
      extensions: [
        "cu"
      ]
    },
    "application/cwt": {
      source: "iana"
    },
    "application/cybercash": {
      source: "iana"
    },
    "application/dart": {
      compressible: true
    },
    "application/dash+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mpd"
      ]
    },
    "application/dash-patch+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mpp"
      ]
    },
    "application/dashdelta": {
      source: "iana"
    },
    "application/davmount+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "davmount"
      ]
    },
    "application/dca-rft": {
      source: "iana"
    },
    "application/dcd": {
      source: "iana"
    },
    "application/dec-dx": {
      source: "iana"
    },
    "application/dialog-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/dicom": {
      source: "iana"
    },
    "application/dicom+json": {
      source: "iana",
      compressible: true
    },
    "application/dicom+xml": {
      source: "iana",
      compressible: true
    },
    "application/dii": {
      source: "iana"
    },
    "application/dit": {
      source: "iana"
    },
    "application/dns": {
      source: "iana"
    },
    "application/dns+json": {
      source: "iana",
      compressible: true
    },
    "application/dns-message": {
      source: "iana"
    },
    "application/docbook+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "dbk"
      ]
    },
    "application/dots+cbor": {
      source: "iana"
    },
    "application/dskpp+xml": {
      source: "iana",
      compressible: true
    },
    "application/dssc+der": {
      source: "iana",
      extensions: [
        "dssc"
      ]
    },
    "application/dssc+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xdssc"
      ]
    },
    "application/dvcs": {
      source: "iana"
    },
    "application/ecmascript": {
      source: "iana",
      compressible: true,
      extensions: [
        "es",
        "ecma"
      ]
    },
    "application/edi-consent": {
      source: "iana"
    },
    "application/edi-x12": {
      source: "iana",
      compressible: false
    },
    "application/edifact": {
      source: "iana",
      compressible: false
    },
    "application/efi": {
      source: "iana"
    },
    "application/elm+json": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/elm+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.cap+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/emergencycalldata.comment+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.control+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.deviceinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.ecall.msd": {
      source: "iana"
    },
    "application/emergencycalldata.providerinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.serviceinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.subscriberinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/emergencycalldata.veds+xml": {
      source: "iana",
      compressible: true
    },
    "application/emma+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "emma"
      ]
    },
    "application/emotionml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "emotionml"
      ]
    },
    "application/encaprtp": {
      source: "iana"
    },
    "application/epp+xml": {
      source: "iana",
      compressible: true
    },
    "application/epub+zip": {
      source: "iana",
      compressible: false,
      extensions: [
        "epub"
      ]
    },
    "application/eshop": {
      source: "iana"
    },
    "application/exi": {
      source: "iana",
      extensions: [
        "exi"
      ]
    },
    "application/expect-ct-report+json": {
      source: "iana",
      compressible: true
    },
    "application/express": {
      source: "iana",
      extensions: [
        "exp"
      ]
    },
    "application/fastinfoset": {
      source: "iana"
    },
    "application/fastsoap": {
      source: "iana"
    },
    "application/fdt+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "fdt"
      ]
    },
    "application/fhir+json": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/fhir+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/fido.trusted-apps+json": {
      compressible: true
    },
    "application/fits": {
      source: "iana"
    },
    "application/flexfec": {
      source: "iana"
    },
    "application/font-sfnt": {
      source: "iana"
    },
    "application/font-tdpfr": {
      source: "iana",
      extensions: [
        "pfr"
      ]
    },
    "application/font-woff": {
      source: "iana",
      compressible: false
    },
    "application/framework-attributes+xml": {
      source: "iana",
      compressible: true
    },
    "application/geo+json": {
      source: "iana",
      compressible: true,
      extensions: [
        "geojson"
      ]
    },
    "application/geo+json-seq": {
      source: "iana"
    },
    "application/geopackage+sqlite3": {
      source: "iana"
    },
    "application/geoxacml+xml": {
      source: "iana",
      compressible: true
    },
    "application/gltf-buffer": {
      source: "iana"
    },
    "application/gml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "gml"
      ]
    },
    "application/gpx+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "gpx"
      ]
    },
    "application/gxf": {
      source: "apache",
      extensions: [
        "gxf"
      ]
    },
    "application/gzip": {
      source: "iana",
      compressible: false,
      extensions: [
        "gz"
      ]
    },
    "application/h224": {
      source: "iana"
    },
    "application/held+xml": {
      source: "iana",
      compressible: true
    },
    "application/hjson": {
      extensions: [
        "hjson"
      ]
    },
    "application/http": {
      source: "iana"
    },
    "application/hyperstudio": {
      source: "iana",
      extensions: [
        "stk"
      ]
    },
    "application/ibe-key-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/ibe-pkg-reply+xml": {
      source: "iana",
      compressible: true
    },
    "application/ibe-pp-data": {
      source: "iana"
    },
    "application/iges": {
      source: "iana"
    },
    "application/im-iscomposing+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/index": {
      source: "iana"
    },
    "application/index.cmd": {
      source: "iana"
    },
    "application/index.obj": {
      source: "iana"
    },
    "application/index.response": {
      source: "iana"
    },
    "application/index.vnd": {
      source: "iana"
    },
    "application/inkml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "ink",
        "inkml"
      ]
    },
    "application/iotp": {
      source: "iana"
    },
    "application/ipfix": {
      source: "iana",
      extensions: [
        "ipfix"
      ]
    },
    "application/ipp": {
      source: "iana"
    },
    "application/isup": {
      source: "iana"
    },
    "application/its+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "its"
      ]
    },
    "application/java-archive": {
      source: "apache",
      compressible: false,
      extensions: [
        "jar",
        "war",
        "ear"
      ]
    },
    "application/java-serialized-object": {
      source: "apache",
      compressible: false,
      extensions: [
        "ser"
      ]
    },
    "application/java-vm": {
      source: "apache",
      compressible: false,
      extensions: [
        "class"
      ]
    },
    "application/javascript": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "js",
        "mjs"
      ]
    },
    "application/jf2feed+json": {
      source: "iana",
      compressible: true
    },
    "application/jose": {
      source: "iana"
    },
    "application/jose+json": {
      source: "iana",
      compressible: true
    },
    "application/jrd+json": {
      source: "iana",
      compressible: true
    },
    "application/jscalendar+json": {
      source: "iana",
      compressible: true
    },
    "application/json": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "json",
        "map"
      ]
    },
    "application/json-patch+json": {
      source: "iana",
      compressible: true
    },
    "application/json-seq": {
      source: "iana"
    },
    "application/json5": {
      extensions: [
        "json5"
      ]
    },
    "application/jsonml+json": {
      source: "apache",
      compressible: true,
      extensions: [
        "jsonml"
      ]
    },
    "application/jwk+json": {
      source: "iana",
      compressible: true
    },
    "application/jwk-set+json": {
      source: "iana",
      compressible: true
    },
    "application/jwt": {
      source: "iana"
    },
    "application/kpml-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/kpml-response+xml": {
      source: "iana",
      compressible: true
    },
    "application/ld+json": {
      source: "iana",
      compressible: true,
      extensions: [
        "jsonld"
      ]
    },
    "application/lgr+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "lgr"
      ]
    },
    "application/link-format": {
      source: "iana"
    },
    "application/load-control+xml": {
      source: "iana",
      compressible: true
    },
    "application/lost+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "lostxml"
      ]
    },
    "application/lostsync+xml": {
      source: "iana",
      compressible: true
    },
    "application/lpf+zip": {
      source: "iana",
      compressible: false
    },
    "application/lxf": {
      source: "iana"
    },
    "application/mac-binhex40": {
      source: "iana",
      extensions: [
        "hqx"
      ]
    },
    "application/mac-compactpro": {
      source: "apache",
      extensions: [
        "cpt"
      ]
    },
    "application/macwriteii": {
      source: "iana"
    },
    "application/mads+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mads"
      ]
    },
    "application/manifest+json": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "webmanifest"
      ]
    },
    "application/marc": {
      source: "iana",
      extensions: [
        "mrc"
      ]
    },
    "application/marcxml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mrcx"
      ]
    },
    "application/mathematica": {
      source: "iana",
      extensions: [
        "ma",
        "nb",
        "mb"
      ]
    },
    "application/mathml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mathml"
      ]
    },
    "application/mathml-content+xml": {
      source: "iana",
      compressible: true
    },
    "application/mathml-presentation+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-associated-procedure-description+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-deregister+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-envelope+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-msk+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-msk-response+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-protection-description+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-reception-report+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-register+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-register-response+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-schedule+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbms-user-service-description+xml": {
      source: "iana",
      compressible: true
    },
    "application/mbox": {
      source: "iana",
      extensions: [
        "mbox"
      ]
    },
    "application/media-policy-dataset+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mpf"
      ]
    },
    "application/media_control+xml": {
      source: "iana",
      compressible: true
    },
    "application/mediaservercontrol+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mscml"
      ]
    },
    "application/merge-patch+json": {
      source: "iana",
      compressible: true
    },
    "application/metalink+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "metalink"
      ]
    },
    "application/metalink4+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "meta4"
      ]
    },
    "application/mets+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mets"
      ]
    },
    "application/mf4": {
      source: "iana"
    },
    "application/mikey": {
      source: "iana"
    },
    "application/mipc": {
      source: "iana"
    },
    "application/missing-blocks+cbor-seq": {
      source: "iana"
    },
    "application/mmt-aei+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "maei"
      ]
    },
    "application/mmt-usd+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "musd"
      ]
    },
    "application/mods+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mods"
      ]
    },
    "application/moss-keys": {
      source: "iana"
    },
    "application/moss-signature": {
      source: "iana"
    },
    "application/mosskey-data": {
      source: "iana"
    },
    "application/mosskey-request": {
      source: "iana"
    },
    "application/mp21": {
      source: "iana",
      extensions: [
        "m21",
        "mp21"
      ]
    },
    "application/mp4": {
      source: "iana",
      extensions: [
        "mp4s",
        "m4p"
      ]
    },
    "application/mpeg4-generic": {
      source: "iana"
    },
    "application/mpeg4-iod": {
      source: "iana"
    },
    "application/mpeg4-iod-xmt": {
      source: "iana"
    },
    "application/mrb-consumer+xml": {
      source: "iana",
      compressible: true
    },
    "application/mrb-publish+xml": {
      source: "iana",
      compressible: true
    },
    "application/msc-ivr+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/msc-mixer+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/msword": {
      source: "iana",
      compressible: false,
      extensions: [
        "doc",
        "dot"
      ]
    },
    "application/mud+json": {
      source: "iana",
      compressible: true
    },
    "application/multipart-core": {
      source: "iana"
    },
    "application/mxf": {
      source: "iana",
      extensions: [
        "mxf"
      ]
    },
    "application/n-quads": {
      source: "iana",
      extensions: [
        "nq"
      ]
    },
    "application/n-triples": {
      source: "iana",
      extensions: [
        "nt"
      ]
    },
    "application/nasdata": {
      source: "iana"
    },
    "application/news-checkgroups": {
      source: "iana",
      charset: "US-ASCII"
    },
    "application/news-groupinfo": {
      source: "iana",
      charset: "US-ASCII"
    },
    "application/news-transmission": {
      source: "iana"
    },
    "application/nlsml+xml": {
      source: "iana",
      compressible: true
    },
    "application/node": {
      source: "iana",
      extensions: [
        "cjs"
      ]
    },
    "application/nss": {
      source: "iana"
    },
    "application/oauth-authz-req+jwt": {
      source: "iana"
    },
    "application/oblivious-dns-message": {
      source: "iana"
    },
    "application/ocsp-request": {
      source: "iana"
    },
    "application/ocsp-response": {
      source: "iana"
    },
    "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"
      ]
    },
    "application/oda": {
      source: "iana",
      extensions: [
        "oda"
      ]
    },
    "application/odm+xml": {
      source: "iana",
      compressible: true
    },
    "application/odx": {
      source: "iana"
    },
    "application/oebps-package+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "opf"
      ]
    },
    "application/ogg": {
      source: "iana",
      compressible: false,
      extensions: [
        "ogx"
      ]
    },
    "application/omdoc+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "omdoc"
      ]
    },
    "application/onenote": {
      source: "apache",
      extensions: [
        "onetoc",
        "onetoc2",
        "onetmp",
        "onepkg"
      ]
    },
    "application/opc-nodeset+xml": {
      source: "iana",
      compressible: true
    },
    "application/oscore": {
      source: "iana"
    },
    "application/oxps": {
      source: "iana",
      extensions: [
        "oxps"
      ]
    },
    "application/p21": {
      source: "iana"
    },
    "application/p21+zip": {
      source: "iana",
      compressible: false
    },
    "application/p2p-overlay+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "relo"
      ]
    },
    "application/parityfec": {
      source: "iana"
    },
    "application/passport": {
      source: "iana"
    },
    "application/patch-ops-error+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xer"
      ]
    },
    "application/pdf": {
      source: "iana",
      compressible: false,
      extensions: [
        "pdf"
      ]
    },
    "application/pdx": {
      source: "iana"
    },
    "application/pem-certificate-chain": {
      source: "iana"
    },
    "application/pgp-encrypted": {
      source: "iana",
      compressible: false,
      extensions: [
        "pgp"
      ]
    },
    "application/pgp-keys": {
      source: "iana",
      extensions: [
        "asc"
      ]
    },
    "application/pgp-signature": {
      source: "iana",
      extensions: [
        "asc",
        "sig"
      ]
    },
    "application/pics-rules": {
      source: "apache",
      extensions: [
        "prf"
      ]
    },
    "application/pidf+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/pidf-diff+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/pkcs10": {
      source: "iana",
      extensions: [
        "p10"
      ]
    },
    "application/pkcs12": {
      source: "iana"
    },
    "application/pkcs7-mime": {
      source: "iana",
      extensions: [
        "p7m",
        "p7c"
      ]
    },
    "application/pkcs7-signature": {
      source: "iana",
      extensions: [
        "p7s"
      ]
    },
    "application/pkcs8": {
      source: "iana",
      extensions: [
        "p8"
      ]
    },
    "application/pkcs8-encrypted": {
      source: "iana"
    },
    "application/pkix-attr-cert": {
      source: "iana",
      extensions: [
        "ac"
      ]
    },
    "application/pkix-cert": {
      source: "iana",
      extensions: [
        "cer"
      ]
    },
    "application/pkix-crl": {
      source: "iana",
      extensions: [
        "crl"
      ]
    },
    "application/pkix-pkipath": {
      source: "iana",
      extensions: [
        "pkipath"
      ]
    },
    "application/pkixcmp": {
      source: "iana",
      extensions: [
        "pki"
      ]
    },
    "application/pls+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "pls"
      ]
    },
    "application/poc-settings+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/postscript": {
      source: "iana",
      compressible: true,
      extensions: [
        "ai",
        "eps",
        "ps"
      ]
    },
    "application/ppsp-tracker+json": {
      source: "iana",
      compressible: true
    },
    "application/problem+json": {
      source: "iana",
      compressible: true
    },
    "application/problem+xml": {
      source: "iana",
      compressible: true
    },
    "application/provenance+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "provx"
      ]
    },
    "application/prs.alvestrand.titrax-sheet": {
      source: "iana"
    },
    "application/prs.cww": {
      source: "iana",
      extensions: [
        "cww"
      ]
    },
    "application/prs.cyn": {
      source: "iana",
      charset: "7-BIT"
    },
    "application/prs.hpub+zip": {
      source: "iana",
      compressible: false
    },
    "application/prs.nprend": {
      source: "iana"
    },
    "application/prs.plucker": {
      source: "iana"
    },
    "application/prs.rdf-xml-crypt": {
      source: "iana"
    },
    "application/prs.xsf+xml": {
      source: "iana",
      compressible: true
    },
    "application/pskc+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "pskcxml"
      ]
    },
    "application/pvd+json": {
      source: "iana",
      compressible: true
    },
    "application/qsig": {
      source: "iana"
    },
    "application/raml+yaml": {
      compressible: true,
      extensions: [
        "raml"
      ]
    },
    "application/raptorfec": {
      source: "iana"
    },
    "application/rdap+json": {
      source: "iana",
      compressible: true
    },
    "application/rdf+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rdf",
        "owl"
      ]
    },
    "application/reginfo+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rif"
      ]
    },
    "application/relax-ng-compact-syntax": {
      source: "iana",
      extensions: [
        "rnc"
      ]
    },
    "application/remote-printing": {
      source: "iana"
    },
    "application/reputon+json": {
      source: "iana",
      compressible: true
    },
    "application/resource-lists+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rl"
      ]
    },
    "application/resource-lists-diff+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rld"
      ]
    },
    "application/rfc+xml": {
      source: "iana",
      compressible: true
    },
    "application/riscos": {
      source: "iana"
    },
    "application/rlmi+xml": {
      source: "iana",
      compressible: true
    },
    "application/rls-services+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rs"
      ]
    },
    "application/route-apd+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rapd"
      ]
    },
    "application/route-s-tsid+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "sls"
      ]
    },
    "application/route-usd+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rusd"
      ]
    },
    "application/rpki-ghostbusters": {
      source: "iana",
      extensions: [
        "gbr"
      ]
    },
    "application/rpki-manifest": {
      source: "iana",
      extensions: [
        "mft"
      ]
    },
    "application/rpki-publication": {
      source: "iana"
    },
    "application/rpki-roa": {
      source: "iana",
      extensions: [
        "roa"
      ]
    },
    "application/rpki-updown": {
      source: "iana"
    },
    "application/rsd+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "rsd"
      ]
    },
    "application/rss+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "rss"
      ]
    },
    "application/rtf": {
      source: "iana",
      compressible: true,
      extensions: [
        "rtf"
      ]
    },
    "application/rtploopback": {
      source: "iana"
    },
    "application/rtx": {
      source: "iana"
    },
    "application/samlassertion+xml": {
      source: "iana",
      compressible: true
    },
    "application/samlmetadata+xml": {
      source: "iana",
      compressible: true
    },
    "application/sarif+json": {
      source: "iana",
      compressible: true
    },
    "application/sarif-external-properties+json": {
      source: "iana",
      compressible: true
    },
    "application/sbe": {
      source: "iana"
    },
    "application/sbml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "sbml"
      ]
    },
    "application/scaip+xml": {
      source: "iana",
      compressible: true
    },
    "application/scim+json": {
      source: "iana",
      compressible: true
    },
    "application/scvp-cv-request": {
      source: "iana",
      extensions: [
        "scq"
      ]
    },
    "application/scvp-cv-response": {
      source: "iana",
      extensions: [
        "scs"
      ]
    },
    "application/scvp-vp-request": {
      source: "iana",
      extensions: [
        "spq"
      ]
    },
    "application/scvp-vp-response": {
      source: "iana",
      extensions: [
        "spp"
      ]
    },
    "application/sdp": {
      source: "iana",
      extensions: [
        "sdp"
      ]
    },
    "application/secevent+jwt": {
      source: "iana"
    },
    "application/senml+cbor": {
      source: "iana"
    },
    "application/senml+json": {
      source: "iana",
      compressible: true
    },
    "application/senml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "senmlx"
      ]
    },
    "application/senml-etch+cbor": {
      source: "iana"
    },
    "application/senml-etch+json": {
      source: "iana",
      compressible: true
    },
    "application/senml-exi": {
      source: "iana"
    },
    "application/sensml+cbor": {
      source: "iana"
    },
    "application/sensml+json": {
      source: "iana",
      compressible: true
    },
    "application/sensml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "sensmlx"
      ]
    },
    "application/sensml-exi": {
      source: "iana"
    },
    "application/sep+xml": {
      source: "iana",
      compressible: true
    },
    "application/sep-exi": {
      source: "iana"
    },
    "application/session-info": {
      source: "iana"
    },
    "application/set-payment": {
      source: "iana"
    },
    "application/set-payment-initiation": {
      source: "iana",
      extensions: [
        "setpay"
      ]
    },
    "application/set-registration": {
      source: "iana"
    },
    "application/set-registration-initiation": {
      source: "iana",
      extensions: [
        "setreg"
      ]
    },
    "application/sgml": {
      source: "iana"
    },
    "application/sgml-open-catalog": {
      source: "iana"
    },
    "application/shf+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "shf"
      ]
    },
    "application/sieve": {
      source: "iana",
      extensions: [
        "siv",
        "sieve"
      ]
    },
    "application/simple-filter+xml": {
      source: "iana",
      compressible: true
    },
    "application/simple-message-summary": {
      source: "iana"
    },
    "application/simplesymbolcontainer": {
      source: "iana"
    },
    "application/sipc": {
      source: "iana"
    },
    "application/slate": {
      source: "iana"
    },
    "application/smil": {
      source: "iana"
    },
    "application/smil+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "smi",
        "smil"
      ]
    },
    "application/smpte336m": {
      source: "iana"
    },
    "application/soap+fastinfoset": {
      source: "iana"
    },
    "application/soap+xml": {
      source: "iana",
      compressible: true
    },
    "application/sparql-query": {
      source: "iana",
      extensions: [
        "rq"
      ]
    },
    "application/sparql-results+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "srx"
      ]
    },
    "application/spdx+json": {
      source: "iana",
      compressible: true
    },
    "application/spirits-event+xml": {
      source: "iana",
      compressible: true
    },
    "application/sql": {
      source: "iana"
    },
    "application/srgs": {
      source: "iana",
      extensions: [
        "gram"
      ]
    },
    "application/srgs+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "grxml"
      ]
    },
    "application/sru+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "sru"
      ]
    },
    "application/ssdl+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "ssdl"
      ]
    },
    "application/ssml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "ssml"
      ]
    },
    "application/stix+json": {
      source: "iana",
      compressible: true
    },
    "application/swid+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "swidtag"
      ]
    },
    "application/tamp-apex-update": {
      source: "iana"
    },
    "application/tamp-apex-update-confirm": {
      source: "iana"
    },
    "application/tamp-community-update": {
      source: "iana"
    },
    "application/tamp-community-update-confirm": {
      source: "iana"
    },
    "application/tamp-error": {
      source: "iana"
    },
    "application/tamp-sequence-adjust": {
      source: "iana"
    },
    "application/tamp-sequence-adjust-confirm": {
      source: "iana"
    },
    "application/tamp-status-query": {
      source: "iana"
    },
    "application/tamp-status-response": {
      source: "iana"
    },
    "application/tamp-update": {
      source: "iana"
    },
    "application/tamp-update-confirm": {
      source: "iana"
    },
    "application/tar": {
      compressible: true
    },
    "application/taxii+json": {
      source: "iana",
      compressible: true
    },
    "application/td+json": {
      source: "iana",
      compressible: true
    },
    "application/tei+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "tei",
        "teicorpus"
      ]
    },
    "application/tetra_isi": {
      source: "iana"
    },
    "application/thraud+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "tfi"
      ]
    },
    "application/timestamp-query": {
      source: "iana"
    },
    "application/timestamp-reply": {
      source: "iana"
    },
    "application/timestamped-data": {
      source: "iana",
      extensions: [
        "tsd"
      ]
    },
    "application/tlsrpt+gzip": {
      source: "iana"
    },
    "application/tlsrpt+json": {
      source: "iana",
      compressible: true
    },
    "application/tnauthlist": {
      source: "iana"
    },
    "application/token-introspection+jwt": {
      source: "iana"
    },
    "application/toml": {
      compressible: true,
      extensions: [
        "toml"
      ]
    },
    "application/trickle-ice-sdpfrag": {
      source: "iana"
    },
    "application/trig": {
      source: "iana",
      extensions: [
        "trig"
      ]
    },
    "application/ttml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "ttml"
      ]
    },
    "application/tve-trigger": {
      source: "iana"
    },
    "application/tzif": {
      source: "iana"
    },
    "application/tzif-leap": {
      source: "iana"
    },
    "application/ubjson": {
      compressible: false,
      extensions: [
        "ubj"
      ]
    },
    "application/ulpfec": {
      source: "iana"
    },
    "application/urc-grpsheet+xml": {
      source: "iana",
      compressible: true
    },
    "application/urc-ressheet+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "rsheet"
      ]
    },
    "application/urc-targetdesc+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "td"
      ]
    },
    "application/urc-uisocketdesc+xml": {
      source: "iana",
      compressible: true
    },
    "application/vcard+json": {
      source: "iana",
      compressible: true
    },
    "application/vcard+xml": {
      source: "iana",
      compressible: true
    },
    "application/vemmi": {
      source: "iana"
    },
    "application/vividence.scriptfile": {
      source: "apache"
    },
    "application/vnd.1000minds.decision-model+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "1km"
      ]
    },
    "application/vnd.3gpp-prose+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp-prose-pc3ch+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp-v2x-local-service-information": {
      source: "iana"
    },
    "application/vnd.3gpp.5gnas": {
      source: "iana"
    },
    "application/vnd.3gpp.access-transfer-events+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.bsf+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.gmop+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.gtpc": {
      source: "iana"
    },
    "application/vnd.3gpp.interworking-data": {
      source: "iana"
    },
    "application/vnd.3gpp.lpp": {
      source: "iana"
    },
    "application/vnd.3gpp.mc-signalling-ear": {
      source: "iana"
    },
    "application/vnd.3gpp.mcdata-affiliation-command+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcdata-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcdata-payload": {
      source: "iana"
    },
    "application/vnd.3gpp.mcdata-service-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcdata-signalling": {
      source: "iana"
    },
    "application/vnd.3gpp.mcdata-ue-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcdata-user-profile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-affiliation-command+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-floor-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-location-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-mbms-usage-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-service-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-signed+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-ue-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-ue-init-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcptt-user-profile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-affiliation-command+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-affiliation-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-location-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-service-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-transmission-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-ue-config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mcvideo-user-profile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.mid-call+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.ngap": {
      source: "iana"
    },
    "application/vnd.3gpp.pfcp": {
      source: "iana"
    },
    "application/vnd.3gpp.pic-bw-large": {
      source: "iana",
      extensions: [
        "plb"
      ]
    },
    "application/vnd.3gpp.pic-bw-small": {
      source: "iana",
      extensions: [
        "psb"
      ]
    },
    "application/vnd.3gpp.pic-bw-var": {
      source: "iana",
      extensions: [
        "pvb"
      ]
    },
    "application/vnd.3gpp.s1ap": {
      source: "iana"
    },
    "application/vnd.3gpp.sms": {
      source: "iana"
    },
    "application/vnd.3gpp.sms+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.srvcc-ext+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.srvcc-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.state-and-event-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp.ussd+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp2.bcmcsinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.3gpp2.sms": {
      source: "iana"
    },
    "application/vnd.3gpp2.tcap": {
      source: "iana",
      extensions: [
        "tcap"
      ]
    },
    "application/vnd.3lightssoftware.imagescal": {
      source: "iana"
    },
    "application/vnd.3m.post-it-notes": {
      source: "iana",
      extensions: [
        "pwn"
      ]
    },
    "application/vnd.accpac.simply.aso": {
      source: "iana",
      extensions: [
        "aso"
      ]
    },
    "application/vnd.accpac.simply.imp": {
      source: "iana",
      extensions: [
        "imp"
      ]
    },
    "application/vnd.acucobol": {
      source: "iana",
      extensions: [
        "acu"
      ]
    },
    "application/vnd.acucorp": {
      source: "iana",
      extensions: [
        "atc",
        "acutc"
      ]
    },
    "application/vnd.adobe.air-application-installer-package+zip": {
      source: "apache",
      compressible: false,
      extensions: [
        "air"
      ]
    },
    "application/vnd.adobe.flash.movie": {
      source: "iana"
    },
    "application/vnd.adobe.formscentral.fcdt": {
      source: "iana",
      extensions: [
        "fcdt"
      ]
    },
    "application/vnd.adobe.fxp": {
      source: "iana",
      extensions: [
        "fxp",
        "fxpl"
      ]
    },
    "application/vnd.adobe.partial-upload": {
      source: "iana"
    },
    "application/vnd.adobe.xdp+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xdp"
      ]
    },
    "application/vnd.adobe.xfdf": {
      source: "iana",
      extensions: [
        "xfdf"
      ]
    },
    "application/vnd.aether.imp": {
      source: "iana"
    },
    "application/vnd.afpc.afplinedata": {
      source: "iana"
    },
    "application/vnd.afpc.afplinedata-pagedef": {
      source: "iana"
    },
    "application/vnd.afpc.cmoca-cmresource": {
      source: "iana"
    },
    "application/vnd.afpc.foca-charset": {
      source: "iana"
    },
    "application/vnd.afpc.foca-codedfont": {
      source: "iana"
    },
    "application/vnd.afpc.foca-codepage": {
      source: "iana"
    },
    "application/vnd.afpc.modca": {
      source: "iana"
    },
    "application/vnd.afpc.modca-cmtable": {
      source: "iana"
    },
    "application/vnd.afpc.modca-formdef": {
      source: "iana"
    },
    "application/vnd.afpc.modca-mediummap": {
      source: "iana"
    },
    "application/vnd.afpc.modca-objectcontainer": {
      source: "iana"
    },
    "application/vnd.afpc.modca-overlay": {
      source: "iana"
    },
    "application/vnd.afpc.modca-pagesegment": {
      source: "iana"
    },
    "application/vnd.age": {
      source: "iana",
      extensions: [
        "age"
      ]
    },
    "application/vnd.ah-barcode": {
      source: "iana"
    },
    "application/vnd.ahead.space": {
      source: "iana",
      extensions: [
        "ahead"
      ]
    },
    "application/vnd.airzip.filesecure.azf": {
      source: "iana",
      extensions: [
        "azf"
      ]
    },
    "application/vnd.airzip.filesecure.azs": {
      source: "iana",
      extensions: [
        "azs"
      ]
    },
    "application/vnd.amadeus+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.amazon.ebook": {
      source: "apache",
      extensions: [
        "azw"
      ]
    },
    "application/vnd.amazon.mobi8-ebook": {
      source: "iana"
    },
    "application/vnd.americandynamics.acc": {
      source: "iana",
      extensions: [
        "acc"
      ]
    },
    "application/vnd.amiga.ami": {
      source: "iana",
      extensions: [
        "ami"
      ]
    },
    "application/vnd.amundsen.maze+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.android.ota": {
      source: "iana"
    },
    "application/vnd.android.package-archive": {
      source: "apache",
      compressible: false,
      extensions: [
        "apk"
      ]
    },
    "application/vnd.anki": {
      source: "iana"
    },
    "application/vnd.anser-web-certificate-issue-initiation": {
      source: "iana",
      extensions: [
        "cii"
      ]
    },
    "application/vnd.anser-web-funds-transfer-initiation": {
      source: "apache",
      extensions: [
        "fti"
      ]
    },
    "application/vnd.antix.game-component": {
      source: "iana",
      extensions: [
        "atx"
      ]
    },
    "application/vnd.apache.arrow.file": {
      source: "iana"
    },
    "application/vnd.apache.arrow.stream": {
      source: "iana"
    },
    "application/vnd.apache.thrift.binary": {
      source: "iana"
    },
    "application/vnd.apache.thrift.compact": {
      source: "iana"
    },
    "application/vnd.apache.thrift.json": {
      source: "iana"
    },
    "application/vnd.api+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.aplextor.warrp+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.apothekende.reservation+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.apple.installer+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mpkg"
      ]
    },
    "application/vnd.apple.keynote": {
      source: "iana",
      extensions: [
        "key"
      ]
    },
    "application/vnd.apple.mpegurl": {
      source: "iana",
      extensions: [
        "m3u8"
      ]
    },
    "application/vnd.apple.numbers": {
      source: "iana",
      extensions: [
        "numbers"
      ]
    },
    "application/vnd.apple.pages": {
      source: "iana",
      extensions: [
        "pages"
      ]
    },
    "application/vnd.apple.pkpass": {
      compressible: false,
      extensions: [
        "pkpass"
      ]
    },
    "application/vnd.arastra.swi": {
      source: "iana"
    },
    "application/vnd.aristanetworks.swi": {
      source: "iana",
      extensions: [
        "swi"
      ]
    },
    "application/vnd.artisan+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.artsquare": {
      source: "iana"
    },
    "application/vnd.astraea-software.iota": {
      source: "iana",
      extensions: [
        "iota"
      ]
    },
    "application/vnd.audiograph": {
      source: "iana",
      extensions: [
        "aep"
      ]
    },
    "application/vnd.autopackage": {
      source: "iana"
    },
    "application/vnd.avalon+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.avistar+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.balsamiq.bmml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "bmml"
      ]
    },
    "application/vnd.balsamiq.bmpr": {
      source: "iana"
    },
    "application/vnd.banana-accounting": {
      source: "iana"
    },
    "application/vnd.bbf.usp.error": {
      source: "iana"
    },
    "application/vnd.bbf.usp.msg": {
      source: "iana"
    },
    "application/vnd.bbf.usp.msg+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.bekitzur-stech+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.bint.med-content": {
      source: "iana"
    },
    "application/vnd.biopax.rdf+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.blink-idb-value-wrapper": {
      source: "iana"
    },
    "application/vnd.blueice.multipass": {
      source: "iana",
      extensions: [
        "mpm"
      ]
    },
    "application/vnd.bluetooth.ep.oob": {
      source: "iana"
    },
    "application/vnd.bluetooth.le.oob": {
      source: "iana"
    },
    "application/vnd.bmi": {
      source: "iana",
      extensions: [
        "bmi"
      ]
    },
    "application/vnd.bpf": {
      source: "iana"
    },
    "application/vnd.bpf3": {
      source: "iana"
    },
    "application/vnd.businessobjects": {
      source: "iana",
      extensions: [
        "rep"
      ]
    },
    "application/vnd.byu.uapi+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cab-jscript": {
      source: "iana"
    },
    "application/vnd.canon-cpdl": {
      source: "iana"
    },
    "application/vnd.canon-lips": {
      source: "iana"
    },
    "application/vnd.capasystems-pg+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cendio.thinlinc.clientconf": {
      source: "iana"
    },
    "application/vnd.century-systems.tcp_stream": {
      source: "iana"
    },
    "application/vnd.chemdraw+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "cdxml"
      ]
    },
    "application/vnd.chess-pgn": {
      source: "iana"
    },
    "application/vnd.chipnuts.karaoke-mmd": {
      source: "iana",
      extensions: [
        "mmd"
      ]
    },
    "application/vnd.ciedi": {
      source: "iana"
    },
    "application/vnd.cinderella": {
      source: "iana",
      extensions: [
        "cdy"
      ]
    },
    "application/vnd.cirpack.isdn-ext": {
      source: "iana"
    },
    "application/vnd.citationstyles.style+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "csl"
      ]
    },
    "application/vnd.claymore": {
      source: "iana",
      extensions: [
        "cla"
      ]
    },
    "application/vnd.cloanto.rp9": {
      source: "iana",
      extensions: [
        "rp9"
      ]
    },
    "application/vnd.clonk.c4group": {
      source: "iana",
      extensions: [
        "c4g",
        "c4d",
        "c4f",
        "c4p",
        "c4u"
      ]
    },
    "application/vnd.cluetrust.cartomobile-config": {
      source: "iana",
      extensions: [
        "c11amc"
      ]
    },
    "application/vnd.cluetrust.cartomobile-config-pkg": {
      source: "iana",
      extensions: [
        "c11amz"
      ]
    },
    "application/vnd.coffeescript": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.document": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.document-template": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.presentation": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.presentation-template": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.spreadsheet": {
      source: "iana"
    },
    "application/vnd.collabio.xodocuments.spreadsheet-template": {
      source: "iana"
    },
    "application/vnd.collection+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.collection.doc+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.collection.next+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.comicbook+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.comicbook-rar": {
      source: "iana"
    },
    "application/vnd.commerce-battelle": {
      source: "iana"
    },
    "application/vnd.commonspace": {
      source: "iana",
      extensions: [
        "csp"
      ]
    },
    "application/vnd.contact.cmsg": {
      source: "iana",
      extensions: [
        "cdbcmsg"
      ]
    },
    "application/vnd.coreos.ignition+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cosmocaller": {
      source: "iana",
      extensions: [
        "cmc"
      ]
    },
    "application/vnd.crick.clicker": {
      source: "iana",
      extensions: [
        "clkx"
      ]
    },
    "application/vnd.crick.clicker.keyboard": {
      source: "iana",
      extensions: [
        "clkk"
      ]
    },
    "application/vnd.crick.clicker.palette": {
      source: "iana",
      extensions: [
        "clkp"
      ]
    },
    "application/vnd.crick.clicker.template": {
      source: "iana",
      extensions: [
        "clkt"
      ]
    },
    "application/vnd.crick.clicker.wordbank": {
      source: "iana",
      extensions: [
        "clkw"
      ]
    },
    "application/vnd.criticaltools.wbs+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "wbs"
      ]
    },
    "application/vnd.cryptii.pipe+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.crypto-shade-file": {
      source: "iana"
    },
    "application/vnd.cryptomator.encrypted": {
      source: "iana"
    },
    "application/vnd.cryptomator.vault": {
      source: "iana"
    },
    "application/vnd.ctc-posml": {
      source: "iana",
      extensions: [
        "pml"
      ]
    },
    "application/vnd.ctct.ws+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cups-pdf": {
      source: "iana"
    },
    "application/vnd.cups-postscript": {
      source: "iana"
    },
    "application/vnd.cups-ppd": {
      source: "iana",
      extensions: [
        "ppd"
      ]
    },
    "application/vnd.cups-raster": {
      source: "iana"
    },
    "application/vnd.cups-raw": {
      source: "iana"
    },
    "application/vnd.curl": {
      source: "iana"
    },
    "application/vnd.curl.car": {
      source: "apache",
      extensions: [
        "car"
      ]
    },
    "application/vnd.curl.pcurl": {
      source: "apache",
      extensions: [
        "pcurl"
      ]
    },
    "application/vnd.cyan.dean.root+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cybank": {
      source: "iana"
    },
    "application/vnd.cyclonedx+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.cyclonedx+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.d2l.coursepackage1p0+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.d3m-dataset": {
      source: "iana"
    },
    "application/vnd.d3m-problem": {
      source: "iana"
    },
    "application/vnd.dart": {
      source: "iana",
      compressible: true,
      extensions: [
        "dart"
      ]
    },
    "application/vnd.data-vision.rdz": {
      source: "iana",
      extensions: [
        "rdz"
      ]
    },
    "application/vnd.datapackage+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dataresource+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dbf": {
      source: "iana",
      extensions: [
        "dbf"
      ]
    },
    "application/vnd.debian.binary-package": {
      source: "iana"
    },
    "application/vnd.dece.data": {
      source: "iana",
      extensions: [
        "uvf",
        "uvvf",
        "uvd",
        "uvvd"
      ]
    },
    "application/vnd.dece.ttml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "uvt",
        "uvvt"
      ]
    },
    "application/vnd.dece.unspecified": {
      source: "iana",
      extensions: [
        "uvx",
        "uvvx"
      ]
    },
    "application/vnd.dece.zip": {
      source: "iana",
      extensions: [
        "uvz",
        "uvvz"
      ]
    },
    "application/vnd.denovo.fcselayout-link": {
      source: "iana",
      extensions: [
        "fe_launch"
      ]
    },
    "application/vnd.desmume.movie": {
      source: "iana"
    },
    "application/vnd.dir-bi.plate-dl-nosuffix": {
      source: "iana"
    },
    "application/vnd.dm.delegation+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dna": {
      source: "iana",
      extensions: [
        "dna"
      ]
    },
    "application/vnd.document+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dolby.mlp": {
      source: "apache",
      extensions: [
        "mlp"
      ]
    },
    "application/vnd.dolby.mobile.1": {
      source: "iana"
    },
    "application/vnd.dolby.mobile.2": {
      source: "iana"
    },
    "application/vnd.doremir.scorecloud-binary-document": {
      source: "iana"
    },
    "application/vnd.dpgraph": {
      source: "iana",
      extensions: [
        "dpg"
      ]
    },
    "application/vnd.dreamfactory": {
      source: "iana",
      extensions: [
        "dfac"
      ]
    },
    "application/vnd.drive+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ds-keypoint": {
      source: "apache",
      extensions: [
        "kpxx"
      ]
    },
    "application/vnd.dtg.local": {
      source: "iana"
    },
    "application/vnd.dtg.local.flash": {
      source: "iana"
    },
    "application/vnd.dtg.local.html": {
      source: "iana"
    },
    "application/vnd.dvb.ait": {
      source: "iana",
      extensions: [
        "ait"
      ]
    },
    "application/vnd.dvb.dvbisl+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.dvbj": {
      source: "iana"
    },
    "application/vnd.dvb.esgcontainer": {
      source: "iana"
    },
    "application/vnd.dvb.ipdcdftnotifaccess": {
      source: "iana"
    },
    "application/vnd.dvb.ipdcesgaccess": {
      source: "iana"
    },
    "application/vnd.dvb.ipdcesgaccess2": {
      source: "iana"
    },
    "application/vnd.dvb.ipdcesgpdd": {
      source: "iana"
    },
    "application/vnd.dvb.ipdcroaming": {
      source: "iana"
    },
    "application/vnd.dvb.iptv.alfec-base": {
      source: "iana"
    },
    "application/vnd.dvb.iptv.alfec-enhancement": {
      source: "iana"
    },
    "application/vnd.dvb.notif-aggregate-root+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-container+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-generic+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-ia-msglist+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-ia-registration-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-ia-registration-response+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.notif-init+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.dvb.pfr": {
      source: "iana"
    },
    "application/vnd.dvb.service": {
      source: "iana",
      extensions: [
        "svc"
      ]
    },
    "application/vnd.dxr": {
      source: "iana"
    },
    "application/vnd.dynageo": {
      source: "iana",
      extensions: [
        "geo"
      ]
    },
    "application/vnd.dzr": {
      source: "iana"
    },
    "application/vnd.easykaraoke.cdgdownload": {
      source: "iana"
    },
    "application/vnd.ecdis-update": {
      source: "iana"
    },
    "application/vnd.ecip.rlp": {
      source: "iana"
    },
    "application/vnd.eclipse.ditto+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ecowin.chart": {
      source: "iana",
      extensions: [
        "mag"
      ]
    },
    "application/vnd.ecowin.filerequest": {
      source: "iana"
    },
    "application/vnd.ecowin.fileupdate": {
      source: "iana"
    },
    "application/vnd.ecowin.series": {
      source: "iana"
    },
    "application/vnd.ecowin.seriesrequest": {
      source: "iana"
    },
    "application/vnd.ecowin.seriesupdate": {
      source: "iana"
    },
    "application/vnd.efi.img": {
      source: "iana"
    },
    "application/vnd.efi.iso": {
      source: "iana"
    },
    "application/vnd.emclient.accessrequest+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.enliven": {
      source: "iana",
      extensions: [
        "nml"
      ]
    },
    "application/vnd.enphase.envoy": {
      source: "iana"
    },
    "application/vnd.eprints.data+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.epson.esf": {
      source: "iana",
      extensions: [
        "esf"
      ]
    },
    "application/vnd.epson.msf": {
      source: "iana",
      extensions: [
        "msf"
      ]
    },
    "application/vnd.epson.quickanime": {
      source: "iana",
      extensions: [
        "qam"
      ]
    },
    "application/vnd.epson.salt": {
      source: "iana",
      extensions: [
        "slt"
      ]
    },
    "application/vnd.epson.ssf": {
      source: "iana",
      extensions: [
        "ssf"
      ]
    },
    "application/vnd.ericsson.quickcall": {
      source: "iana"
    },
    "application/vnd.espass-espass+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.eszigno3+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "es3",
        "et3"
      ]
    },
    "application/vnd.etsi.aoc+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.asic-e+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.etsi.asic-s+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.etsi.cug+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvcommand+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvdiscovery+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvprofile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvsad-bc+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvsad-cod+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvsad-npvr+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvservice+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvsync+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.iptvueprofile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.mcid+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.mheg5": {
      source: "iana"
    },
    "application/vnd.etsi.overload-control-policy-dataset+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.pstn+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.sci+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.simservs+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.timestamp-token": {
      source: "iana"
    },
    "application/vnd.etsi.tsl+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.etsi.tsl.der": {
      source: "iana"
    },
    "application/vnd.eu.kasparian.car+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.eudora.data": {
      source: "iana"
    },
    "application/vnd.evolv.ecig.profile": {
      source: "iana"
    },
    "application/vnd.evolv.ecig.settings": {
      source: "iana"
    },
    "application/vnd.evolv.ecig.theme": {
      source: "iana"
    },
    "application/vnd.exstream-empower+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.exstream-package": {
      source: "iana"
    },
    "application/vnd.ezpix-album": {
      source: "iana",
      extensions: [
        "ez2"
      ]
    },
    "application/vnd.ezpix-package": {
      source: "iana",
      extensions: [
        "ez3"
      ]
    },
    "application/vnd.f-secure.mobile": {
      source: "iana"
    },
    "application/vnd.familysearch.gedcom+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.fastcopy-disk-image": {
      source: "iana"
    },
    "application/vnd.fdf": {
      source: "iana",
      extensions: [
        "fdf"
      ]
    },
    "application/vnd.fdsn.mseed": {
      source: "iana",
      extensions: [
        "mseed"
      ]
    },
    "application/vnd.fdsn.seed": {
      source: "iana",
      extensions: [
        "seed",
        "dataless"
      ]
    },
    "application/vnd.ffsns": {
      source: "iana"
    },
    "application/vnd.ficlab.flb+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.filmit.zfc": {
      source: "iana"
    },
    "application/vnd.fints": {
      source: "iana"
    },
    "application/vnd.firemonkeys.cloudcell": {
      source: "iana"
    },
    "application/vnd.flographit": {
      source: "iana",
      extensions: [
        "gph"
      ]
    },
    "application/vnd.fluxtime.clip": {
      source: "iana",
      extensions: [
        "ftc"
      ]
    },
    "application/vnd.font-fontforge-sfd": {
      source: "iana"
    },
    "application/vnd.framemaker": {
      source: "iana",
      extensions: [
        "fm",
        "frame",
        "maker",
        "book"
      ]
    },
    "application/vnd.frogans.fnc": {
      source: "iana",
      extensions: [
        "fnc"
      ]
    },
    "application/vnd.frogans.ltf": {
      source: "iana",
      extensions: [
        "ltf"
      ]
    },
    "application/vnd.fsc.weblaunch": {
      source: "iana",
      extensions: [
        "fsc"
      ]
    },
    "application/vnd.fujifilm.fb.docuworks": {
      source: "iana"
    },
    "application/vnd.fujifilm.fb.docuworks.binder": {
      source: "iana"
    },
    "application/vnd.fujifilm.fb.docuworks.container": {
      source: "iana"
    },
    "application/vnd.fujifilm.fb.jfi+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.fujitsu.oasys": {
      source: "iana",
      extensions: [
        "oas"
      ]
    },
    "application/vnd.fujitsu.oasys2": {
      source: "iana",
      extensions: [
        "oa2"
      ]
    },
    "application/vnd.fujitsu.oasys3": {
      source: "iana",
      extensions: [
        "oa3"
      ]
    },
    "application/vnd.fujitsu.oasysgp": {
      source: "iana",
      extensions: [
        "fg5"
      ]
    },
    "application/vnd.fujitsu.oasysprs": {
      source: "iana",
      extensions: [
        "bh2"
      ]
    },
    "application/vnd.fujixerox.art-ex": {
      source: "iana"
    },
    "application/vnd.fujixerox.art4": {
      source: "iana"
    },
    "application/vnd.fujixerox.ddd": {
      source: "iana",
      extensions: [
        "ddd"
      ]
    },
    "application/vnd.fujixerox.docuworks": {
      source: "iana",
      extensions: [
        "xdw"
      ]
    },
    "application/vnd.fujixerox.docuworks.binder": {
      source: "iana",
      extensions: [
        "xbd"
      ]
    },
    "application/vnd.fujixerox.docuworks.container": {
      source: "iana"
    },
    "application/vnd.fujixerox.hbpl": {
      source: "iana"
    },
    "application/vnd.fut-misnet": {
      source: "iana"
    },
    "application/vnd.futoin+cbor": {
      source: "iana"
    },
    "application/vnd.futoin+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.fuzzysheet": {
      source: "iana",
      extensions: [
        "fzs"
      ]
    },
    "application/vnd.genomatix.tuxedo": {
      source: "iana",
      extensions: [
        "txd"
      ]
    },
    "application/vnd.gentics.grd+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.geo+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.geocube+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.geogebra.file": {
      source: "iana",
      extensions: [
        "ggb"
      ]
    },
    "application/vnd.geogebra.slides": {
      source: "iana"
    },
    "application/vnd.geogebra.tool": {
      source: "iana",
      extensions: [
        "ggt"
      ]
    },
    "application/vnd.geometry-explorer": {
      source: "iana",
      extensions: [
        "gex",
        "gre"
      ]
    },
    "application/vnd.geonext": {
      source: "iana",
      extensions: [
        "gxt"
      ]
    },
    "application/vnd.geoplan": {
      source: "iana",
      extensions: [
        "g2w"
      ]
    },
    "application/vnd.geospace": {
      source: "iana",
      extensions: [
        "g3w"
      ]
    },
    "application/vnd.gerber": {
      source: "iana"
    },
    "application/vnd.globalplatform.card-content-mgt": {
      source: "iana"
    },
    "application/vnd.globalplatform.card-content-mgt-response": {
      source: "iana"
    },
    "application/vnd.gmx": {
      source: "iana",
      extensions: [
        "gmx"
      ]
    },
    "application/vnd.google-apps.document": {
      compressible: false,
      extensions: [
        "gdoc"
      ]
    },
    "application/vnd.google-apps.presentation": {
      compressible: false,
      extensions: [
        "gslides"
      ]
    },
    "application/vnd.google-apps.spreadsheet": {
      compressible: false,
      extensions: [
        "gsheet"
      ]
    },
    "application/vnd.google-earth.kml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "kml"
      ]
    },
    "application/vnd.google-earth.kmz": {
      source: "iana",
      compressible: false,
      extensions: [
        "kmz"
      ]
    },
    "application/vnd.gov.sk.e-form+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.gov.sk.e-form+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.gov.sk.xmldatacontainer+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.grafeq": {
      source: "iana",
      extensions: [
        "gqf",
        "gqs"
      ]
    },
    "application/vnd.gridmp": {
      source: "iana"
    },
    "application/vnd.groove-account": {
      source: "iana",
      extensions: [
        "gac"
      ]
    },
    "application/vnd.groove-help": {
      source: "iana",
      extensions: [
        "ghf"
      ]
    },
    "application/vnd.groove-identity-message": {
      source: "iana",
      extensions: [
        "gim"
      ]
    },
    "application/vnd.groove-injector": {
      source: "iana",
      extensions: [
        "grv"
      ]
    },
    "application/vnd.groove-tool-message": {
      source: "iana",
      extensions: [
        "gtm"
      ]
    },
    "application/vnd.groove-tool-template": {
      source: "iana",
      extensions: [
        "tpl"
      ]
    },
    "application/vnd.groove-vcard": {
      source: "iana",
      extensions: [
        "vcg"
      ]
    },
    "application/vnd.hal+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hal+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "hal"
      ]
    },
    "application/vnd.handheld-entertainment+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "zmm"
      ]
    },
    "application/vnd.hbci": {
      source: "iana",
      extensions: [
        "hbci"
      ]
    },
    "application/vnd.hc+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hcl-bireports": {
      source: "iana"
    },
    "application/vnd.hdt": {
      source: "iana"
    },
    "application/vnd.heroku+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hhe.lesson-player": {
      source: "iana",
      extensions: [
        "les"
      ]
    },
    "application/vnd.hl7cda+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.hl7v2+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.hp-hpgl": {
      source: "iana",
      extensions: [
        "hpgl"
      ]
    },
    "application/vnd.hp-hpid": {
      source: "iana",
      extensions: [
        "hpid"
      ]
    },
    "application/vnd.hp-hps": {
      source: "iana",
      extensions: [
        "hps"
      ]
    },
    "application/vnd.hp-jlyt": {
      source: "iana",
      extensions: [
        "jlt"
      ]
    },
    "application/vnd.hp-pcl": {
      source: "iana",
      extensions: [
        "pcl"
      ]
    },
    "application/vnd.hp-pclxl": {
      source: "iana",
      extensions: [
        "pclxl"
      ]
    },
    "application/vnd.httphone": {
      source: "iana"
    },
    "application/vnd.hydrostatix.sof-data": {
      source: "iana",
      extensions: [
        "sfd-hdstx"
      ]
    },
    "application/vnd.hyper+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hyper-item+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hyperdrive+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.hzn-3d-crossword": {
      source: "iana"
    },
    "application/vnd.ibm.afplinedata": {
      source: "iana"
    },
    "application/vnd.ibm.electronic-media": {
      source: "iana"
    },
    "application/vnd.ibm.minipay": {
      source: "iana",
      extensions: [
        "mpy"
      ]
    },
    "application/vnd.ibm.modcap": {
      source: "iana",
      extensions: [
        "afp",
        "listafp",
        "list3820"
      ]
    },
    "application/vnd.ibm.rights-management": {
      source: "iana",
      extensions: [
        "irm"
      ]
    },
    "application/vnd.ibm.secure-container": {
      source: "iana",
      extensions: [
        "sc"
      ]
    },
    "application/vnd.iccprofile": {
      source: "iana",
      extensions: [
        "icc",
        "icm"
      ]
    },
    "application/vnd.ieee.1905": {
      source: "iana"
    },
    "application/vnd.igloader": {
      source: "iana",
      extensions: [
        "igl"
      ]
    },
    "application/vnd.imagemeter.folder+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.imagemeter.image+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.immervision-ivp": {
      source: "iana",
      extensions: [
        "ivp"
      ]
    },
    "application/vnd.immervision-ivu": {
      source: "iana",
      extensions: [
        "ivu"
      ]
    },
    "application/vnd.ims.imsccv1p1": {
      source: "iana"
    },
    "application/vnd.ims.imsccv1p2": {
      source: "iana"
    },
    "application/vnd.ims.imsccv1p3": {
      source: "iana"
    },
    "application/vnd.ims.lis.v2.result+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ims.lti.v2.toolconsumerprofile+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ims.lti.v2.toolproxy+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ims.lti.v2.toolproxy.id+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ims.lti.v2.toolsettings+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ims.lti.v2.toolsettings.simple+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.informedcontrol.rms+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.informix-visionary": {
      source: "iana"
    },
    "application/vnd.infotech.project": {
      source: "iana"
    },
    "application/vnd.infotech.project+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.innopath.wamp.notification": {
      source: "iana"
    },
    "application/vnd.insors.igm": {
      source: "iana",
      extensions: [
        "igm"
      ]
    },
    "application/vnd.intercon.formnet": {
      source: "iana",
      extensions: [
        "xpw",
        "xpx"
      ]
    },
    "application/vnd.intergeo": {
      source: "iana",
      extensions: [
        "i2g"
      ]
    },
    "application/vnd.intertrust.digibox": {
      source: "iana"
    },
    "application/vnd.intertrust.nncp": {
      source: "iana"
    },
    "application/vnd.intu.qbo": {
      source: "iana",
      extensions: [
        "qbo"
      ]
    },
    "application/vnd.intu.qfx": {
      source: "iana",
      extensions: [
        "qfx"
      ]
    },
    "application/vnd.iptc.g2.catalogitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.conceptitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.knowledgeitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.newsitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.newsmessage+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.packageitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.iptc.g2.planningitem+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ipunplugged.rcprofile": {
      source: "iana",
      extensions: [
        "rcprofile"
      ]
    },
    "application/vnd.irepository.package+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "irp"
      ]
    },
    "application/vnd.is-xpr": {
      source: "iana",
      extensions: [
        "xpr"
      ]
    },
    "application/vnd.isac.fcs": {
      source: "iana",
      extensions: [
        "fcs"
      ]
    },
    "application/vnd.iso11783-10+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.jam": {
      source: "iana",
      extensions: [
        "jam"
      ]
    },
    "application/vnd.japannet-directory-service": {
      source: "iana"
    },
    "application/vnd.japannet-jpnstore-wakeup": {
      source: "iana"
    },
    "application/vnd.japannet-payment-wakeup": {
      source: "iana"
    },
    "application/vnd.japannet-registration": {
      source: "iana"
    },
    "application/vnd.japannet-registration-wakeup": {
      source: "iana"
    },
    "application/vnd.japannet-setstore-wakeup": {
      source: "iana"
    },
    "application/vnd.japannet-verification": {
      source: "iana"
    },
    "application/vnd.japannet-verification-wakeup": {
      source: "iana"
    },
    "application/vnd.jcp.javame.midlet-rms": {
      source: "iana",
      extensions: [
        "rms"
      ]
    },
    "application/vnd.jisp": {
      source: "iana",
      extensions: [
        "jisp"
      ]
    },
    "application/vnd.joost.joda-archive": {
      source: "iana",
      extensions: [
        "joda"
      ]
    },
    "application/vnd.jsk.isdn-ngn": {
      source: "iana"
    },
    "application/vnd.kahootz": {
      source: "iana",
      extensions: [
        "ktz",
        "ktr"
      ]
    },
    "application/vnd.kde.karbon": {
      source: "iana",
      extensions: [
        "karbon"
      ]
    },
    "application/vnd.kde.kchart": {
      source: "iana",
      extensions: [
        "chrt"
      ]
    },
    "application/vnd.kde.kformula": {
      source: "iana",
      extensions: [
        "kfo"
      ]
    },
    "application/vnd.kde.kivio": {
      source: "iana",
      extensions: [
        "flw"
      ]
    },
    "application/vnd.kde.kontour": {
      source: "iana",
      extensions: [
        "kon"
      ]
    },
    "application/vnd.kde.kpresenter": {
      source: "iana",
      extensions: [
        "kpr",
        "kpt"
      ]
    },
    "application/vnd.kde.kspread": {
      source: "iana",
      extensions: [
        "ksp"
      ]
    },
    "application/vnd.kde.kword": {
      source: "iana",
      extensions: [
        "kwd",
        "kwt"
      ]
    },
    "application/vnd.kenameaapp": {
      source: "iana",
      extensions: [
        "htke"
      ]
    },
    "application/vnd.kidspiration": {
      source: "iana",
      extensions: [
        "kia"
      ]
    },
    "application/vnd.kinar": {
      source: "iana",
      extensions: [
        "kne",
        "knp"
      ]
    },
    "application/vnd.koan": {
      source: "iana",
      extensions: [
        "skp",
        "skd",
        "skt",
        "skm"
      ]
    },
    "application/vnd.kodak-descriptor": {
      source: "iana",
      extensions: [
        "sse"
      ]
    },
    "application/vnd.las": {
      source: "iana"
    },
    "application/vnd.las.las+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.las.las+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "lasxml"
      ]
    },
    "application/vnd.laszip": {
      source: "iana"
    },
    "application/vnd.leap+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.liberty-request+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.llamagraphics.life-balance.desktop": {
      source: "iana",
      extensions: [
        "lbd"
      ]
    },
    "application/vnd.llamagraphics.life-balance.exchange+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "lbe"
      ]
    },
    "application/vnd.logipipe.circuit+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.loom": {
      source: "iana"
    },
    "application/vnd.lotus-1-2-3": {
      source: "iana",
      extensions: [
        "123"
      ]
    },
    "application/vnd.lotus-approach": {
      source: "iana",
      extensions: [
        "apr"
      ]
    },
    "application/vnd.lotus-freelance": {
      source: "iana",
      extensions: [
        "pre"
      ]
    },
    "application/vnd.lotus-notes": {
      source: "iana",
      extensions: [
        "nsf"
      ]
    },
    "application/vnd.lotus-organizer": {
      source: "iana",
      extensions: [
        "org"
      ]
    },
    "application/vnd.lotus-screencam": {
      source: "iana",
      extensions: [
        "scm"
      ]
    },
    "application/vnd.lotus-wordpro": {
      source: "iana",
      extensions: [
        "lwp"
      ]
    },
    "application/vnd.macports.portpkg": {
      source: "iana",
      extensions: [
        "portpkg"
      ]
    },
    "application/vnd.mapbox-vector-tile": {
      source: "iana",
      extensions: [
        "mvt"
      ]
    },
    "application/vnd.marlin.drm.actiontoken+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.marlin.drm.conftoken+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.marlin.drm.license+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.marlin.drm.mdcf": {
      source: "iana"
    },
    "application/vnd.mason+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.maxar.archive.3tz+zip": {
      source: "iana",
      compressible: false
    },
    "application/vnd.maxmind.maxmind-db": {
      source: "iana"
    },
    "application/vnd.mcd": {
      source: "iana",
      extensions: [
        "mcd"
      ]
    },
    "application/vnd.medcalcdata": {
      source: "iana",
      extensions: [
        "mc1"
      ]
    },
    "application/vnd.mediastation.cdkey": {
      source: "iana",
      extensions: [
        "cdkey"
      ]
    },
    "application/vnd.meridian-slingshot": {
      source: "iana"
    },
    "application/vnd.mfer": {
      source: "iana",
      extensions: [
        "mwf"
      ]
    },
    "application/vnd.mfmp": {
      source: "iana",
      extensions: [
        "mfm"
      ]
    },
    "application/vnd.micro+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.micrografx.flo": {
      source: "iana",
      extensions: [
        "flo"
      ]
    },
    "application/vnd.micrografx.igx": {
      source: "iana",
      extensions: [
        "igx"
      ]
    },
    "application/vnd.microsoft.portable-executable": {
      source: "iana"
    },
    "application/vnd.microsoft.windows.thumbnail-cache": {
      source: "iana"
    },
    "application/vnd.miele+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.mif": {
      source: "iana",
      extensions: [
        "mif"
      ]
    },
    "application/vnd.minisoft-hp3000-save": {
      source: "iana"
    },
    "application/vnd.mitsubishi.misty-guard.trustweb": {
      source: "iana"
    },
    "application/vnd.mobius.daf": {
      source: "iana",
      extensions: [
        "daf"
      ]
    },
    "application/vnd.mobius.dis": {
      source: "iana",
      extensions: [
        "dis"
      ]
    },
    "application/vnd.mobius.mbk": {
      source: "iana",
      extensions: [
        "mbk"
      ]
    },
    "application/vnd.mobius.mqy": {
      source: "iana",
      extensions: [
        "mqy"
      ]
    },
    "application/vnd.mobius.msl": {
      source: "iana",
      extensions: [
        "msl"
      ]
    },
    "application/vnd.mobius.plc": {
      source: "iana",
      extensions: [
        "plc"
      ]
    },
    "application/vnd.mobius.txf": {
      source: "iana",
      extensions: [
        "txf"
      ]
    },
    "application/vnd.mophun.application": {
      source: "iana",
      extensions: [
        "mpn"
      ]
    },
    "application/vnd.mophun.certificate": {
      source: "iana",
      extensions: [
        "mpc"
      ]
    },
    "application/vnd.motorola.flexsuite": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.adsi": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.fis": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.gotap": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.kmr": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.ttc": {
      source: "iana"
    },
    "application/vnd.motorola.flexsuite.wem": {
      source: "iana"
    },
    "application/vnd.motorola.iprm": {
      source: "iana"
    },
    "application/vnd.mozilla.xul+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xul"
      ]
    },
    "application/vnd.ms-3mfdocument": {
      source: "iana"
    },
    "application/vnd.ms-artgalry": {
      source: "iana",
      extensions: [
        "cil"
      ]
    },
    "application/vnd.ms-asf": {
      source: "iana"
    },
    "application/vnd.ms-cab-compressed": {
      source: "iana",
      extensions: [
        "cab"
      ]
    },
    "application/vnd.ms-color.iccprofile": {
      source: "apache"
    },
    "application/vnd.ms-excel": {
      source: "iana",
      compressible: false,
      extensions: [
        "xls",
        "xlm",
        "xla",
        "xlc",
        "xlt",
        "xlw"
      ]
    },
    "application/vnd.ms-excel.addin.macroenabled.12": {
      source: "iana",
      extensions: [
        "xlam"
      ]
    },
    "application/vnd.ms-excel.sheet.binary.macroenabled.12": {
      source: "iana",
      extensions: [
        "xlsb"
      ]
    },
    "application/vnd.ms-excel.sheet.macroenabled.12": {
      source: "iana",
      extensions: [
        "xlsm"
      ]
    },
    "application/vnd.ms-excel.template.macroenabled.12": {
      source: "iana",
      extensions: [
        "xltm"
      ]
    },
    "application/vnd.ms-fontobject": {
      source: "iana",
      compressible: true,
      extensions: [
        "eot"
      ]
    },
    "application/vnd.ms-htmlhelp": {
      source: "iana",
      extensions: [
        "chm"
      ]
    },
    "application/vnd.ms-ims": {
      source: "iana",
      extensions: [
        "ims"
      ]
    },
    "application/vnd.ms-lrm": {
      source: "iana",
      extensions: [
        "lrm"
      ]
    },
    "application/vnd.ms-office.activex+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ms-officetheme": {
      source: "iana",
      extensions: [
        "thmx"
      ]
    },
    "application/vnd.ms-opentype": {
      source: "apache",
      compressible: true
    },
    "application/vnd.ms-outlook": {
      compressible: false,
      extensions: [
        "msg"
      ]
    },
    "application/vnd.ms-package.obfuscated-opentype": {
      source: "apache"
    },
    "application/vnd.ms-pki.seccat": {
      source: "apache",
      extensions: [
        "cat"
      ]
    },
    "application/vnd.ms-pki.stl": {
      source: "apache",
      extensions: [
        "stl"
      ]
    },
    "application/vnd.ms-playready.initiator+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ms-powerpoint": {
      source: "iana",
      compressible: false,
      extensions: [
        "ppt",
        "pps",
        "pot"
      ]
    },
    "application/vnd.ms-powerpoint.addin.macroenabled.12": {
      source: "iana",
      extensions: [
        "ppam"
      ]
    },
    "application/vnd.ms-powerpoint.presentation.macroenabled.12": {
      source: "iana",
      extensions: [
        "pptm"
      ]
    },
    "application/vnd.ms-powerpoint.slide.macroenabled.12": {
      source: "iana",
      extensions: [
        "sldm"
      ]
    },
    "application/vnd.ms-powerpoint.slideshow.macroenabled.12": {
      source: "iana",
      extensions: [
        "ppsm"
      ]
    },
    "application/vnd.ms-powerpoint.template.macroenabled.12": {
      source: "iana",
      extensions: [
        "potm"
      ]
    },
    "application/vnd.ms-printdevicecapabilities+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ms-printing.printticket+xml": {
      source: "apache",
      compressible: true
    },
    "application/vnd.ms-printschematicket+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ms-project": {
      source: "iana",
      extensions: [
        "mpp",
        "mpt"
      ]
    },
    "application/vnd.ms-tnef": {
      source: "iana"
    },
    "application/vnd.ms-windows.devicepairing": {
      source: "iana"
    },
    "application/vnd.ms-windows.nwprinting.oob": {
      source: "iana"
    },
    "application/vnd.ms-windows.printerpairing": {
      source: "iana"
    },
    "application/vnd.ms-windows.wsd.oob": {
      source: "iana"
    },
    "application/vnd.ms-wmdrm.lic-chlg-req": {
      source: "iana"
    },
    "application/vnd.ms-wmdrm.lic-resp": {
      source: "iana"
    },
    "application/vnd.ms-wmdrm.meter-chlg-req": {
      source: "iana"
    },
    "application/vnd.ms-wmdrm.meter-resp": {
      source: "iana"
    },
    "application/vnd.ms-word.document.macroenabled.12": {
      source: "iana",
      extensions: [
        "docm"
      ]
    },
    "application/vnd.ms-word.template.macroenabled.12": {
      source: "iana",
      extensions: [
        "dotm"
      ]
    },
    "application/vnd.ms-works": {
      source: "iana",
      extensions: [
        "wps",
        "wks",
        "wcm",
        "wdb"
      ]
    },
    "application/vnd.ms-wpl": {
      source: "iana",
      extensions: [
        "wpl"
      ]
    },
    "application/vnd.ms-xpsdocument": {
      source: "iana",
      compressible: false,
      extensions: [
        "xps"
      ]
    },
    "application/vnd.msa-disk-image": {
      source: "iana"
    },
    "application/vnd.mseq": {
      source: "iana",
      extensions: [
        "mseq"
      ]
    },
    "application/vnd.msign": {
      source: "iana"
    },
    "application/vnd.multiad.creator": {
      source: "iana"
    },
    "application/vnd.multiad.creator.cif": {
      source: "iana"
    },
    "application/vnd.music-niff": {
      source: "iana"
    },
    "application/vnd.musician": {
      source: "iana",
      extensions: [
        "mus"
      ]
    },
    "application/vnd.muvee.style": {
      source: "iana",
      extensions: [
        "msty"
      ]
    },
    "application/vnd.mynfc": {
      source: "iana",
      extensions: [
        "taglet"
      ]
    },
    "application/vnd.nacamar.ybrid+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.ncd.control": {
      source: "iana"
    },
    "application/vnd.ncd.reference": {
      source: "iana"
    },
    "application/vnd.nearst.inv+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nebumind.line": {
      source: "iana"
    },
    "application/vnd.nervana": {
      source: "iana"
    },
    "application/vnd.netfpx": {
      source: "iana"
    },
    "application/vnd.neurolanguage.nlu": {
      source: "iana",
      extensions: [
        "nlu"
      ]
    },
    "application/vnd.nimn": {
      source: "iana"
    },
    "application/vnd.nintendo.nitro.rom": {
      source: "iana"
    },
    "application/vnd.nintendo.snes.rom": {
      source: "iana"
    },
    "application/vnd.nitf": {
      source: "iana",
      extensions: [
        "ntf",
        "nitf"
      ]
    },
    "application/vnd.noblenet-directory": {
      source: "iana",
      extensions: [
        "nnd"
      ]
    },
    "application/vnd.noblenet-sealer": {
      source: "iana",
      extensions: [
        "nns"
      ]
    },
    "application/vnd.noblenet-web": {
      source: "iana",
      extensions: [
        "nnw"
      ]
    },
    "application/vnd.nokia.catalogs": {
      source: "iana"
    },
    "application/vnd.nokia.conml+wbxml": {
      source: "iana"
    },
    "application/vnd.nokia.conml+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nokia.iptv.config+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nokia.isds-radio-presets": {
      source: "iana"
    },
    "application/vnd.nokia.landmark+wbxml": {
      source: "iana"
    },
    "application/vnd.nokia.landmark+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nokia.landmarkcollection+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nokia.n-gage.ac+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "ac"
      ]
    },
    "application/vnd.nokia.n-gage.data": {
      source: "iana",
      extensions: [
        "ngdat"
      ]
    },
    "application/vnd.nokia.n-gage.symbian.install": {
      source: "iana",
      extensions: [
        "n-gage"
      ]
    },
    "application/vnd.nokia.ncd": {
      source: "iana"
    },
    "application/vnd.nokia.pcd+wbxml": {
      source: "iana"
    },
    "application/vnd.nokia.pcd+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.nokia.radio-preset": {
      source: "iana",
      extensions: [
        "rpst"
      ]
    },
    "application/vnd.nokia.radio-presets": {
      source: "iana",
      extensions: [
        "rpss"
      ]
    },
    "application/vnd.novadigm.edm": {
      source: "iana",
      extensions: [
        "edm"
      ]
    },
    "application/vnd.novadigm.edx": {
      source: "iana",
      extensions: [
        "edx"
      ]
    },
    "application/vnd.novadigm.ext": {
      source: "iana",
      extensions: [
        "ext"
      ]
    },
    "application/vnd.ntt-local.content-share": {
      source: "iana"
    },
    "application/vnd.ntt-local.file-transfer": {
      source: "iana"
    },
    "application/vnd.ntt-local.ogw_remote-access": {
      source: "iana"
    },
    "application/vnd.ntt-local.sip-ta_remote": {
      source: "iana"
    },
    "application/vnd.ntt-local.sip-ta_tcp_stream": {
      source: "iana"
    },
    "application/vnd.oasis.opendocument.chart": {
      source: "iana",
      extensions: [
        "odc"
      ]
    },
    "application/vnd.oasis.opendocument.chart-template": {
      source: "iana",
      extensions: [
        "otc"
      ]
    },
    "application/vnd.oasis.opendocument.database": {
      source: "iana",
      extensions: [
        "odb"
      ]
    },
    "application/vnd.oasis.opendocument.formula": {
      source: "iana",
      extensions: [
        "odf"
      ]
    },
    "application/vnd.oasis.opendocument.formula-template": {
      source: "iana",
      extensions: [
        "odft"
      ]
    },
    "application/vnd.oasis.opendocument.graphics": {
      source: "iana",
      compressible: false,
      extensions: [
        "odg"
      ]
    },
    "application/vnd.oasis.opendocument.graphics-template": {
      source: "iana",
      extensions: [
        "otg"
      ]
    },
    "application/vnd.oasis.opendocument.image": {
      source: "iana",
      extensions: [
        "odi"
      ]
    },
    "application/vnd.oasis.opendocument.image-template": {
      source: "iana",
      extensions: [
        "oti"
      ]
    },
    "application/vnd.oasis.opendocument.presentation": {
      source: "iana",
      compressible: false,
      extensions: [
        "odp"
      ]
    },
    "application/vnd.oasis.opendocument.presentation-template": {
      source: "iana",
      extensions: [
        "otp"
      ]
    },
    "application/vnd.oasis.opendocument.spreadsheet": {
      source: "iana",
      compressible: false,
      extensions: [
        "ods"
      ]
    },
    "application/vnd.oasis.opendocument.spreadsheet-template": {
      source: "iana",
      extensions: [
        "ots"
      ]
    },
    "application/vnd.oasis.opendocument.text": {
      source: "iana",
      compressible: false,
      extensions: [
        "odt"
      ]
    },
    "application/vnd.oasis.opendocument.text-master": {
      source: "iana",
      extensions: [
        "odm"
      ]
    },
    "application/vnd.oasis.opendocument.text-template": {
      source: "iana",
      extensions: [
        "ott"
      ]
    },
    "application/vnd.oasis.opendocument.text-web": {
      source: "iana",
      extensions: [
        "oth"
      ]
    },
    "application/vnd.obn": {
      source: "iana"
    },
    "application/vnd.ocf+cbor": {
      source: "iana"
    },
    "application/vnd.oci.image.manifest.v1+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oftn.l10n+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.contentaccessdownload+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.contentaccessstreaming+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.cspg-hexbinary": {
      source: "iana"
    },
    "application/vnd.oipf.dae.svg+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.dae.xhtml+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.mippvcontrolmessage+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.pae.gem": {
      source: "iana"
    },
    "application/vnd.oipf.spdiscovery+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.spdlist+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.ueprofile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oipf.userprofile+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.olpc-sugar": {
      source: "iana",
      extensions: [
        "xo"
      ]
    },
    "application/vnd.oma-scws-config": {
      source: "iana"
    },
    "application/vnd.oma-scws-http-request": {
      source: "iana"
    },
    "application/vnd.oma-scws-http-response": {
      source: "iana"
    },
    "application/vnd.oma.bcast.associated-procedure-parameter+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.drm-trigger+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.imd+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.ltkm": {
      source: "iana"
    },
    "application/vnd.oma.bcast.notification+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.provisioningtrigger": {
      source: "iana"
    },
    "application/vnd.oma.bcast.sgboot": {
      source: "iana"
    },
    "application/vnd.oma.bcast.sgdd+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.sgdu": {
      source: "iana"
    },
    "application/vnd.oma.bcast.simple-symbol-container": {
      source: "iana"
    },
    "application/vnd.oma.bcast.smartcard-trigger+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.sprov+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.bcast.stkm": {
      source: "iana"
    },
    "application/vnd.oma.cab-address-book+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.cab-feature-handler+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.cab-pcc+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.cab-subs-invite+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.cab-user-prefs+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.dcd": {
      source: "iana"
    },
    "application/vnd.oma.dcdc": {
      source: "iana"
    },
    "application/vnd.oma.dd2+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "dd2"
      ]
    },
    "application/vnd.oma.drm.risd+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.group-usage-list+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.lwm2m+cbor": {
      source: "iana"
    },
    "application/vnd.oma.lwm2m+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.lwm2m+tlv": {
      source: "iana"
    },
    "application/vnd.oma.pal+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.poc.detailed-progress-report+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.poc.final-report+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.poc.groups+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.poc.invocation-descriptor+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.poc.optimized-progress-report+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.push": {
      source: "iana"
    },
    "application/vnd.oma.scidm.messages+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oma.xcap-directory+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.omads-email+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.omads-file+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.omads-folder+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.omaloc-supl-init": {
      source: "iana"
    },
    "application/vnd.onepager": {
      source: "iana"
    },
    "application/vnd.onepagertamp": {
      source: "iana"
    },
    "application/vnd.onepagertamx": {
      source: "iana"
    },
    "application/vnd.onepagertat": {
      source: "iana"
    },
    "application/vnd.onepagertatp": {
      source: "iana"
    },
    "application/vnd.onepagertatx": {
      source: "iana"
    },
    "application/vnd.openblox.game+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "obgx"
      ]
    },
    "application/vnd.openblox.game-binary": {
      source: "iana"
    },
    "application/vnd.openeye.oeb": {
      source: "iana"
    },
    "application/vnd.openofficeorg.extension": {
      source: "apache",
      extensions: [
        "oxt"
      ]
    },
    "application/vnd.openstreetmap.data+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "osm"
      ]
    },
    "application/vnd.opentimestamps.ots": {
      source: "iana"
    },
    "application/vnd.openxmlformats-officedocument.custom-properties+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawing+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.extended-properties+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.presentation": {
      source: "iana",
      compressible: false,
      extensions: [
        "pptx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slide": {
      source: "iana",
      extensions: [
        "sldx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slideshow": {
      source: "iana",
      extensions: [
        "ppsx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.template": {
      source: "iana",
      extensions: [
        "potx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": {
      source: "iana",
      compressible: false,
      extensions: [
        "xlsx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.template": {
      source: "iana",
      extensions: [
        "xltx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.theme+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.themeoverride+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.vmldrawing": {
      source: "iana"
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": {
      source: "iana",
      compressible: false,
      extensions: [
        "docx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.template": {
      source: "iana",
      extensions: [
        "dotx"
      ]
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-package.core-properties+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.openxmlformats-package.relationships+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oracle.resource+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.orange.indata": {
      source: "iana"
    },
    "application/vnd.osa.netdeploy": {
      source: "iana"
    },
    "application/vnd.osgeo.mapguide.package": {
      source: "iana",
      extensions: [
        "mgp"
      ]
    },
    "application/vnd.osgi.bundle": {
      source: "iana"
    },
    "application/vnd.osgi.dp": {
      source: "iana",
      extensions: [
        "dp"
      ]
    },
    "application/vnd.osgi.subsystem": {
      source: "iana",
      extensions: [
        "esa"
      ]
    },
    "application/vnd.otps.ct-kip+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.oxli.countgraph": {
      source: "iana"
    },
    "application/vnd.pagerduty+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.palm": {
      source: "iana",
      extensions: [
        "pdb",
        "pqa",
        "oprc"
      ]
    },
    "application/vnd.panoply": {
      source: "iana"
    },
    "application/vnd.paos.xml": {
      source: "iana"
    },
    "application/vnd.patentdive": {
      source: "iana"
    },
    "application/vnd.patientecommsdoc": {
      source: "iana"
    },
    "application/vnd.pawaafile": {
      source: "iana",
      extensions: [
        "paw"
      ]
    },
    "application/vnd.pcos": {
      source: "iana"
    },
    "application/vnd.pg.format": {
      source: "iana",
      extensions: [
        "str"
      ]
    },
    "application/vnd.pg.osasli": {
      source: "iana",
      extensions: [
        "ei6"
      ]
    },
    "application/vnd.piaccess.application-licence": {
      source: "iana"
    },
    "application/vnd.picsel": {
      source: "iana",
      extensions: [
        "efif"
      ]
    },
    "application/vnd.pmi.widget": {
      source: "iana",
      extensions: [
        "wg"
      ]
    },
    "application/vnd.poc.group-advertisement+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.pocketlearn": {
      source: "iana",
      extensions: [
        "plf"
      ]
    },
    "application/vnd.powerbuilder6": {
      source: "iana",
      extensions: [
        "pbd"
      ]
    },
    "application/vnd.powerbuilder6-s": {
      source: "iana"
    },
    "application/vnd.powerbuilder7": {
      source: "iana"
    },
    "application/vnd.powerbuilder7-s": {
      source: "iana"
    },
    "application/vnd.powerbuilder75": {
      source: "iana"
    },
    "application/vnd.powerbuilder75-s": {
      source: "iana"
    },
    "application/vnd.preminet": {
      source: "iana"
    },
    "application/vnd.previewsystems.box": {
      source: "iana",
      extensions: [
        "box"
      ]
    },
    "application/vnd.proteus.magazine": {
      source: "iana",
      extensions: [
        "mgz"
      ]
    },
    "application/vnd.psfs": {
      source: "iana"
    },
    "application/vnd.publishare-delta-tree": {
      source: "iana",
      extensions: [
        "qps"
      ]
    },
    "application/vnd.pvi.ptid1": {
      source: "iana",
      extensions: [
        "ptid"
      ]
    },
    "application/vnd.pwg-multiplexed": {
      source: "iana"
    },
    "application/vnd.pwg-xhtml-print+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.qualcomm.brew-app-res": {
      source: "iana"
    },
    "application/vnd.quarantainenet": {
      source: "iana"
    },
    "application/vnd.quark.quarkxpress": {
      source: "iana",
      extensions: [
        "qxd",
        "qxt",
        "qwd",
        "qwt",
        "qxl",
        "qxb"
      ]
    },
    "application/vnd.quobject-quoxdocument": {
      source: "iana"
    },
    "application/vnd.radisys.moml+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-audit+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-audit-conf+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-audit-conn+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-audit-dialog+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-audit-stream+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-conf+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-base+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-fax-detect+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-group+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-speech+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.radisys.msml-dialog-transform+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.rainstor.data": {
      source: "iana"
    },
    "application/vnd.rapid": {
      source: "iana"
    },
    "application/vnd.rar": {
      source: "iana",
      extensions: [
        "rar"
      ]
    },
    "application/vnd.realvnc.bed": {
      source: "iana",
      extensions: [
        "bed"
      ]
    },
    "application/vnd.recordare.musicxml": {
      source: "iana",
      extensions: [
        "mxl"
      ]
    },
    "application/vnd.recordare.musicxml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "musicxml"
      ]
    },
    "application/vnd.renlearn.rlprint": {
      source: "iana"
    },
    "application/vnd.resilient.logic": {
      source: "iana"
    },
    "application/vnd.restful+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.rig.cryptonote": {
      source: "iana",
      extensions: [
        "cryptonote"
      ]
    },
    "application/vnd.rim.cod": {
      source: "apache",
      extensions: [
        "cod"
      ]
    },
    "application/vnd.rn-realmedia": {
      source: "apache",
      extensions: [
        "rm"
      ]
    },
    "application/vnd.rn-realmedia-vbr": {
      source: "apache",
      extensions: [
        "rmvb"
      ]
    },
    "application/vnd.route66.link66+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "link66"
      ]
    },
    "application/vnd.rs-274x": {
      source: "iana"
    },
    "application/vnd.ruckus.download": {
      source: "iana"
    },
    "application/vnd.s3sms": {
      source: "iana"
    },
    "application/vnd.sailingtracker.track": {
      source: "iana",
      extensions: [
        "st"
      ]
    },
    "application/vnd.sar": {
      source: "iana"
    },
    "application/vnd.sbm.cid": {
      source: "iana"
    },
    "application/vnd.sbm.mid2": {
      source: "iana"
    },
    "application/vnd.scribus": {
      source: "iana"
    },
    "application/vnd.sealed.3df": {
      source: "iana"
    },
    "application/vnd.sealed.csf": {
      source: "iana"
    },
    "application/vnd.sealed.doc": {
      source: "iana"
    },
    "application/vnd.sealed.eml": {
      source: "iana"
    },
    "application/vnd.sealed.mht": {
      source: "iana"
    },
    "application/vnd.sealed.net": {
      source: "iana"
    },
    "application/vnd.sealed.ppt": {
      source: "iana"
    },
    "application/vnd.sealed.tiff": {
      source: "iana"
    },
    "application/vnd.sealed.xls": {
      source: "iana"
    },
    "application/vnd.sealedmedia.softseal.html": {
      source: "iana"
    },
    "application/vnd.sealedmedia.softseal.pdf": {
      source: "iana"
    },
    "application/vnd.seemail": {
      source: "iana",
      extensions: [
        "see"
      ]
    },
    "application/vnd.seis+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.sema": {
      source: "iana",
      extensions: [
        "sema"
      ]
    },
    "application/vnd.semd": {
      source: "iana",
      extensions: [
        "semd"
      ]
    },
    "application/vnd.semf": {
      source: "iana",
      extensions: [
        "semf"
      ]
    },
    "application/vnd.shade-save-file": {
      source: "iana"
    },
    "application/vnd.shana.informed.formdata": {
      source: "iana",
      extensions: [
        "ifm"
      ]
    },
    "application/vnd.shana.informed.formtemplate": {
      source: "iana",
      extensions: [
        "itp"
      ]
    },
    "application/vnd.shana.informed.interchange": {
      source: "iana",
      extensions: [
        "iif"
      ]
    },
    "application/vnd.shana.informed.package": {
      source: "iana",
      extensions: [
        "ipk"
      ]
    },
    "application/vnd.shootproof+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.shopkick+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.shp": {
      source: "iana"
    },
    "application/vnd.shx": {
      source: "iana"
    },
    "application/vnd.sigrok.session": {
      source: "iana"
    },
    "application/vnd.simtech-mindmapper": {
      source: "iana",
      extensions: [
        "twd",
        "twds"
      ]
    },
    "application/vnd.siren+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.smaf": {
      source: "iana",
      extensions: [
        "mmf"
      ]
    },
    "application/vnd.smart.notebook": {
      source: "iana"
    },
    "application/vnd.smart.teacher": {
      source: "iana",
      extensions: [
        "teacher"
      ]
    },
    "application/vnd.snesdev-page-table": {
      source: "iana"
    },
    "application/vnd.software602.filler.form+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "fo"
      ]
    },
    "application/vnd.software602.filler.form-xml-zip": {
      source: "iana"
    },
    "application/vnd.solent.sdkm+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "sdkm",
        "sdkd"
      ]
    },
    "application/vnd.spotfire.dxp": {
      source: "iana",
      extensions: [
        "dxp"
      ]
    },
    "application/vnd.spotfire.sfs": {
      source: "iana",
      extensions: [
        "sfs"
      ]
    },
    "application/vnd.sqlite3": {
      source: "iana"
    },
    "application/vnd.sss-cod": {
      source: "iana"
    },
    "application/vnd.sss-dtf": {
      source: "iana"
    },
    "application/vnd.sss-ntf": {
      source: "iana"
    },
    "application/vnd.stardivision.calc": {
      source: "apache",
      extensions: [
        "sdc"
      ]
    },
    "application/vnd.stardivision.draw": {
      source: "apache",
      extensions: [
        "sda"
      ]
    },
    "application/vnd.stardivision.impress": {
      source: "apache",
      extensions: [
        "sdd"
      ]
    },
    "application/vnd.stardivision.math": {
      source: "apache",
      extensions: [
        "smf"
      ]
    },
    "application/vnd.stardivision.writer": {
      source: "apache",
      extensions: [
        "sdw",
        "vor"
      ]
    },
    "application/vnd.stardivision.writer-global": {
      source: "apache",
      extensions: [
        "sgl"
      ]
    },
    "application/vnd.stepmania.package": {
      source: "iana",
      extensions: [
        "smzip"
      ]
    },
    "application/vnd.stepmania.stepchart": {
      source: "iana",
      extensions: [
        "sm"
      ]
    },
    "application/vnd.street-stream": {
      source: "iana"
    },
    "application/vnd.sun.wadl+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "wadl"
      ]
    },
    "application/vnd.sun.xml.calc": {
      source: "apache",
      extensions: [
        "sxc"
      ]
    },
    "application/vnd.sun.xml.calc.template": {
      source: "apache",
      extensions: [
        "stc"
      ]
    },
    "application/vnd.sun.xml.draw": {
      source: "apache",
      extensions: [
        "sxd"
      ]
    },
    "application/vnd.sun.xml.draw.template": {
      source: "apache",
      extensions: [
        "std"
      ]
    },
    "application/vnd.sun.xml.impress": {
      source: "apache",
      extensions: [
        "sxi"
      ]
    },
    "application/vnd.sun.xml.impress.template": {
      source: "apache",
      extensions: [
        "sti"
      ]
    },
    "application/vnd.sun.xml.math": {
      source: "apache",
      extensions: [
        "sxm"
      ]
    },
    "application/vnd.sun.xml.writer": {
      source: "apache",
      extensions: [
        "sxw"
      ]
    },
    "application/vnd.sun.xml.writer.global": {
      source: "apache",
      extensions: [
        "sxg"
      ]
    },
    "application/vnd.sun.xml.writer.template": {
      source: "apache",
      extensions: [
        "stw"
      ]
    },
    "application/vnd.sus-calendar": {
      source: "iana",
      extensions: [
        "sus",
        "susp"
      ]
    },
    "application/vnd.svd": {
      source: "iana",
      extensions: [
        "svd"
      ]
    },
    "application/vnd.swiftview-ics": {
      source: "iana"
    },
    "application/vnd.sycle+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.syft+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.symbian.install": {
      source: "apache",
      extensions: [
        "sis",
        "sisx"
      ]
    },
    "application/vnd.syncml+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "xsm"
      ]
    },
    "application/vnd.syncml.dm+wbxml": {
      source: "iana",
      charset: "UTF-8",
      extensions: [
        "bdm"
      ]
    },
    "application/vnd.syncml.dm+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "xdm"
      ]
    },
    "application/vnd.syncml.dm.notification": {
      source: "iana"
    },
    "application/vnd.syncml.dmddf+wbxml": {
      source: "iana"
    },
    "application/vnd.syncml.dmddf+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "ddf"
      ]
    },
    "application/vnd.syncml.dmtnds+wbxml": {
      source: "iana"
    },
    "application/vnd.syncml.dmtnds+xml": {
      source: "iana",
      charset: "UTF-8",
      compressible: true
    },
    "application/vnd.syncml.ds.notification": {
      source: "iana"
    },
    "application/vnd.tableschema+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.tao.intent-module-archive": {
      source: "iana",
      extensions: [
        "tao"
      ]
    },
    "application/vnd.tcpdump.pcap": {
      source: "iana",
      extensions: [
        "pcap",
        "cap",
        "dmp"
      ]
    },
    "application/vnd.think-cell.ppttc+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.tmd.mediaflex.api+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.tml": {
      source: "iana"
    },
    "application/vnd.tmobile-livetv": {
      source: "iana",
      extensions: [
        "tmo"
      ]
    },
    "application/vnd.tri.onesource": {
      source: "iana"
    },
    "application/vnd.trid.tpt": {
      source: "iana",
      extensions: [
        "tpt"
      ]
    },
    "application/vnd.triscape.mxs": {
      source: "iana",
      extensions: [
        "mxs"
      ]
    },
    "application/vnd.trueapp": {
      source: "iana",
      extensions: [
        "tra"
      ]
    },
    "application/vnd.truedoc": {
      source: "iana"
    },
    "application/vnd.ubisoft.webplayer": {
      source: "iana"
    },
    "application/vnd.ufdl": {
      source: "iana",
      extensions: [
        "ufd",
        "ufdl"
      ]
    },
    "application/vnd.uiq.theme": {
      source: "iana",
      extensions: [
        "utz"
      ]
    },
    "application/vnd.umajin": {
      source: "iana",
      extensions: [
        "umj"
      ]
    },
    "application/vnd.unity": {
      source: "iana",
      extensions: [
        "unityweb"
      ]
    },
    "application/vnd.uoml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "uoml"
      ]
    },
    "application/vnd.uplanet.alert": {
      source: "iana"
    },
    "application/vnd.uplanet.alert-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.bearer-choice": {
      source: "iana"
    },
    "application/vnd.uplanet.bearer-choice-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.cacheop": {
      source: "iana"
    },
    "application/vnd.uplanet.cacheop-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.channel": {
      source: "iana"
    },
    "application/vnd.uplanet.channel-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.list": {
      source: "iana"
    },
    "application/vnd.uplanet.list-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.listcmd": {
      source: "iana"
    },
    "application/vnd.uplanet.listcmd-wbxml": {
      source: "iana"
    },
    "application/vnd.uplanet.signal": {
      source: "iana"
    },
    "application/vnd.uri-map": {
      source: "iana"
    },
    "application/vnd.valve.source.material": {
      source: "iana"
    },
    "application/vnd.vcx": {
      source: "iana",
      extensions: [
        "vcx"
      ]
    },
    "application/vnd.vd-study": {
      source: "iana"
    },
    "application/vnd.vectorworks": {
      source: "iana"
    },
    "application/vnd.vel+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.verimatrix.vcas": {
      source: "iana"
    },
    "application/vnd.veritone.aion+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.veryant.thin": {
      source: "iana"
    },
    "application/vnd.ves.encrypted": {
      source: "iana"
    },
    "application/vnd.vidsoft.vidconference": {
      source: "iana"
    },
    "application/vnd.visio": {
      source: "iana",
      extensions: [
        "vsd",
        "vst",
        "vss",
        "vsw"
      ]
    },
    "application/vnd.visionary": {
      source: "iana",
      extensions: [
        "vis"
      ]
    },
    "application/vnd.vividence.scriptfile": {
      source: "iana"
    },
    "application/vnd.vsf": {
      source: "iana",
      extensions: [
        "vsf"
      ]
    },
    "application/vnd.wap.sic": {
      source: "iana"
    },
    "application/vnd.wap.slc": {
      source: "iana"
    },
    "application/vnd.wap.wbxml": {
      source: "iana",
      charset: "UTF-8",
      extensions: [
        "wbxml"
      ]
    },
    "application/vnd.wap.wmlc": {
      source: "iana",
      extensions: [
        "wmlc"
      ]
    },
    "application/vnd.wap.wmlscriptc": {
      source: "iana",
      extensions: [
        "wmlsc"
      ]
    },
    "application/vnd.webturbo": {
      source: "iana",
      extensions: [
        "wtb"
      ]
    },
    "application/vnd.wfa.dpp": {
      source: "iana"
    },
    "application/vnd.wfa.p2p": {
      source: "iana"
    },
    "application/vnd.wfa.wsc": {
      source: "iana"
    },
    "application/vnd.windows.devicepairing": {
      source: "iana"
    },
    "application/vnd.wmc": {
      source: "iana"
    },
    "application/vnd.wmf.bootstrap": {
      source: "iana"
    },
    "application/vnd.wolfram.mathematica": {
      source: "iana"
    },
    "application/vnd.wolfram.mathematica.package": {
      source: "iana"
    },
    "application/vnd.wolfram.player": {
      source: "iana",
      extensions: [
        "nbp"
      ]
    },
    "application/vnd.wordperfect": {
      source: "iana",
      extensions: [
        "wpd"
      ]
    },
    "application/vnd.wqd": {
      source: "iana",
      extensions: [
        "wqd"
      ]
    },
    "application/vnd.wrq-hp3000-labelled": {
      source: "iana"
    },
    "application/vnd.wt.stf": {
      source: "iana",
      extensions: [
        "stf"
      ]
    },
    "application/vnd.wv.csp+wbxml": {
      source: "iana"
    },
    "application/vnd.wv.csp+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.wv.ssp+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.xacml+json": {
      source: "iana",
      compressible: true
    },
    "application/vnd.xara": {
      source: "iana",
      extensions: [
        "xar"
      ]
    },
    "application/vnd.xfdl": {
      source: "iana",
      extensions: [
        "xfdl"
      ]
    },
    "application/vnd.xfdl.webform": {
      source: "iana"
    },
    "application/vnd.xmi+xml": {
      source: "iana",
      compressible: true
    },
    "application/vnd.xmpie.cpkg": {
      source: "iana"
    },
    "application/vnd.xmpie.dpkg": {
      source: "iana"
    },
    "application/vnd.xmpie.plan": {
      source: "iana"
    },
    "application/vnd.xmpie.ppkg": {
      source: "iana"
    },
    "application/vnd.xmpie.xlim": {
      source: "iana"
    },
    "application/vnd.yamaha.hv-dic": {
      source: "iana",
      extensions: [
        "hvd"
      ]
    },
    "application/vnd.yamaha.hv-script": {
      source: "iana",
      extensions: [
        "hvs"
      ]
    },
    "application/vnd.yamaha.hv-voice": {
      source: "iana",
      extensions: [
        "hvp"
      ]
    },
    "application/vnd.yamaha.openscoreformat": {
      source: "iana",
      extensions: [
        "osf"
      ]
    },
    "application/vnd.yamaha.openscoreformat.osfpvg+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "osfpvg"
      ]
    },
    "application/vnd.yamaha.remote-setup": {
      source: "iana"
    },
    "application/vnd.yamaha.smaf-audio": {
      source: "iana",
      extensions: [
        "saf"
      ]
    },
    "application/vnd.yamaha.smaf-phrase": {
      source: "iana",
      extensions: [
        "spf"
      ]
    },
    "application/vnd.yamaha.through-ngn": {
      source: "iana"
    },
    "application/vnd.yamaha.tunnel-udpencap": {
      source: "iana"
    },
    "application/vnd.yaoweme": {
      source: "iana"
    },
    "application/vnd.yellowriver-custom-menu": {
      source: "iana",
      extensions: [
        "cmp"
      ]
    },
    "application/vnd.youtube.yt": {
      source: "iana"
    },
    "application/vnd.zul": {
      source: "iana",
      extensions: [
        "zir",
        "zirz"
      ]
    },
    "application/vnd.zzazz.deck+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "zaz"
      ]
    },
    "application/voicexml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "vxml"
      ]
    },
    "application/voucher-cms+json": {
      source: "iana",
      compressible: true
    },
    "application/vq-rtcpxr": {
      source: "iana"
    },
    "application/wasm": {
      source: "iana",
      compressible: true,
      extensions: [
        "wasm"
      ]
    },
    "application/watcherinfo+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "wif"
      ]
    },
    "application/webpush-options+json": {
      source: "iana",
      compressible: true
    },
    "application/whoispp-query": {
      source: "iana"
    },
    "application/whoispp-response": {
      source: "iana"
    },
    "application/widget": {
      source: "iana",
      extensions: [
        "wgt"
      ]
    },
    "application/winhlp": {
      source: "apache",
      extensions: [
        "hlp"
      ]
    },
    "application/wita": {
      source: "iana"
    },
    "application/wordperfect5.1": {
      source: "iana"
    },
    "application/wsdl+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "wsdl"
      ]
    },
    "application/wspolicy+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "wspolicy"
      ]
    },
    "application/x-7z-compressed": {
      source: "apache",
      compressible: false,
      extensions: [
        "7z"
      ]
    },
    "application/x-abiword": {
      source: "apache",
      extensions: [
        "abw"
      ]
    },
    "application/x-ace-compressed": {
      source: "apache",
      extensions: [
        "ace"
      ]
    },
    "application/x-amf": {
      source: "apache"
    },
    "application/x-apple-diskimage": {
      source: "apache",
      extensions: [
        "dmg"
      ]
    },
    "application/x-arj": {
      compressible: false,
      extensions: [
        "arj"
      ]
    },
    "application/x-authorware-bin": {
      source: "apache",
      extensions: [
        "aab",
        "x32",
        "u32",
        "vox"
      ]
    },
    "application/x-authorware-map": {
      source: "apache",
      extensions: [
        "aam"
      ]
    },
    "application/x-authorware-seg": {
      source: "apache",
      extensions: [
        "aas"
      ]
    },
    "application/x-bcpio": {
      source: "apache",
      extensions: [
        "bcpio"
      ]
    },
    "application/x-bdoc": {
      compressible: false,
      extensions: [
        "bdoc"
      ]
    },
    "application/x-bittorrent": {
      source: "apache",
      extensions: [
        "torrent"
      ]
    },
    "application/x-blorb": {
      source: "apache",
      extensions: [
        "blb",
        "blorb"
      ]
    },
    "application/x-bzip": {
      source: "apache",
      compressible: false,
      extensions: [
        "bz"
      ]
    },
    "application/x-bzip2": {
      source: "apache",
      compressible: false,
      extensions: [
        "bz2",
        "boz"
      ]
    },
    "application/x-cbr": {
      source: "apache",
      extensions: [
        "cbr",
        "cba",
        "cbt",
        "cbz",
        "cb7"
      ]
    },
    "application/x-cdlink": {
      source: "apache",
      extensions: [
        "vcd"
      ]
    },
    "application/x-cfs-compressed": {
      source: "apache",
      extensions: [
        "cfs"
      ]
    },
    "application/x-chat": {
      source: "apache",
      extensions: [
        "chat"
      ]
    },
    "application/x-chess-pgn": {
      source: "apache",
      extensions: [
        "pgn"
      ]
    },
    "application/x-chrome-extension": {
      extensions: [
        "crx"
      ]
    },
    "application/x-cocoa": {
      source: "nginx",
      extensions: [
        "cco"
      ]
    },
    "application/x-compress": {
      source: "apache"
    },
    "application/x-conference": {
      source: "apache",
      extensions: [
        "nsc"
      ]
    },
    "application/x-cpio": {
      source: "apache",
      extensions: [
        "cpio"
      ]
    },
    "application/x-csh": {
      source: "apache",
      extensions: [
        "csh"
      ]
    },
    "application/x-deb": {
      compressible: false
    },
    "application/x-debian-package": {
      source: "apache",
      extensions: [
        "deb",
        "udeb"
      ]
    },
    "application/x-dgc-compressed": {
      source: "apache",
      extensions: [
        "dgc"
      ]
    },
    "application/x-director": {
      source: "apache",
      extensions: [
        "dir",
        "dcr",
        "dxr",
        "cst",
        "cct",
        "cxt",
        "w3d",
        "fgd",
        "swa"
      ]
    },
    "application/x-doom": {
      source: "apache",
      extensions: [
        "wad"
      ]
    },
    "application/x-dtbncx+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "ncx"
      ]
    },
    "application/x-dtbook+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "dtb"
      ]
    },
    "application/x-dtbresource+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "res"
      ]
    },
    "application/x-dvi": {
      source: "apache",
      compressible: false,
      extensions: [
        "dvi"
      ]
    },
    "application/x-envoy": {
      source: "apache",
      extensions: [
        "evy"
      ]
    },
    "application/x-eva": {
      source: "apache",
      extensions: [
        "eva"
      ]
    },
    "application/x-font-bdf": {
      source: "apache",
      extensions: [
        "bdf"
      ]
    },
    "application/x-font-dos": {
      source: "apache"
    },
    "application/x-font-framemaker": {
      source: "apache"
    },
    "application/x-font-ghostscript": {
      source: "apache",
      extensions: [
        "gsf"
      ]
    },
    "application/x-font-libgrx": {
      source: "apache"
    },
    "application/x-font-linux-psf": {
      source: "apache",
      extensions: [
        "psf"
      ]
    },
    "application/x-font-pcf": {
      source: "apache",
      extensions: [
        "pcf"
      ]
    },
    "application/x-font-snf": {
      source: "apache",
      extensions: [
        "snf"
      ]
    },
    "application/x-font-speedo": {
      source: "apache"
    },
    "application/x-font-sunos-news": {
      source: "apache"
    },
    "application/x-font-type1": {
      source: "apache",
      extensions: [
        "pfa",
        "pfb",
        "pfm",
        "afm"
      ]
    },
    "application/x-font-vfont": {
      source: "apache"
    },
    "application/x-freearc": {
      source: "apache",
      extensions: [
        "arc"
      ]
    },
    "application/x-futuresplash": {
      source: "apache",
      extensions: [
        "spl"
      ]
    },
    "application/x-gca-compressed": {
      source: "apache",
      extensions: [
        "gca"
      ]
    },
    "application/x-glulx": {
      source: "apache",
      extensions: [
        "ulx"
      ]
    },
    "application/x-gnumeric": {
      source: "apache",
      extensions: [
        "gnumeric"
      ]
    },
    "application/x-gramps-xml": {
      source: "apache",
      extensions: [
        "gramps"
      ]
    },
    "application/x-gtar": {
      source: "apache",
      extensions: [
        "gtar"
      ]
    },
    "application/x-gzip": {
      source: "apache"
    },
    "application/x-hdf": {
      source: "apache",
      extensions: [
        "hdf"
      ]
    },
    "application/x-httpd-php": {
      compressible: true,
      extensions: [
        "php"
      ]
    },
    "application/x-install-instructions": {
      source: "apache",
      extensions: [
        "install"
      ]
    },
    "application/x-iso9660-image": {
      source: "apache",
      extensions: [
        "iso"
      ]
    },
    "application/x-iwork-keynote-sffkey": {
      extensions: [
        "key"
      ]
    },
    "application/x-iwork-numbers-sffnumbers": {
      extensions: [
        "numbers"
      ]
    },
    "application/x-iwork-pages-sffpages": {
      extensions: [
        "pages"
      ]
    },
    "application/x-java-archive-diff": {
      source: "nginx",
      extensions: [
        "jardiff"
      ]
    },
    "application/x-java-jnlp-file": {
      source: "apache",
      compressible: false,
      extensions: [
        "jnlp"
      ]
    },
    "application/x-javascript": {
      compressible: true
    },
    "application/x-keepass2": {
      extensions: [
        "kdbx"
      ]
    },
    "application/x-latex": {
      source: "apache",
      compressible: false,
      extensions: [
        "latex"
      ]
    },
    "application/x-lua-bytecode": {
      extensions: [
        "luac"
      ]
    },
    "application/x-lzh-compressed": {
      source: "apache",
      extensions: [
        "lzh",
        "lha"
      ]
    },
    "application/x-makeself": {
      source: "nginx",
      extensions: [
        "run"
      ]
    },
    "application/x-mie": {
      source: "apache",
      extensions: [
        "mie"
      ]
    },
    "application/x-mobipocket-ebook": {
      source: "apache",
      extensions: [
        "prc",
        "mobi"
      ]
    },
    "application/x-mpegurl": {
      compressible: false
    },
    "application/x-ms-application": {
      source: "apache",
      extensions: [
        "application"
      ]
    },
    "application/x-ms-shortcut": {
      source: "apache",
      extensions: [
        "lnk"
      ]
    },
    "application/x-ms-wmd": {
      source: "apache",
      extensions: [
        "wmd"
      ]
    },
    "application/x-ms-wmz": {
      source: "apache",
      extensions: [
        "wmz"
      ]
    },
    "application/x-ms-xbap": {
      source: "apache",
      extensions: [
        "xbap"
      ]
    },
    "application/x-msaccess": {
      source: "apache",
      extensions: [
        "mdb"
      ]
    },
    "application/x-msbinder": {
      source: "apache",
      extensions: [
        "obd"
      ]
    },
    "application/x-mscardfile": {
      source: "apache",
      extensions: [
        "crd"
      ]
    },
    "application/x-msclip": {
      source: "apache",
      extensions: [
        "clp"
      ]
    },
    "application/x-msdos-program": {
      extensions: [
        "exe"
      ]
    },
    "application/x-msdownload": {
      source: "apache",
      extensions: [
        "exe",
        "dll",
        "com",
        "bat",
        "msi"
      ]
    },
    "application/x-msmediaview": {
      source: "apache",
      extensions: [
        "mvb",
        "m13",
        "m14"
      ]
    },
    "application/x-msmetafile": {
      source: "apache",
      extensions: [
        "wmf",
        "wmz",
        "emf",
        "emz"
      ]
    },
    "application/x-msmoney": {
      source: "apache",
      extensions: [
        "mny"
      ]
    },
    "application/x-mspublisher": {
      source: "apache",
      extensions: [
        "pub"
      ]
    },
    "application/x-msschedule": {
      source: "apache",
      extensions: [
        "scd"
      ]
    },
    "application/x-msterminal": {
      source: "apache",
      extensions: [
        "trm"
      ]
    },
    "application/x-mswrite": {
      source: "apache",
      extensions: [
        "wri"
      ]
    },
    "application/x-netcdf": {
      source: "apache",
      extensions: [
        "nc",
        "cdf"
      ]
    },
    "application/x-ns-proxy-autoconfig": {
      compressible: true,
      extensions: [
        "pac"
      ]
    },
    "application/x-nzb": {
      source: "apache",
      extensions: [
        "nzb"
      ]
    },
    "application/x-perl": {
      source: "nginx",
      extensions: [
        "pl",
        "pm"
      ]
    },
    "application/x-pilot": {
      source: "nginx",
      extensions: [
        "prc",
        "pdb"
      ]
    },
    "application/x-pkcs12": {
      source: "apache",
      compressible: false,
      extensions: [
        "p12",
        "pfx"
      ]
    },
    "application/x-pkcs7-certificates": {
      source: "apache",
      extensions: [
        "p7b",
        "spc"
      ]
    },
    "application/x-pkcs7-certreqresp": {
      source: "apache",
      extensions: [
        "p7r"
      ]
    },
    "application/x-pki-message": {
      source: "iana"
    },
    "application/x-rar-compressed": {
      source: "apache",
      compressible: false,
      extensions: [
        "rar"
      ]
    },
    "application/x-redhat-package-manager": {
      source: "nginx",
      extensions: [
        "rpm"
      ]
    },
    "application/x-research-info-systems": {
      source: "apache",
      extensions: [
        "ris"
      ]
    },
    "application/x-sea": {
      source: "nginx",
      extensions: [
        "sea"
      ]
    },
    "application/x-sh": {
      source: "apache",
      compressible: true,
      extensions: [
        "sh"
      ]
    },
    "application/x-shar": {
      source: "apache",
      extensions: [
        "shar"
      ]
    },
    "application/x-shockwave-flash": {
      source: "apache",
      compressible: false,
      extensions: [
        "swf"
      ]
    },
    "application/x-silverlight-app": {
      source: "apache",
      extensions: [
        "xap"
      ]
    },
    "application/x-sql": {
      source: "apache",
      extensions: [
        "sql"
      ]
    },
    "application/x-stuffit": {
      source: "apache",
      compressible: false,
      extensions: [
        "sit"
      ]
    },
    "application/x-stuffitx": {
      source: "apache",
      extensions: [
        "sitx"
      ]
    },
    "application/x-subrip": {
      source: "apache",
      extensions: [
        "srt"
      ]
    },
    "application/x-sv4cpio": {
      source: "apache",
      extensions: [
        "sv4cpio"
      ]
    },
    "application/x-sv4crc": {
      source: "apache",
      extensions: [
        "sv4crc"
      ]
    },
    "application/x-t3vm-image": {
      source: "apache",
      extensions: [
        "t3"
      ]
    },
    "application/x-tads": {
      source: "apache",
      extensions: [
        "gam"
      ]
    },
    "application/x-tar": {
      source: "apache",
      compressible: true,
      extensions: [
        "tar"
      ]
    },
    "application/x-tcl": {
      source: "apache",
      extensions: [
        "tcl",
        "tk"
      ]
    },
    "application/x-tex": {
      source: "apache",
      extensions: [
        "tex"
      ]
    },
    "application/x-tex-tfm": {
      source: "apache",
      extensions: [
        "tfm"
      ]
    },
    "application/x-texinfo": {
      source: "apache",
      extensions: [
        "texinfo",
        "texi"
      ]
    },
    "application/x-tgif": {
      source: "apache",
      extensions: [
        "obj"
      ]
    },
    "application/x-ustar": {
      source: "apache",
      extensions: [
        "ustar"
      ]
    },
    "application/x-virtualbox-hdd": {
      compressible: true,
      extensions: [
        "hdd"
      ]
    },
    "application/x-virtualbox-ova": {
      compressible: true,
      extensions: [
        "ova"
      ]
    },
    "application/x-virtualbox-ovf": {
      compressible: true,
      extensions: [
        "ovf"
      ]
    },
    "application/x-virtualbox-vbox": {
      compressible: true,
      extensions: [
        "vbox"
      ]
    },
    "application/x-virtualbox-vbox-extpack": {
      compressible: false,
      extensions: [
        "vbox-extpack"
      ]
    },
    "application/x-virtualbox-vdi": {
      compressible: true,
      extensions: [
        "vdi"
      ]
    },
    "application/x-virtualbox-vhd": {
      compressible: true,
      extensions: [
        "vhd"
      ]
    },
    "application/x-virtualbox-vmdk": {
      compressible: true,
      extensions: [
        "vmdk"
      ]
    },
    "application/x-wais-source": {
      source: "apache",
      extensions: [
        "src"
      ]
    },
    "application/x-web-app-manifest+json": {
      compressible: true,
      extensions: [
        "webapp"
      ]
    },
    "application/x-www-form-urlencoded": {
      source: "iana",
      compressible: true
    },
    "application/x-x509-ca-cert": {
      source: "iana",
      extensions: [
        "der",
        "crt",
        "pem"
      ]
    },
    "application/x-x509-ca-ra-cert": {
      source: "iana"
    },
    "application/x-x509-next-ca-cert": {
      source: "iana"
    },
    "application/x-xfig": {
      source: "apache",
      extensions: [
        "fig"
      ]
    },
    "application/x-xliff+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "xlf"
      ]
    },
    "application/x-xpinstall": {
      source: "apache",
      compressible: false,
      extensions: [
        "xpi"
      ]
    },
    "application/x-xz": {
      source: "apache",
      extensions: [
        "xz"
      ]
    },
    "application/x-zmachine": {
      source: "apache",
      extensions: [
        "z1",
        "z2",
        "z3",
        "z4",
        "z5",
        "z6",
        "z7",
        "z8"
      ]
    },
    "application/x400-bp": {
      source: "iana"
    },
    "application/xacml+xml": {
      source: "iana",
      compressible: true
    },
    "application/xaml+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "xaml"
      ]
    },
    "application/xcap-att+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xav"
      ]
    },
    "application/xcap-caps+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xca"
      ]
    },
    "application/xcap-diff+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xdf"
      ]
    },
    "application/xcap-el+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xel"
      ]
    },
    "application/xcap-error+xml": {
      source: "iana",
      compressible: true
    },
    "application/xcap-ns+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xns"
      ]
    },
    "application/xcon-conference-info+xml": {
      source: "iana",
      compressible: true
    },
    "application/xcon-conference-info-diff+xml": {
      source: "iana",
      compressible: true
    },
    "application/xenc+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xenc"
      ]
    },
    "application/xhtml+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xhtml",
        "xht"
      ]
    },
    "application/xhtml-voice+xml": {
      source: "apache",
      compressible: true
    },
    "application/xliff+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xlf"
      ]
    },
    "application/xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xml",
        "xsl",
        "xsd",
        "rng"
      ]
    },
    "application/xml-dtd": {
      source: "iana",
      compressible: true,
      extensions: [
        "dtd"
      ]
    },
    "application/xml-external-parsed-entity": {
      source: "iana"
    },
    "application/xml-patch+xml": {
      source: "iana",
      compressible: true
    },
    "application/xmpp+xml": {
      source: "iana",
      compressible: true
    },
    "application/xop+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xop"
      ]
    },
    "application/xproc+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "xpl"
      ]
    },
    "application/xslt+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xsl",
        "xslt"
      ]
    },
    "application/xspf+xml": {
      source: "apache",
      compressible: true,
      extensions: [
        "xspf"
      ]
    },
    "application/xv+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "mxml",
        "xhvml",
        "xvml",
        "xvm"
      ]
    },
    "application/yang": {
      source: "iana",
      extensions: [
        "yang"
      ]
    },
    "application/yang-data+json": {
      source: "iana",
      compressible: true
    },
    "application/yang-data+xml": {
      source: "iana",
      compressible: true
    },
    "application/yang-patch+json": {
      source: "iana",
      compressible: true
    },
    "application/yang-patch+xml": {
      source: "iana",
      compressible: true
    },
    "application/yin+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "yin"
      ]
    },
    "application/zip": {
      source: "iana",
      compressible: false,
      extensions: [
        "zip"
      ]
    },
    "application/zlib": {
      source: "iana"
    },
    "application/zstd": {
      source: "iana"
    },
    "audio/1d-interleaved-parityfec": {
      source: "iana"
    },
    "audio/32kadpcm": {
      source: "iana"
    },
    "audio/3gpp": {
      source: "iana",
      compressible: false,
      extensions: [
        "3gpp"
      ]
    },
    "audio/3gpp2": {
      source: "iana"
    },
    "audio/aac": {
      source: "iana"
    },
    "audio/ac3": {
      source: "iana"
    },
    "audio/adpcm": {
      source: "apache",
      extensions: [
        "adp"
      ]
    },
    "audio/amr": {
      source: "iana",
      extensions: [
        "amr"
      ]
    },
    "audio/amr-wb": {
      source: "iana"
    },
    "audio/amr-wb+": {
      source: "iana"
    },
    "audio/aptx": {
      source: "iana"
    },
    "audio/asc": {
      source: "iana"
    },
    "audio/atrac-advanced-lossless": {
      source: "iana"
    },
    "audio/atrac-x": {
      source: "iana"
    },
    "audio/atrac3": {
      source: "iana"
    },
    "audio/basic": {
      source: "iana",
      compressible: false,
      extensions: [
        "au",
        "snd"
      ]
    },
    "audio/bv16": {
      source: "iana"
    },
    "audio/bv32": {
      source: "iana"
    },
    "audio/clearmode": {
      source: "iana"
    },
    "audio/cn": {
      source: "iana"
    },
    "audio/dat12": {
      source: "iana"
    },
    "audio/dls": {
      source: "iana"
    },
    "audio/dsr-es201108": {
      source: "iana"
    },
    "audio/dsr-es202050": {
      source: "iana"
    },
    "audio/dsr-es202211": {
      source: "iana"
    },
    "audio/dsr-es202212": {
      source: "iana"
    },
    "audio/dv": {
      source: "iana"
    },
    "audio/dvi4": {
      source: "iana"
    },
    "audio/eac3": {
      source: "iana"
    },
    "audio/encaprtp": {
      source: "iana"
    },
    "audio/evrc": {
      source: "iana"
    },
    "audio/evrc-qcp": {
      source: "iana"
    },
    "audio/evrc0": {
      source: "iana"
    },
    "audio/evrc1": {
      source: "iana"
    },
    "audio/evrcb": {
      source: "iana"
    },
    "audio/evrcb0": {
      source: "iana"
    },
    "audio/evrcb1": {
      source: "iana"
    },
    "audio/evrcnw": {
      source: "iana"
    },
    "audio/evrcnw0": {
      source: "iana"
    },
    "audio/evrcnw1": {
      source: "iana"
    },
    "audio/evrcwb": {
      source: "iana"
    },
    "audio/evrcwb0": {
      source: "iana"
    },
    "audio/evrcwb1": {
      source: "iana"
    },
    "audio/evs": {
      source: "iana"
    },
    "audio/flexfec": {
      source: "iana"
    },
    "audio/fwdred": {
      source: "iana"
    },
    "audio/g711-0": {
      source: "iana"
    },
    "audio/g719": {
      source: "iana"
    },
    "audio/g722": {
      source: "iana"
    },
    "audio/g7221": {
      source: "iana"
    },
    "audio/g723": {
      source: "iana"
    },
    "audio/g726-16": {
      source: "iana"
    },
    "audio/g726-24": {
      source: "iana"
    },
    "audio/g726-32": {
      source: "iana"
    },
    "audio/g726-40": {
      source: "iana"
    },
    "audio/g728": {
      source: "iana"
    },
    "audio/g729": {
      source: "iana"
    },
    "audio/g7291": {
      source: "iana"
    },
    "audio/g729d": {
      source: "iana"
    },
    "audio/g729e": {
      source: "iana"
    },
    "audio/gsm": {
      source: "iana"
    },
    "audio/gsm-efr": {
      source: "iana"
    },
    "audio/gsm-hr-08": {
      source: "iana"
    },
    "audio/ilbc": {
      source: "iana"
    },
    "audio/ip-mr_v2.5": {
      source: "iana"
    },
    "audio/isac": {
      source: "apache"
    },
    "audio/l16": {
      source: "iana"
    },
    "audio/l20": {
      source: "iana"
    },
    "audio/l24": {
      source: "iana",
      compressible: false
    },
    "audio/l8": {
      source: "iana"
    },
    "audio/lpc": {
      source: "iana"
    },
    "audio/melp": {
      source: "iana"
    },
    "audio/melp1200": {
      source: "iana"
    },
    "audio/melp2400": {
      source: "iana"
    },
    "audio/melp600": {
      source: "iana"
    },
    "audio/mhas": {
      source: "iana"
    },
    "audio/midi": {
      source: "apache",
      extensions: [
        "mid",
        "midi",
        "kar",
        "rmi"
      ]
    },
    "audio/mobile-xmf": {
      source: "iana",
      extensions: [
        "mxmf"
      ]
    },
    "audio/mp3": {
      compressible: false,
      extensions: [
        "mp3"
      ]
    },
    "audio/mp4": {
      source: "iana",
      compressible: false,
      extensions: [
        "m4a",
        "mp4a"
      ]
    },
    "audio/mp4a-latm": {
      source: "iana"
    },
    "audio/mpa": {
      source: "iana"
    },
    "audio/mpa-robust": {
      source: "iana"
    },
    "audio/mpeg": {
      source: "iana",
      compressible: false,
      extensions: [
        "mpga",
        "mp2",
        "mp2a",
        "mp3",
        "m2a",
        "m3a"
      ]
    },
    "audio/mpeg4-generic": {
      source: "iana"
    },
    "audio/musepack": {
      source: "apache"
    },
    "audio/ogg": {
      source: "iana",
      compressible: false,
      extensions: [
        "oga",
        "ogg",
        "spx",
        "opus"
      ]
    },
    "audio/opus": {
      source: "iana"
    },
    "audio/parityfec": {
      source: "iana"
    },
    "audio/pcma": {
      source: "iana"
    },
    "audio/pcma-wb": {
      source: "iana"
    },
    "audio/pcmu": {
      source: "iana"
    },
    "audio/pcmu-wb": {
      source: "iana"
    },
    "audio/prs.sid": {
      source: "iana"
    },
    "audio/qcelp": {
      source: "iana"
    },
    "audio/raptorfec": {
      source: "iana"
    },
    "audio/red": {
      source: "iana"
    },
    "audio/rtp-enc-aescm128": {
      source: "iana"
    },
    "audio/rtp-midi": {
      source: "iana"
    },
    "audio/rtploopback": {
      source: "iana"
    },
    "audio/rtx": {
      source: "iana"
    },
    "audio/s3m": {
      source: "apache",
      extensions: [
        "s3m"
      ]
    },
    "audio/scip": {
      source: "iana"
    },
    "audio/silk": {
      source: "apache",
      extensions: [
        "sil"
      ]
    },
    "audio/smv": {
      source: "iana"
    },
    "audio/smv-qcp": {
      source: "iana"
    },
    "audio/smv0": {
      source: "iana"
    },
    "audio/sofa": {
      source: "iana"
    },
    "audio/sp-midi": {
      source: "iana"
    },
    "audio/speex": {
      source: "iana"
    },
    "audio/t140c": {
      source: "iana"
    },
    "audio/t38": {
      source: "iana"
    },
    "audio/telephone-event": {
      source: "iana"
    },
    "audio/tetra_acelp": {
      source: "iana"
    },
    "audio/tetra_acelp_bb": {
      source: "iana"
    },
    "audio/tone": {
      source: "iana"
    },
    "audio/tsvcis": {
      source: "iana"
    },
    "audio/uemclip": {
      source: "iana"
    },
    "audio/ulpfec": {
      source: "iana"
    },
    "audio/usac": {
      source: "iana"
    },
    "audio/vdvi": {
      source: "iana"
    },
    "audio/vmr-wb": {
      source: "iana"
    },
    "audio/vnd.3gpp.iufp": {
      source: "iana"
    },
    "audio/vnd.4sb": {
      source: "iana"
    },
    "audio/vnd.audiokoz": {
      source: "iana"
    },
    "audio/vnd.celp": {
      source: "iana"
    },
    "audio/vnd.cisco.nse": {
      source: "iana"
    },
    "audio/vnd.cmles.radio-events": {
      source: "iana"
    },
    "audio/vnd.cns.anp1": {
      source: "iana"
    },
    "audio/vnd.cns.inf1": {
      source: "iana"
    },
    "audio/vnd.dece.audio": {
      source: "iana",
      extensions: [
        "uva",
        "uvva"
      ]
    },
    "audio/vnd.digital-winds": {
      source: "iana",
      extensions: [
        "eol"
      ]
    },
    "audio/vnd.dlna.adts": {
      source: "iana"
    },
    "audio/vnd.dolby.heaac.1": {
      source: "iana"
    },
    "audio/vnd.dolby.heaac.2": {
      source: "iana"
    },
    "audio/vnd.dolby.mlp": {
      source: "iana"
    },
    "audio/vnd.dolby.mps": {
      source: "iana"
    },
    "audio/vnd.dolby.pl2": {
      source: "iana"
    },
    "audio/vnd.dolby.pl2x": {
      source: "iana"
    },
    "audio/vnd.dolby.pl2z": {
      source: "iana"
    },
    "audio/vnd.dolby.pulse.1": {
      source: "iana"
    },
    "audio/vnd.dra": {
      source: "iana",
      extensions: [
        "dra"
      ]
    },
    "audio/vnd.dts": {
      source: "iana",
      extensions: [
        "dts"
      ]
    },
    "audio/vnd.dts.hd": {
      source: "iana",
      extensions: [
        "dtshd"
      ]
    },
    "audio/vnd.dts.uhd": {
      source: "iana"
    },
    "audio/vnd.dvb.file": {
      source: "iana"
    },
    "audio/vnd.everad.plj": {
      source: "iana"
    },
    "audio/vnd.hns.audio": {
      source: "iana"
    },
    "audio/vnd.lucent.voice": {
      source: "iana",
      extensions: [
        "lvp"
      ]
    },
    "audio/vnd.ms-playready.media.pya": {
      source: "iana",
      extensions: [
        "pya"
      ]
    },
    "audio/vnd.nokia.mobile-xmf": {
      source: "iana"
    },
    "audio/vnd.nortel.vbk": {
      source: "iana"
    },
    "audio/vnd.nuera.ecelp4800": {
      source: "iana",
      extensions: [
        "ecelp4800"
      ]
    },
    "audio/vnd.nuera.ecelp7470": {
      source: "iana",
      extensions: [
        "ecelp7470"
      ]
    },
    "audio/vnd.nuera.ecelp9600": {
      source: "iana",
      extensions: [
        "ecelp9600"
      ]
    },
    "audio/vnd.octel.sbc": {
      source: "iana"
    },
    "audio/vnd.presonus.multitrack": {
      source: "iana"
    },
    "audio/vnd.qcelp": {
      source: "iana"
    },
    "audio/vnd.rhetorex.32kadpcm": {
      source: "iana"
    },
    "audio/vnd.rip": {
      source: "iana",
      extensions: [
        "rip"
      ]
    },
    "audio/vnd.rn-realaudio": {
      compressible: false
    },
    "audio/vnd.sealedmedia.softseal.mpeg": {
      source: "iana"
    },
    "audio/vnd.vmx.cvsd": {
      source: "iana"
    },
    "audio/vnd.wave": {
      compressible: false
    },
    "audio/vorbis": {
      source: "iana",
      compressible: false
    },
    "audio/vorbis-config": {
      source: "iana"
    },
    "audio/wav": {
      compressible: false,
      extensions: [
        "wav"
      ]
    },
    "audio/wave": {
      compressible: false,
      extensions: [
        "wav"
      ]
    },
    "audio/webm": {
      source: "apache",
      compressible: false,
      extensions: [
        "weba"
      ]
    },
    "audio/x-aac": {
      source: "apache",
      compressible: false,
      extensions: [
        "aac"
      ]
    },
    "audio/x-aiff": {
      source: "apache",
      extensions: [
        "aif",
        "aiff",
        "aifc"
      ]
    },
    "audio/x-caf": {
      source: "apache",
      compressible: false,
      extensions: [
        "caf"
      ]
    },
    "audio/x-flac": {
      source: "apache",
      extensions: [
        "flac"
      ]
    },
    "audio/x-m4a": {
      source: "nginx",
      extensions: [
        "m4a"
      ]
    },
    "audio/x-matroska": {
      source: "apache",
      extensions: [
        "mka"
      ]
    },
    "audio/x-mpegurl": {
      source: "apache",
      extensions: [
        "m3u"
      ]
    },
    "audio/x-ms-wax": {
      source: "apache",
      extensions: [
        "wax"
      ]
    },
    "audio/x-ms-wma": {
      source: "apache",
      extensions: [
        "wma"
      ]
    },
    "audio/x-pn-realaudio": {
      source: "apache",
      extensions: [
        "ram",
        "ra"
      ]
    },
    "audio/x-pn-realaudio-plugin": {
      source: "apache",
      extensions: [
        "rmp"
      ]
    },
    "audio/x-realaudio": {
      source: "nginx",
      extensions: [
        "ra"
      ]
    },
    "audio/x-tta": {
      source: "apache"
    },
    "audio/x-wav": {
      source: "apache",
      extensions: [
        "wav"
      ]
    },
    "audio/xm": {
      source: "apache",
      extensions: [
        "xm"
      ]
    },
    "chemical/x-cdx": {
      source: "apache",
      extensions: [
        "cdx"
      ]
    },
    "chemical/x-cif": {
      source: "apache",
      extensions: [
        "cif"
      ]
    },
    "chemical/x-cmdf": {
      source: "apache",
      extensions: [
        "cmdf"
      ]
    },
    "chemical/x-cml": {
      source: "apache",
      extensions: [
        "cml"
      ]
    },
    "chemical/x-csml": {
      source: "apache",
      extensions: [
        "csml"
      ]
    },
    "chemical/x-pdb": {
      source: "apache"
    },
    "chemical/x-xyz": {
      source: "apache",
      extensions: [
        "xyz"
      ]
    },
    "font/collection": {
      source: "iana",
      extensions: [
        "ttc"
      ]
    },
    "font/otf": {
      source: "iana",
      compressible: true,
      extensions: [
        "otf"
      ]
    },
    "font/sfnt": {
      source: "iana"
    },
    "font/ttf": {
      source: "iana",
      compressible: true,
      extensions: [
        "ttf"
      ]
    },
    "font/woff": {
      source: "iana",
      extensions: [
        "woff"
      ]
    },
    "font/woff2": {
      source: "iana",
      extensions: [
        "woff2"
      ]
    },
    "image/aces": {
      source: "iana",
      extensions: [
        "exr"
      ]
    },
    "image/apng": {
      compressible: false,
      extensions: [
        "apng"
      ]
    },
    "image/avci": {
      source: "iana",
      extensions: [
        "avci"
      ]
    },
    "image/avcs": {
      source: "iana",
      extensions: [
        "avcs"
      ]
    },
    "image/avif": {
      source: "iana",
      compressible: false,
      extensions: [
        "avif"
      ]
    },
    "image/bmp": {
      source: "iana",
      compressible: true,
      extensions: [
        "bmp"
      ]
    },
    "image/cgm": {
      source: "iana",
      extensions: [
        "cgm"
      ]
    },
    "image/dicom-rle": {
      source: "iana",
      extensions: [
        "drle"
      ]
    },
    "image/emf": {
      source: "iana",
      extensions: [
        "emf"
      ]
    },
    "image/fits": {
      source: "iana",
      extensions: [
        "fits"
      ]
    },
    "image/g3fax": {
      source: "iana",
      extensions: [
        "g3"
      ]
    },
    "image/gif": {
      source: "iana",
      compressible: false,
      extensions: [
        "gif"
      ]
    },
    "image/heic": {
      source: "iana",
      extensions: [
        "heic"
      ]
    },
    "image/heic-sequence": {
      source: "iana",
      extensions: [
        "heics"
      ]
    },
    "image/heif": {
      source: "iana",
      extensions: [
        "heif"
      ]
    },
    "image/heif-sequence": {
      source: "iana",
      extensions: [
        "heifs"
      ]
    },
    "image/hej2k": {
      source: "iana",
      extensions: [
        "hej2"
      ]
    },
    "image/hsj2": {
      source: "iana",
      extensions: [
        "hsj2"
      ]
    },
    "image/ief": {
      source: "iana",
      extensions: [
        "ief"
      ]
    },
    "image/jls": {
      source: "iana",
      extensions: [
        "jls"
      ]
    },
    "image/jp2": {
      source: "iana",
      compressible: false,
      extensions: [
        "jp2",
        "jpg2"
      ]
    },
    "image/jpeg": {
      source: "iana",
      compressible: false,
      extensions: [
        "jpeg",
        "jpg",
        "jpe"
      ]
    },
    "image/jph": {
      source: "iana",
      extensions: [
        "jph"
      ]
    },
    "image/jphc": {
      source: "iana",
      extensions: [
        "jhc"
      ]
    },
    "image/jpm": {
      source: "iana",
      compressible: false,
      extensions: [
        "jpm"
      ]
    },
    "image/jpx": {
      source: "iana",
      compressible: false,
      extensions: [
        "jpx",
        "jpf"
      ]
    },
    "image/jxr": {
      source: "iana",
      extensions: [
        "jxr"
      ]
    },
    "image/jxra": {
      source: "iana",
      extensions: [
        "jxra"
      ]
    },
    "image/jxrs": {
      source: "iana",
      extensions: [
        "jxrs"
      ]
    },
    "image/jxs": {
      source: "iana",
      extensions: [
        "jxs"
      ]
    },
    "image/jxsc": {
      source: "iana",
      extensions: [
        "jxsc"
      ]
    },
    "image/jxsi": {
      source: "iana",
      extensions: [
        "jxsi"
      ]
    },
    "image/jxss": {
      source: "iana",
      extensions: [
        "jxss"
      ]
    },
    "image/ktx": {
      source: "iana",
      extensions: [
        "ktx"
      ]
    },
    "image/ktx2": {
      source: "iana",
      extensions: [
        "ktx2"
      ]
    },
    "image/naplps": {
      source: "iana"
    },
    "image/pjpeg": {
      compressible: false
    },
    "image/png": {
      source: "iana",
      compressible: false,
      extensions: [
        "png"
      ]
    },
    "image/prs.btif": {
      source: "iana",
      extensions: [
        "btif"
      ]
    },
    "image/prs.pti": {
      source: "iana",
      extensions: [
        "pti"
      ]
    },
    "image/pwg-raster": {
      source: "iana"
    },
    "image/sgi": {
      source: "apache",
      extensions: [
        "sgi"
      ]
    },
    "image/svg+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "svg",
        "svgz"
      ]
    },
    "image/t38": {
      source: "iana",
      extensions: [
        "t38"
      ]
    },
    "image/tiff": {
      source: "iana",
      compressible: false,
      extensions: [
        "tif",
        "tiff"
      ]
    },
    "image/tiff-fx": {
      source: "iana",
      extensions: [
        "tfx"
      ]
    },
    "image/vnd.adobe.photoshop": {
      source: "iana",
      compressible: true,
      extensions: [
        "psd"
      ]
    },
    "image/vnd.airzip.accelerator.azv": {
      source: "iana",
      extensions: [
        "azv"
      ]
    },
    "image/vnd.cns.inf2": {
      source: "iana"
    },
    "image/vnd.dece.graphic": {
      source: "iana",
      extensions: [
        "uvi",
        "uvvi",
        "uvg",
        "uvvg"
      ]
    },
    "image/vnd.djvu": {
      source: "iana",
      extensions: [
        "djvu",
        "djv"
      ]
    },
    "image/vnd.dvb.subtitle": {
      source: "iana",
      extensions: [
        "sub"
      ]
    },
    "image/vnd.dwg": {
      source: "iana",
      extensions: [
        "dwg"
      ]
    },
    "image/vnd.dxf": {
      source: "iana",
      extensions: [
        "dxf"
      ]
    },
    "image/vnd.fastbidsheet": {
      source: "iana",
      extensions: [
        "fbs"
      ]
    },
    "image/vnd.fpx": {
      source: "iana",
      extensions: [
        "fpx"
      ]
    },
    "image/vnd.fst": {
      source: "iana",
      extensions: [
        "fst"
      ]
    },
    "image/vnd.fujixerox.edmics-mmr": {
      source: "iana",
      extensions: [
        "mmr"
      ]
    },
    "image/vnd.fujixerox.edmics-rlc": {
      source: "iana",
      extensions: [
        "rlc"
      ]
    },
    "image/vnd.globalgraphics.pgb": {
      source: "iana"
    },
    "image/vnd.microsoft.icon": {
      source: "iana",
      compressible: true,
      extensions: [
        "ico"
      ]
    },
    "image/vnd.mix": {
      source: "iana"
    },
    "image/vnd.mozilla.apng": {
      source: "iana"
    },
    "image/vnd.ms-dds": {
      compressible: true,
      extensions: [
        "dds"
      ]
    },
    "image/vnd.ms-modi": {
      source: "iana",
      extensions: [
        "mdi"
      ]
    },
    "image/vnd.ms-photo": {
      source: "apache",
      extensions: [
        "wdp"
      ]
    },
    "image/vnd.net-fpx": {
      source: "iana",
      extensions: [
        "npx"
      ]
    },
    "image/vnd.pco.b16": {
      source: "iana",
      extensions: [
        "b16"
      ]
    },
    "image/vnd.radiance": {
      source: "iana"
    },
    "image/vnd.sealed.png": {
      source: "iana"
    },
    "image/vnd.sealedmedia.softseal.gif": {
      source: "iana"
    },
    "image/vnd.sealedmedia.softseal.jpg": {
      source: "iana"
    },
    "image/vnd.svf": {
      source: "iana"
    },
    "image/vnd.tencent.tap": {
      source: "iana",
      extensions: [
        "tap"
      ]
    },
    "image/vnd.valve.source.texture": {
      source: "iana",
      extensions: [
        "vtf"
      ]
    },
    "image/vnd.wap.wbmp": {
      source: "iana",
      extensions: [
        "wbmp"
      ]
    },
    "image/vnd.xiff": {
      source: "iana",
      extensions: [
        "xif"
      ]
    },
    "image/vnd.zbrush.pcx": {
      source: "iana",
      extensions: [
        "pcx"
      ]
    },
    "image/webp": {
      source: "apache",
      extensions: [
        "webp"
      ]
    },
    "image/wmf": {
      source: "iana",
      extensions: [
        "wmf"
      ]
    },
    "image/x-3ds": {
      source: "apache",
      extensions: [
        "3ds"
      ]
    },
    "image/x-cmu-raster": {
      source: "apache",
      extensions: [
        "ras"
      ]
    },
    "image/x-cmx": {
      source: "apache",
      extensions: [
        "cmx"
      ]
    },
    "image/x-freehand": {
      source: "apache",
      extensions: [
        "fh",
        "fhc",
        "fh4",
        "fh5",
        "fh7"
      ]
    },
    "image/x-icon": {
      source: "apache",
      compressible: true,
      extensions: [
        "ico"
      ]
    },
    "image/x-jng": {
      source: "nginx",
      extensions: [
        "jng"
      ]
    },
    "image/x-mrsid-image": {
      source: "apache",
      extensions: [
        "sid"
      ]
    },
    "image/x-ms-bmp": {
      source: "nginx",
      compressible: true,
      extensions: [
        "bmp"
      ]
    },
    "image/x-pcx": {
      source: "apache",
      extensions: [
        "pcx"
      ]
    },
    "image/x-pict": {
      source: "apache",
      extensions: [
        "pic",
        "pct"
      ]
    },
    "image/x-portable-anymap": {
      source: "apache",
      extensions: [
        "pnm"
      ]
    },
    "image/x-portable-bitmap": {
      source: "apache",
      extensions: [
        "pbm"
      ]
    },
    "image/x-portable-graymap": {
      source: "apache",
      extensions: [
        "pgm"
      ]
    },
    "image/x-portable-pixmap": {
      source: "apache",
      extensions: [
        "ppm"
      ]
    },
    "image/x-rgb": {
      source: "apache",
      extensions: [
        "rgb"
      ]
    },
    "image/x-tga": {
      source: "apache",
      extensions: [
        "tga"
      ]
    },
    "image/x-xbitmap": {
      source: "apache",
      extensions: [
        "xbm"
      ]
    },
    "image/x-xcf": {
      compressible: false
    },
    "image/x-xpixmap": {
      source: "apache",
      extensions: [
        "xpm"
      ]
    },
    "image/x-xwindowdump": {
      source: "apache",
      extensions: [
        "xwd"
      ]
    },
    "message/cpim": {
      source: "iana"
    },
    "message/delivery-status": {
      source: "iana"
    },
    "message/disposition-notification": {
      source: "iana",
      extensions: [
        "disposition-notification"
      ]
    },
    "message/external-body": {
      source: "iana"
    },
    "message/feedback-report": {
      source: "iana"
    },
    "message/global": {
      source: "iana",
      extensions: [
        "u8msg"
      ]
    },
    "message/global-delivery-status": {
      source: "iana",
      extensions: [
        "u8dsn"
      ]
    },
    "message/global-disposition-notification": {
      source: "iana",
      extensions: [
        "u8mdn"
      ]
    },
    "message/global-headers": {
      source: "iana",
      extensions: [
        "u8hdr"
      ]
    },
    "message/http": {
      source: "iana",
      compressible: false
    },
    "message/imdn+xml": {
      source: "iana",
      compressible: true
    },
    "message/news": {
      source: "iana"
    },
    "message/partial": {
      source: "iana",
      compressible: false
    },
    "message/rfc822": {
      source: "iana",
      compressible: true,
      extensions: [
        "eml",
        "mime"
      ]
    },
    "message/s-http": {
      source: "iana"
    },
    "message/sip": {
      source: "iana"
    },
    "message/sipfrag": {
      source: "iana"
    },
    "message/tracking-status": {
      source: "iana"
    },
    "message/vnd.si.simp": {
      source: "iana"
    },
    "message/vnd.wfa.wsc": {
      source: "iana",
      extensions: [
        "wsc"
      ]
    },
    "model/3mf": {
      source: "iana",
      extensions: [
        "3mf"
      ]
    },
    "model/e57": {
      source: "iana"
    },
    "model/gltf+json": {
      source: "iana",
      compressible: true,
      extensions: [
        "gltf"
      ]
    },
    "model/gltf-binary": {
      source: "iana",
      compressible: true,
      extensions: [
        "glb"
      ]
    },
    "model/iges": {
      source: "iana",
      compressible: false,
      extensions: [
        "igs",
        "iges"
      ]
    },
    "model/mesh": {
      source: "iana",
      compressible: false,
      extensions: [
        "msh",
        "mesh",
        "silo"
      ]
    },
    "model/mtl": {
      source: "iana",
      extensions: [
        "mtl"
      ]
    },
    "model/obj": {
      source: "iana",
      extensions: [
        "obj"
      ]
    },
    "model/step": {
      source: "iana"
    },
    "model/step+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "stpx"
      ]
    },
    "model/step+zip": {
      source: "iana",
      compressible: false,
      extensions: [
        "stpz"
      ]
    },
    "model/step-xml+zip": {
      source: "iana",
      compressible: false,
      extensions: [
        "stpxz"
      ]
    },
    "model/stl": {
      source: "iana",
      extensions: [
        "stl"
      ]
    },
    "model/vnd.collada+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "dae"
      ]
    },
    "model/vnd.dwf": {
      source: "iana",
      extensions: [
        "dwf"
      ]
    },
    "model/vnd.flatland.3dml": {
      source: "iana"
    },
    "model/vnd.gdl": {
      source: "iana",
      extensions: [
        "gdl"
      ]
    },
    "model/vnd.gs-gdl": {
      source: "apache"
    },
    "model/vnd.gs.gdl": {
      source: "iana"
    },
    "model/vnd.gtw": {
      source: "iana",
      extensions: [
        "gtw"
      ]
    },
    "model/vnd.moml+xml": {
      source: "iana",
      compressible: true
    },
    "model/vnd.mts": {
      source: "iana",
      extensions: [
        "mts"
      ]
    },
    "model/vnd.opengex": {
      source: "iana",
      extensions: [
        "ogex"
      ]
    },
    "model/vnd.parasolid.transmit.binary": {
      source: "iana",
      extensions: [
        "x_b"
      ]
    },
    "model/vnd.parasolid.transmit.text": {
      source: "iana",
      extensions: [
        "x_t"
      ]
    },
    "model/vnd.pytha.pyox": {
      source: "iana"
    },
    "model/vnd.rosette.annotated-data-model": {
      source: "iana"
    },
    "model/vnd.sap.vds": {
      source: "iana",
      extensions: [
        "vds"
      ]
    },
    "model/vnd.usdz+zip": {
      source: "iana",
      compressible: false,
      extensions: [
        "usdz"
      ]
    },
    "model/vnd.valve.source.compiled-map": {
      source: "iana",
      extensions: [
        "bsp"
      ]
    },
    "model/vnd.vtu": {
      source: "iana",
      extensions: [
        "vtu"
      ]
    },
    "model/vrml": {
      source: "iana",
      compressible: false,
      extensions: [
        "wrl",
        "vrml"
      ]
    },
    "model/x3d+binary": {
      source: "apache",
      compressible: false,
      extensions: [
        "x3db",
        "x3dbz"
      ]
    },
    "model/x3d+fastinfoset": {
      source: "iana",
      extensions: [
        "x3db"
      ]
    },
    "model/x3d+vrml": {
      source: "apache",
      compressible: false,
      extensions: [
        "x3dv",
        "x3dvz"
      ]
    },
    "model/x3d+xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "x3d",
        "x3dz"
      ]
    },
    "model/x3d-vrml": {
      source: "iana",
      extensions: [
        "x3dv"
      ]
    },
    "multipart/alternative": {
      source: "iana",
      compressible: false
    },
    "multipart/appledouble": {
      source: "iana"
    },
    "multipart/byteranges": {
      source: "iana"
    },
    "multipart/digest": {
      source: "iana"
    },
    "multipart/encrypted": {
      source: "iana",
      compressible: false
    },
    "multipart/form-data": {
      source: "iana",
      compressible: false
    },
    "multipart/header-set": {
      source: "iana"
    },
    "multipart/mixed": {
      source: "iana"
    },
    "multipart/multilingual": {
      source: "iana"
    },
    "multipart/parallel": {
      source: "iana"
    },
    "multipart/related": {
      source: "iana",
      compressible: false
    },
    "multipart/report": {
      source: "iana"
    },
    "multipart/signed": {
      source: "iana",
      compressible: false
    },
    "multipart/vnd.bint.med-plus": {
      source: "iana"
    },
    "multipart/voice-message": {
      source: "iana"
    },
    "multipart/x-mixed-replace": {
      source: "iana"
    },
    "text/1d-interleaved-parityfec": {
      source: "iana"
    },
    "text/cache-manifest": {
      source: "iana",
      compressible: true,
      extensions: [
        "appcache",
        "manifest"
      ]
    },
    "text/calendar": {
      source: "iana",
      extensions: [
        "ics",
        "ifb"
      ]
    },
    "text/calender": {
      compressible: true
    },
    "text/cmd": {
      compressible: true
    },
    "text/coffeescript": {
      extensions: [
        "coffee",
        "litcoffee"
      ]
    },
    "text/cql": {
      source: "iana"
    },
    "text/cql-expression": {
      source: "iana"
    },
    "text/cql-identifier": {
      source: "iana"
    },
    "text/css": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "css"
      ]
    },
    "text/csv": {
      source: "iana",
      compressible: true,
      extensions: [
        "csv"
      ]
    },
    "text/csv-schema": {
      source: "iana"
    },
    "text/directory": {
      source: "iana"
    },
    "text/dns": {
      source: "iana"
    },
    "text/ecmascript": {
      source: "iana"
    },
    "text/encaprtp": {
      source: "iana"
    },
    "text/enriched": {
      source: "iana"
    },
    "text/fhirpath": {
      source: "iana"
    },
    "text/flexfec": {
      source: "iana"
    },
    "text/fwdred": {
      source: "iana"
    },
    "text/gff3": {
      source: "iana"
    },
    "text/grammar-ref-list": {
      source: "iana"
    },
    "text/html": {
      source: "iana",
      compressible: true,
      extensions: [
        "html",
        "htm",
        "shtml"
      ]
    },
    "text/jade": {
      extensions: [
        "jade"
      ]
    },
    "text/javascript": {
      source: "iana",
      compressible: true
    },
    "text/jcr-cnd": {
      source: "iana"
    },
    "text/jsx": {
      compressible: true,
      extensions: [
        "jsx"
      ]
    },
    "text/less": {
      compressible: true,
      extensions: [
        "less"
      ]
    },
    "text/markdown": {
      source: "iana",
      compressible: true,
      extensions: [
        "markdown",
        "md"
      ]
    },
    "text/mathml": {
      source: "nginx",
      extensions: [
        "mml"
      ]
    },
    "text/mdx": {
      compressible: true,
      extensions: [
        "mdx"
      ]
    },
    "text/mizar": {
      source: "iana"
    },
    "text/n3": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "n3"
      ]
    },
    "text/parameters": {
      source: "iana",
      charset: "UTF-8"
    },
    "text/parityfec": {
      source: "iana"
    },
    "text/plain": {
      source: "iana",
      compressible: true,
      extensions: [
        "txt",
        "text",
        "conf",
        "def",
        "list",
        "log",
        "in",
        "ini"
      ]
    },
    "text/provenance-notation": {
      source: "iana",
      charset: "UTF-8"
    },
    "text/prs.fallenstein.rst": {
      source: "iana"
    },
    "text/prs.lines.tag": {
      source: "iana",
      extensions: [
        "dsc"
      ]
    },
    "text/prs.prop.logic": {
      source: "iana"
    },
    "text/raptorfec": {
      source: "iana"
    },
    "text/red": {
      source: "iana"
    },
    "text/rfc822-headers": {
      source: "iana"
    },
    "text/richtext": {
      source: "iana",
      compressible: true,
      extensions: [
        "rtx"
      ]
    },
    "text/rtf": {
      source: "iana",
      compressible: true,
      extensions: [
        "rtf"
      ]
    },
    "text/rtp-enc-aescm128": {
      source: "iana"
    },
    "text/rtploopback": {
      source: "iana"
    },
    "text/rtx": {
      source: "iana"
    },
    "text/sgml": {
      source: "iana",
      extensions: [
        "sgml",
        "sgm"
      ]
    },
    "text/shaclc": {
      source: "iana"
    },
    "text/shex": {
      source: "iana",
      extensions: [
        "shex"
      ]
    },
    "text/slim": {
      extensions: [
        "slim",
        "slm"
      ]
    },
    "text/spdx": {
      source: "iana",
      extensions: [
        "spdx"
      ]
    },
    "text/strings": {
      source: "iana"
    },
    "text/stylus": {
      extensions: [
        "stylus",
        "styl"
      ]
    },
    "text/t140": {
      source: "iana"
    },
    "text/tab-separated-values": {
      source: "iana",
      compressible: true,
      extensions: [
        "tsv"
      ]
    },
    "text/troff": {
      source: "iana",
      extensions: [
        "t",
        "tr",
        "roff",
        "man",
        "me",
        "ms"
      ]
    },
    "text/turtle": {
      source: "iana",
      charset: "UTF-8",
      extensions: [
        "ttl"
      ]
    },
    "text/ulpfec": {
      source: "iana"
    },
    "text/uri-list": {
      source: "iana",
      compressible: true,
      extensions: [
        "uri",
        "uris",
        "urls"
      ]
    },
    "text/vcard": {
      source: "iana",
      compressible: true,
      extensions: [
        "vcard"
      ]
    },
    "text/vnd.a": {
      source: "iana"
    },
    "text/vnd.abc": {
      source: "iana"
    },
    "text/vnd.ascii-art": {
      source: "iana"
    },
    "text/vnd.curl": {
      source: "iana",
      extensions: [
        "curl"
      ]
    },
    "text/vnd.curl.dcurl": {
      source: "apache",
      extensions: [
        "dcurl"
      ]
    },
    "text/vnd.curl.mcurl": {
      source: "apache",
      extensions: [
        "mcurl"
      ]
    },
    "text/vnd.curl.scurl": {
      source: "apache",
      extensions: [
        "scurl"
      ]
    },
    "text/vnd.debian.copyright": {
      source: "iana",
      charset: "UTF-8"
    },
    "text/vnd.dmclientscript": {
      source: "iana"
    },
    "text/vnd.dvb.subtitle": {
      source: "iana",
      extensions: [
        "sub"
      ]
    },
    "text/vnd.esmertec.theme-descriptor": {
      source: "iana",
      charset: "UTF-8"
    },
    "text/vnd.familysearch.gedcom": {
      source: "iana",
      extensions: [
        "ged"
      ]
    },
    "text/vnd.ficlab.flt": {
      source: "iana"
    },
    "text/vnd.fly": {
      source: "iana",
      extensions: [
        "fly"
      ]
    },
    "text/vnd.fmi.flexstor": {
      source: "iana",
      extensions: [
        "flx"
      ]
    },
    "text/vnd.gml": {
      source: "iana"
    },
    "text/vnd.graphviz": {
      source: "iana",
      extensions: [
        "gv"
      ]
    },
    "text/vnd.hans": {
      source: "iana"
    },
    "text/vnd.hgl": {
      source: "iana"
    },
    "text/vnd.in3d.3dml": {
      source: "iana",
      extensions: [
        "3dml"
      ]
    },
    "text/vnd.in3d.spot": {
      source: "iana",
      extensions: [
        "spot"
      ]
    },
    "text/vnd.iptc.newsml": {
      source: "iana"
    },
    "text/vnd.iptc.nitf": {
      source: "iana"
    },
    "text/vnd.latex-z": {
      source: "iana"
    },
    "text/vnd.motorola.reflex": {
      source: "iana"
    },
    "text/vnd.ms-mediapackage": {
      source: "iana"
    },
    "text/vnd.net2phone.commcenter.command": {
      source: "iana"
    },
    "text/vnd.radisys.msml-basic-layout": {
      source: "iana"
    },
    "text/vnd.senx.warpscript": {
      source: "iana"
    },
    "text/vnd.si.uricatalogue": {
      source: "iana"
    },
    "text/vnd.sosi": {
      source: "iana"
    },
    "text/vnd.sun.j2me.app-descriptor": {
      source: "iana",
      charset: "UTF-8",
      extensions: [
        "jad"
      ]
    },
    "text/vnd.trolltech.linguist": {
      source: "iana",
      charset: "UTF-8"
    },
    "text/vnd.wap.si": {
      source: "iana"
    },
    "text/vnd.wap.sl": {
      source: "iana"
    },
    "text/vnd.wap.wml": {
      source: "iana",
      extensions: [
        "wml"
      ]
    },
    "text/vnd.wap.wmlscript": {
      source: "iana",
      extensions: [
        "wmls"
      ]
    },
    "text/vtt": {
      source: "iana",
      charset: "UTF-8",
      compressible: true,
      extensions: [
        "vtt"
      ]
    },
    "text/x-asm": {
      source: "apache",
      extensions: [
        "s",
        "asm"
      ]
    },
    "text/x-c": {
      source: "apache",
      extensions: [
        "c",
        "cc",
        "cxx",
        "cpp",
        "h",
        "hh",
        "dic"
      ]
    },
    "text/x-component": {
      source: "nginx",
      extensions: [
        "htc"
      ]
    },
    "text/x-fortran": {
      source: "apache",
      extensions: [
        "f",
        "for",
        "f77",
        "f90"
      ]
    },
    "text/x-gwt-rpc": {
      compressible: true
    },
    "text/x-handlebars-template": {
      extensions: [
        "hbs"
      ]
    },
    "text/x-java-source": {
      source: "apache",
      extensions: [
        "java"
      ]
    },
    "text/x-jquery-tmpl": {
      compressible: true
    },
    "text/x-lua": {
      extensions: [
        "lua"
      ]
    },
    "text/x-markdown": {
      compressible: true,
      extensions: [
        "mkd"
      ]
    },
    "text/x-nfo": {
      source: "apache",
      extensions: [
        "nfo"
      ]
    },
    "text/x-opml": {
      source: "apache",
      extensions: [
        "opml"
      ]
    },
    "text/x-org": {
      compressible: true,
      extensions: [
        "org"
      ]
    },
    "text/x-pascal": {
      source: "apache",
      extensions: [
        "p",
        "pas"
      ]
    },
    "text/x-processing": {
      compressible: true,
      extensions: [
        "pde"
      ]
    },
    "text/x-sass": {
      extensions: [
        "sass"
      ]
    },
    "text/x-scss": {
      extensions: [
        "scss"
      ]
    },
    "text/x-setext": {
      source: "apache",
      extensions: [
        "etx"
      ]
    },
    "text/x-sfv": {
      source: "apache",
      extensions: [
        "sfv"
      ]
    },
    "text/x-suse-ymp": {
      compressible: true,
      extensions: [
        "ymp"
      ]
    },
    "text/x-uuencode": {
      source: "apache",
      extensions: [
        "uu"
      ]
    },
    "text/x-vcalendar": {
      source: "apache",
      extensions: [
        "vcs"
      ]
    },
    "text/x-vcard": {
      source: "apache",
      extensions: [
        "vcf"
      ]
    },
    "text/xml": {
      source: "iana",
      compressible: true,
      extensions: [
        "xml"
      ]
    },
    "text/xml-external-parsed-entity": {
      source: "iana"
    },
    "text/yaml": {
      compressible: true,
      extensions: [
        "yaml",
        "yml"
      ]
    },
    "video/1d-interleaved-parityfec": {
      source: "iana"
    },
    "video/3gpp": {
      source: "iana",
      extensions: [
        "3gp",
        "3gpp"
      ]
    },
    "video/3gpp-tt": {
      source: "iana"
    },
    "video/3gpp2": {
      source: "iana",
      extensions: [
        "3g2"
      ]
    },
    "video/av1": {
      source: "iana"
    },
    "video/bmpeg": {
      source: "iana"
    },
    "video/bt656": {
      source: "iana"
    },
    "video/celb": {
      source: "iana"
    },
    "video/dv": {
      source: "iana"
    },
    "video/encaprtp": {
      source: "iana"
    },
    "video/ffv1": {
      source: "iana"
    },
    "video/flexfec": {
      source: "iana"
    },
    "video/h261": {
      source: "iana",
      extensions: [
        "h261"
      ]
    },
    "video/h263": {
      source: "iana",
      extensions: [
        "h263"
      ]
    },
    "video/h263-1998": {
      source: "iana"
    },
    "video/h263-2000": {
      source: "iana"
    },
    "video/h264": {
      source: "iana",
      extensions: [
        "h264"
      ]
    },
    "video/h264-rcdo": {
      source: "iana"
    },
    "video/h264-svc": {
      source: "iana"
    },
    "video/h265": {
      source: "iana"
    },
    "video/iso.segment": {
      source: "iana",
      extensions: [
        "m4s"
      ]
    },
    "video/jpeg": {
      source: "iana",
      extensions: [
        "jpgv"
      ]
    },
    "video/jpeg2000": {
      source: "iana"
    },
    "video/jpm": {
      source: "apache",
      extensions: [
        "jpm",
        "jpgm"
      ]
    },
    "video/jxsv": {
      source: "iana"
    },
    "video/mj2": {
      source: "iana",
      extensions: [
        "mj2",
        "mjp2"
      ]
    },
    "video/mp1s": {
      source: "iana"
    },
    "video/mp2p": {
      source: "iana"
    },
    "video/mp2t": {
      source: "iana",
      extensions: [
        "ts"
      ]
    },
    "video/mp4": {
      source: "iana",
      compressible: false,
      extensions: [
        "mp4",
        "mp4v",
        "mpg4"
      ]
    },
    "video/mp4v-es": {
      source: "iana"
    },
    "video/mpeg": {
      source: "iana",
      compressible: false,
      extensions: [
        "mpeg",
        "mpg",
        "mpe",
        "m1v",
        "m2v"
      ]
    },
    "video/mpeg4-generic": {
      source: "iana"
    },
    "video/mpv": {
      source: "iana"
    },
    "video/nv": {
      source: "iana"
    },
    "video/ogg": {
      source: "iana",
      compressible: false,
      extensions: [
        "ogv"
      ]
    },
    "video/parityfec": {
      source: "iana"
    },
    "video/pointer": {
      source: "iana"
    },
    "video/quicktime": {
      source: "iana",
      compressible: false,
      extensions: [
        "qt",
        "mov"
      ]
    },
    "video/raptorfec": {
      source: "iana"
    },
    "video/raw": {
      source: "iana"
    },
    "video/rtp-enc-aescm128": {
      source: "iana"
    },
    "video/rtploopback": {
      source: "iana"
    },
    "video/rtx": {
      source: "iana"
    },
    "video/scip": {
      source: "iana"
    },
    "video/smpte291": {
      source: "iana"
    },
    "video/smpte292m": {
      source: "iana"
    },
    "video/ulpfec": {
      source: "iana"
    },
    "video/vc1": {
      source: "iana"
    },
    "video/vc2": {
      source: "iana"
    },
    "video/vnd.cctv": {
      source: "iana"
    },
    "video/vnd.dece.hd": {
      source: "iana",
      extensions: [
        "uvh",
        "uvvh"
      ]
    },
    "video/vnd.dece.mobile": {
      source: "iana",
      extensions: [
        "uvm",
        "uvvm"
      ]
    },
    "video/vnd.dece.mp4": {
      source: "iana"
    },
    "video/vnd.dece.pd": {
      source: "iana",
      extensions: [
        "uvp",
        "uvvp"
      ]
    },
    "video/vnd.dece.sd": {
      source: "iana",
      extensions: [
        "uvs",
        "uvvs"
      ]
    },
    "video/vnd.dece.video": {
      source: "iana",
      extensions: [
        "uvv",
        "uvvv"
      ]
    },
    "video/vnd.directv.mpeg": {
      source: "iana"
    },
    "video/vnd.directv.mpeg-tts": {
      source: "iana"
    },
    "video/vnd.dlna.mpeg-tts": {
      source: "iana"
    },
    "video/vnd.dvb.file": {
      source: "iana",
      extensions: [
        "dvb"
      ]
    },
    "video/vnd.fvt": {
      source: "iana",
      extensions: [
        "fvt"
      ]
    },
    "video/vnd.hns.video": {
      source: "iana"
    },
    "video/vnd.iptvforum.1dparityfec-1010": {
      source: "iana"
    },
    "video/vnd.iptvforum.1dparityfec-2005": {
      source: "iana"
    },
    "video/vnd.iptvforum.2dparityfec-1010": {
      source: "iana"
    },
    "video/vnd.iptvforum.2dparityfec-2005": {
      source: "iana"
    },
    "video/vnd.iptvforum.ttsavc": {
      source: "iana"
    },
    "video/vnd.iptvforum.ttsmpeg2": {
      source: "iana"
    },
    "video/vnd.motorola.video": {
      source: "iana"
    },
    "video/vnd.motorola.videop": {
      source: "iana"
    },
    "video/vnd.mpegurl": {
      source: "iana",
      extensions: [
        "mxu",
        "m4u"
      ]
    },
    "video/vnd.ms-playready.media.pyv": {
      source: "iana",
      extensions: [
        "pyv"
      ]
    },
    "video/vnd.nokia.interleaved-multimedia": {
      source: "iana"
    },
    "video/vnd.nokia.mp4vr": {
      source: "iana"
    },
    "video/vnd.nokia.videovoip": {
      source: "iana"
    },
    "video/vnd.objectvideo": {
      source: "iana"
    },
    "video/vnd.radgamettools.bink": {
      source: "iana"
    },
    "video/vnd.radgamettools.smacker": {
      source: "iana"
    },
    "video/vnd.sealed.mpeg1": {
      source: "iana"
    },
    "video/vnd.sealed.mpeg4": {
      source: "iana"
    },
    "video/vnd.sealed.swf": {
      source: "iana"
    },
    "video/vnd.sealedmedia.softseal.mov": {
      source: "iana"
    },
    "video/vnd.uvvu.mp4": {
      source: "iana",
      extensions: [
        "uvu",
        "uvvu"
      ]
    },
    "video/vnd.vivo": {
      source: "iana",
      extensions: [
        "viv"
      ]
    },
    "video/vnd.youtube.yt": {
      source: "iana"
    },
    "video/vp8": {
      source: "iana"
    },
    "video/vp9": {
      source: "iana"
    },
    "video/webm": {
      source: "apache",
      compressible: false,
      extensions: [
        "webm"
      ]
    },
    "video/x-f4v": {
      source: "apache",
      extensions: [
        "f4v"
      ]
    },
    "video/x-fli": {
      source: "apache",
      extensions: [
        "fli"
      ]
    },
    "video/x-flv": {
      source: "apache",
      compressible: false,
      extensions: [
        "flv"
      ]
    },
    "video/x-m4v": {
      source: "apache",
      extensions: [
        "m4v"
      ]
    },
    "video/x-matroska": {
      source: "apache",
      compressible: false,
      extensions: [
        "mkv",
        "mk3d",
        "mks"
      ]
    },
    "video/x-mng": {
      source: "apache",
      extensions: [
        "mng"
      ]
    },
    "video/x-ms-asf": {
      source: "apache",
      extensions: [
        "asf",
        "asx"
      ]
    },
    "video/x-ms-vob": {
      source: "apache",
      extensions: [
        "vob"
      ]
    },
    "video/x-ms-wm": {
      source: "apache",
      extensions: [
        "wm"
      ]
    },
    "video/x-ms-wmv": {
      source: "apache",
      compressible: false,
      extensions: [
        "wmv"
      ]
    },
    "video/x-ms-wmx": {
      source: "apache",
      extensions: [
        "wmx"
      ]
    },
    "video/x-ms-wvx": {
      source: "apache",
      extensions: [
        "wvx"
      ]
    },
    "video/x-msvideo": {
      source: "apache",
      extensions: [
        "avi"
      ]
    },
    "video/x-sgi-movie": {
      source: "apache",
      extensions: [
        "movie"
      ]
    },
    "video/x-smv": {
      source: "apache",
      extensions: [
        "smv"
      ]
    },
    "x-conference/x-cooltalk": {
      source: "apache",
      extensions: [
        "ice"
      ]
    },
    "x-shader/x-fragment": {
      compressible: true
    },
    "x-shader/x-vertex": {
      compressible: true
    }
  };
  /*!
   * mime-db
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015-2022 Douglas Christopher Wilson
   * MIT Licensed
   */
  var mimeDb;
  var hasRequiredMimeDb;
  function requireMimeDb() {
    if (hasRequiredMimeDb)
      return mimeDb;
    hasRequiredMimeDb = 1;
    mimeDb = require$$0$1;
    return mimeDb;
  }
  /*!
   * mime-types
   * Copyright(c) 2014 Jonathan Ong
   * Copyright(c) 2015 Douglas Christopher Wilson
   * MIT Licensed
   */
  var hasRequiredMimeTypes;
  function requireMimeTypes() {
    if (hasRequiredMimeTypes)
      return mimeTypes;
    hasRequiredMimeTypes = 1;
    (function(exports) {
      var db = requireMimeDb();
      var extname = require$$0$2.extname;
      var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
      var TEXT_TYPE_REGEXP = /^text\//i;
      exports.charset = charset;
      exports.charsets = { lookup: charset };
      exports.contentType = contentType;
      exports.extension = extension;
      exports.extensions = /* @__PURE__ */ Object.create(null);
      exports.lookup = lookup;
      exports.types = /* @__PURE__ */ Object.create(null);
      populateMaps(exports.extensions, exports.types);
      function charset(type2) {
        if (!type2 || typeof type2 !== "string") {
          return false;
        }
        var match = EXTRACT_TYPE_REGEXP.exec(type2);
        var mime = match && db[match[1].toLowerCase()];
        if (mime && mime.charset) {
          return mime.charset;
        }
        if (match && TEXT_TYPE_REGEXP.test(match[1])) {
          return "UTF-8";
        }
        return false;
      }
      function contentType(str) {
        if (!str || typeof str !== "string") {
          return false;
        }
        var mime = str.indexOf("/") === -1 ? exports.lookup(str) : str;
        if (!mime) {
          return false;
        }
        if (mime.indexOf("charset") === -1) {
          var charset2 = exports.charset(mime);
          if (charset2)
            mime += "; charset=" + charset2.toLowerCase();
        }
        return mime;
      }
      function extension(type2) {
        if (!type2 || typeof type2 !== "string") {
          return false;
        }
        var match = EXTRACT_TYPE_REGEXP.exec(type2);
        var exts = match && exports.extensions[match[1].toLowerCase()];
        if (!exts || !exts.length) {
          return false;
        }
        return exts[0];
      }
      function lookup(path) {
        if (!path || typeof path !== "string") {
          return false;
        }
        var extension2 = extname("x." + path).toLowerCase().substr(1);
        if (!extension2) {
          return false;
        }
        return exports.types[extension2] || false;
      }
      function populateMaps(extensions, types2) {
        var preference = ["nginx", "apache", void 0, "iana"];
        Object.keys(db).forEach(function forEachMimeType(type2) {
          var mime = db[type2];
          var exts = mime.extensions;
          if (!exts || !exts.length) {
            return;
          }
          extensions[type2] = exts;
          for (var i2 = 0; i2 < exts.length; i2++) {
            var extension2 = exts[i2];
            if (types2[extension2]) {
              var from = preference.indexOf(db[types2[extension2]].source);
              var to = preference.indexOf(mime.source);
              if (types2[extension2] !== "application/octet-stream" && (from > to || from === to && types2[extension2].substr(0, 12) === "application/")) {
                continue;
              }
            }
            types2[extension2] = type2;
          }
        });
      }
    })(mimeTypes);
    return mimeTypes;
  }
  var caseless = { exports: {} };
  var hasRequiredCaseless;
  function requireCaseless() {
    if (hasRequiredCaseless)
      return caseless.exports;
    hasRequiredCaseless = 1;
    function Caseless(dict) {
      this.dict = dict || {};
    }
    Caseless.prototype.set = function(name, value, clobber) {
      if (typeof name === "object") {
        for (var i2 in name) {
          this.set(i2, name[i2], value);
        }
      } else {
        if (typeof clobber === "undefined")
          clobber = true;
        var has = this.has(name);
        if (!clobber && has)
          this.dict[has] = this.dict[has] + "," + value;
        else
          this.dict[has || name] = value;
        return has;
      }
    };
    Caseless.prototype.has = function(name) {
      var keys = Object.keys(this.dict), name = name.toLowerCase();
      for (var i2 = 0; i2 < keys.length; i2++) {
        if (keys[i2].toLowerCase() === name)
          return keys[i2];
      }
      return false;
    };
    Caseless.prototype.get = function(name) {
      name = name.toLowerCase();
      var result2, _key;
      var headers = this.dict;
      Object.keys(headers).forEach(function(key2) {
        _key = key2.toLowerCase();
        if (name === _key)
          result2 = headers[key2];
      });
      return result2;
    };
    Caseless.prototype.swap = function(name) {
      var has = this.has(name);
      if (has === name)
        return;
      if (!has)
        throw new Error('There is no header than matches "' + name + '"');
      this.dict[name] = this.dict[has];
      delete this.dict[has];
    };
    Caseless.prototype.del = function(name) {
      var has = this.has(name);
      return delete this.dict[has || name];
    };
    caseless.exports = function(dict) {
      return new Caseless(dict);
    };
    caseless.exports.httpify = function(resp, headers) {
      var c2 = new Caseless(headers);
      resp.setHeader = function(key2, value, clobber) {
        if (typeof value === "undefined")
          return;
        return c2.set(key2, value, clobber);
      };
      resp.hasHeader = function(key2) {
        return c2.has(key2);
      };
      resp.getHeader = function(key2) {
        return c2.get(key2);
      };
      resp.removeHeader = function(key2) {
        return c2.del(key2);
      };
      resp.headers = c2.dict;
      return c2;
    };
    return caseless.exports;
  }
  var foreverAgent;
  var hasRequiredForeverAgent;
  function requireForeverAgent() {
    if (hasRequiredForeverAgent)
      return foreverAgent;
    hasRequiredForeverAgent = 1;
    foreverAgent = ForeverAgent;
    ForeverAgent.SSL = ForeverAgentSSL;
    var util2 = require$$0$2, Agent = require$$0$2.Agent, net2 = require$$0$2, tls = require$$0$2, AgentSSL = require$$0$2.Agent;
    function getConnectionName(host, port) {
      var name = "";
      if (typeof host === "string") {
        name = host + ":" + port;
      } else {
        name = host.host + ":" + host.port + ":" + (host.localAddress ? host.localAddress + ":" : ":");
      }
      return name;
    }
    function ForeverAgent(options) {
      var self2 = this;
      self2.options = options || {};
      self2.requests = {};
      self2.sockets = {};
      self2.freeSockets = {};
      self2.maxSockets = self2.options.maxSockets || Agent.defaultMaxSockets;
      self2.minSockets = self2.options.minSockets || ForeverAgent.defaultMinSockets;
      self2.on("free", function(socket, host, port) {
        var name = getConnectionName(host, port);
        if (self2.requests[name] && self2.requests[name].length) {
          self2.requests[name].shift().onSocket(socket);
        } else if (self2.sockets[name].length < self2.minSockets) {
          if (!self2.freeSockets[name])
            self2.freeSockets[name] = [];
          self2.freeSockets[name].push(socket);
          var onIdleError = function() {
            socket.destroy();
          };
          socket._onIdleError = onIdleError;
          socket.on("error", onIdleError);
        } else {
          socket.destroy();
        }
      });
    }
    util2.inherits(ForeverAgent, Agent);
    ForeverAgent.defaultMinSockets = 5;
    ForeverAgent.prototype.createConnection = net2.createConnection;
    ForeverAgent.prototype.addRequestNoreuse = Agent.prototype.addRequest;
    ForeverAgent.prototype.addRequest = function(req, host, port) {
      var name = getConnectionName(host, port);
      if (typeof host !== "string") {
        var options = host;
        port = options.port;
        host = options.host;
      }
      if (this.freeSockets[name] && this.freeSockets[name].length > 0 && !req.useChunkedEncodingByDefault) {
        var idleSocket = this.freeSockets[name].pop();
        idleSocket.removeListener("error", idleSocket._onIdleError);
        delete idleSocket._onIdleError;
        req._reusedSocket = true;
        req.onSocket(idleSocket);
      } else {
        this.addRequestNoreuse(req, host, port);
      }
    };
    ForeverAgent.prototype.removeSocket = function(s, name, host, port) {
      if (this.sockets[name]) {
        var index = this.sockets[name].indexOf(s);
        if (index !== -1) {
          this.sockets[name].splice(index, 1);
        }
      } else if (this.sockets[name] && this.sockets[name].length === 0) {
        delete this.sockets[name];
        delete this.requests[name];
      }
      if (this.freeSockets[name]) {
        var index = this.freeSockets[name].indexOf(s);
        if (index !== -1) {
          this.freeSockets[name].splice(index, 1);
          if (this.freeSockets[name].length === 0) {
            delete this.freeSockets[name];
          }
        }
      }
      if (this.requests[name] && this.requests[name].length) {
        this.createSocket(name, host, port).emit("free");
      }
    };
    function ForeverAgentSSL(options) {
      ForeverAgent.call(this, options);
    }
    util2.inherits(ForeverAgentSSL, ForeverAgent);
    ForeverAgentSSL.prototype.createConnection = createConnectionSSL;
    ForeverAgentSSL.prototype.addRequestNoreuse = AgentSSL.prototype.addRequest;
    function createConnectionSSL(port, host, options) {
      if (typeof port === "object") {
        options = port;
      } else if (typeof host === "object") {
        options = host;
      } else if (typeof options === "object") {
        options = options;
      } else {
        options = {};
      }
      if (typeof port === "number") {
        options.port = port;
      }
      if (typeof host === "string") {
        options.host = host;
      }
      return tls.connect(options);
    }
    return foreverAgent;
  }
  var browser;
  var hasRequiredBrowser;
  function requireBrowser() {
    if (hasRequiredBrowser)
      return browser;
    hasRequiredBrowser = 1;
    browser = typeof self == "object" ? self.FormData : window.FormData;
    return browser;
  }
  var isstream = { exports: {} };
  var hasRequiredIsstream;
  function requireIsstream() {
    if (hasRequiredIsstream)
      return isstream.exports;
    hasRequiredIsstream = 1;
    var stream = require$$0$2;
    function isStream(obj) {
      return obj instanceof stream.Stream;
    }
    function isReadable(obj) {
      return isStream(obj) && typeof obj._read == "function" && typeof obj._readableState == "object";
    }
    function isWritable(obj) {
      return isStream(obj) && typeof obj._write == "function" && typeof obj._writableState == "object";
    }
    function isDuplex(obj) {
      return isReadable(obj) && isWritable(obj);
    }
    isstream.exports = isStream;
    isstream.exports.isReadable = isReadable;
    isstream.exports.isWritable = isWritable;
    isstream.exports.isDuplex = isDuplex;
    return isstream.exports;
  }
  var isTypedarray;
  var hasRequiredIsTypedarray;
  function requireIsTypedarray() {
    if (hasRequiredIsTypedarray)
      return isTypedarray;
    hasRequiredIsTypedarray = 1;
    isTypedarray = isTypedArray;
    isTypedArray.strict = isStrictTypedArray;
    isTypedArray.loose = isLooseTypedArray;
    var toString2 = Object.prototype.toString;
    var names = {
      "[object Int8Array]": true,
      "[object Int16Array]": true,
      "[object Int32Array]": true,
      "[object Uint8Array]": true,
      "[object Uint8ClampedArray]": true,
      "[object Uint16Array]": true,
      "[object Uint32Array]": true,
      "[object Float32Array]": true,
      "[object Float64Array]": true
    };
    function isTypedArray(arr) {
      return isStrictTypedArray(arr) || isLooseTypedArray(arr);
    }
    function isStrictTypedArray(arr) {
      return arr instanceof Int8Array || arr instanceof Int16Array || arr instanceof Int32Array || arr instanceof Uint8Array || arr instanceof Uint8ClampedArray || arr instanceof Uint16Array || arr instanceof Uint32Array || arr instanceof Float32Array || arr instanceof Float64Array;
    }
    function isLooseTypedArray(arr) {
      return names[toString2.call(arr)];
    }
    return isTypedarray;
  }
  var getProxyFromURI_1;
  var hasRequiredGetProxyFromURI;
  function requireGetProxyFromURI() {
    if (hasRequiredGetProxyFromURI)
      return getProxyFromURI_1;
    hasRequiredGetProxyFromURI = 1;
    function formatHostname(hostname) {
      return hostname.replace(/^\.*/, ".").toLowerCase();
    }
    function parseNoProxyZone(zone) {
      zone = zone.trim().toLowerCase();
      var zoneParts = zone.split(":", 2);
      var zoneHost = formatHostname(zoneParts[0]);
      var zonePort = zoneParts[1];
      var hasPort = zone.indexOf(":") > -1;
      return { hostname: zoneHost, port: zonePort, hasPort };
    }
    function uriInNoProxy(uri, noProxy) {
      var port = uri.port || (uri.protocol === "https:" ? "443" : "80");
      var hostname = formatHostname(uri.hostname);
      var noProxyList = noProxy.split(",");
      return noProxyList.map(parseNoProxyZone).some(function(noProxyZone) {
        var isMatchedAt = hostname.indexOf(noProxyZone.hostname);
        var hostnameMatched = isMatchedAt > -1 && isMatchedAt === hostname.length - noProxyZone.hostname.length;
        if (noProxyZone.hasPort) {
          return port === noProxyZone.port && hostnameMatched;
        }
        return hostnameMatched;
      });
    }
    function getProxyFromURI(uri) {
      var noProxy = {}.NO_PROXY || {}.no_proxy || "";
      if (noProxy === "*") {
        return null;
      }
      if (noProxy !== "" && uriInNoProxy(uri, noProxy)) {
        return null;
      }
      if (uri.protocol === "http:") {
        return {}.HTTP_PROXY || {}.http_proxy || null;
      }
      if (uri.protocol === "https:") {
        return {}.HTTPS_PROXY || {}.https_proxy || {}.HTTP_PROXY || {}.http_proxy || null;
      }
      return null;
    }
    getProxyFromURI_1 = getProxyFromURI;
    return getProxyFromURI_1;
  }
  var querystring = {};
  var utils;
  var hasRequiredUtils;
  function requireUtils() {
    if (hasRequiredUtils)
      return utils;
    hasRequiredUtils = 1;
    var has = Object.prototype.hasOwnProperty;
    var hexTable = function() {
      var array = [];
      for (var i2 = 0; i2 < 256; ++i2) {
        array.push("%" + ((i2 < 16 ? "0" : "") + i2.toString(16)).toUpperCase());
      }
      return array;
    }();
    var compactQueue = function compactQueue2(queue) {
      var obj;
      while (queue.length) {
        var item = queue.pop();
        obj = item.obj[item.prop];
        if (Array.isArray(obj)) {
          var compacted = [];
          for (var j2 = 0; j2 < obj.length; ++j2) {
            if (typeof obj[j2] !== "undefined") {
              compacted.push(obj[j2]);
            }
          }
          item.obj[item.prop] = compacted;
        }
      }
      return obj;
    };
    var arrayToObject = function arrayToObject2(source, options) {
      var obj = options && options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      for (var i2 = 0; i2 < source.length; ++i2) {
        if (typeof source[i2] !== "undefined") {
          obj[i2] = source[i2];
        }
      }
      return obj;
    };
    var merge = function merge2(target, source, options) {
      if (!source) {
        return target;
      }
      if (typeof source !== "object") {
        if (Array.isArray(target)) {
          target.push(source);
        } else if (target && typeof target === "object") {
          if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
            target[source] = true;
          }
        } else {
          return [target, source];
        }
        return target;
      }
      if (!target || typeof target !== "object") {
        return [target].concat(source);
      }
      var mergeTarget = target;
      if (Array.isArray(target) && !Array.isArray(source)) {
        mergeTarget = arrayToObject(target, options);
      }
      if (Array.isArray(target) && Array.isArray(source)) {
        source.forEach(function(item, i2) {
          if (has.call(target, i2)) {
            var targetItem = target[i2];
            if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
              target[i2] = merge2(targetItem, item, options);
            } else {
              target.push(item);
            }
          } else {
            target[i2] = item;
          }
        });
        return target;
      }
      return Object.keys(source).reduce(function(acc, key2) {
        var value = source[key2];
        if (has.call(acc, key2)) {
          acc[key2] = merge2(acc[key2], value, options);
        } else {
          acc[key2] = value;
        }
        return acc;
      }, mergeTarget);
    };
    var assign = function assignSingleSource(target, source) {
      return Object.keys(source).reduce(function(acc, key2) {
        acc[key2] = source[key2];
        return acc;
      }, target);
    };
    var decode2 = function(str) {
      try {
        return decodeURIComponent(str.replace(/\+/g, " "));
      } catch (e) {
        return str;
      }
    };
    var encode2 = function encode3(str) {
      if (str.length === 0) {
        return str;
      }
      var string = typeof str === "string" ? str : String(str);
      var out = "";
      for (var i2 = 0; i2 < string.length; ++i2) {
        var c2 = string.charCodeAt(i2);
        if (c2 === 45 || c2 === 46 || c2 === 95 || c2 === 126 || c2 >= 48 && c2 <= 57 || c2 >= 65 && c2 <= 90 || c2 >= 97 && c2 <= 122) {
          out += string.charAt(i2);
          continue;
        }
        if (c2 < 128) {
          out = out + hexTable[c2];
          continue;
        }
        if (c2 < 2048) {
          out = out + (hexTable[192 | c2 >> 6] + hexTable[128 | c2 & 63]);
          continue;
        }
        if (c2 < 55296 || c2 >= 57344) {
          out = out + (hexTable[224 | c2 >> 12] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63]);
          continue;
        }
        i2 += 1;
        c2 = 65536 + ((c2 & 1023) << 10 | string.charCodeAt(i2) & 1023);
        out += hexTable[240 | c2 >> 18] + hexTable[128 | c2 >> 12 & 63] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63];
      }
      return out;
    };
    var compact = function compact2(value) {
      var queue = [{ obj: { o: value }, prop: "o" }];
      var refs = [];
      for (var i2 = 0; i2 < queue.length; ++i2) {
        var item = queue[i2];
        var obj = item.obj[item.prop];
        var keys = Object.keys(obj);
        for (var j2 = 0; j2 < keys.length; ++j2) {
          var key2 = keys[j2];
          var val = obj[key2];
          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
            queue.push({ obj, prop: key2 });
            refs.push(val);
          }
        }
      }
      return compactQueue(queue);
    };
    var isRegExp = function isRegExp2(obj) {
      return Object.prototype.toString.call(obj) === "[object RegExp]";
    };
    var isBuffer = function isBuffer2(obj) {
      if (obj === null || typeof obj === "undefined") {
        return false;
      }
      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
    };
    utils = {
      arrayToObject,
      assign,
      compact,
      decode: decode2,
      encode: encode2,
      isBuffer,
      isRegExp,
      merge
    };
    return utils;
  }
  var formats;
  var hasRequiredFormats$1;
  function requireFormats$1() {
    if (hasRequiredFormats$1)
      return formats;
    hasRequiredFormats$1 = 1;
    var replace = String.prototype.replace;
    var percentTwenties = /%20/g;
    formats = {
      "default": "RFC3986",
      formatters: {
        RFC1738: function(value) {
          return replace.call(value, percentTwenties, "+");
        },
        RFC3986: function(value) {
          return String(value);
        }
      },
      RFC1738: "RFC1738",
      RFC3986: "RFC3986"
    };
    return formats;
  }
  var stringify_1;
  var hasRequiredStringify;
  function requireStringify() {
    if (hasRequiredStringify)
      return stringify_1;
    hasRequiredStringify = 1;
    var utils2 = requireUtils();
    var formats2 = requireFormats$1();
    var arrayPrefixGenerators = {
      brackets: function brackets(prefix) {
        return prefix + "[]";
      },
      indices: function indices(prefix, key2) {
        return prefix + "[" + key2 + "]";
      },
      repeat: function repeat(prefix) {
        return prefix;
      }
    };
    var isArray3 = Array.isArray;
    var push = Array.prototype.push;
    var pushToArray = function(arr, valueOrArray) {
      push.apply(arr, isArray3(valueOrArray) ? valueOrArray : [valueOrArray]);
    };
    var toISO = Date.prototype.toISOString;
    var defaults = {
      delimiter: "&",
      encode: true,
      encoder: utils2.encode,
      encodeValuesOnly: false,
      serializeDate: function serializeDate(date) {
        return toISO.call(date);
      },
      skipNulls: false,
      strictNullHandling: false
    };
    var stringify2 = function stringify3(object, prefix, generateArrayPrefix, strictNullHandling, skipNulls, encoder, filter, sort, allowDots, serializeDate, formatter, encodeValuesOnly) {
      var obj = object;
      if (typeof filter === "function") {
        obj = filter(prefix, obj);
      } else if (obj instanceof Date) {
        obj = serializeDate(obj);
      }
      if (obj === null) {
        if (strictNullHandling) {
          return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder) : prefix;
        }
        obj = "";
      }
      if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean" || utils2.isBuffer(obj)) {
        if (encoder) {
          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder);
          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults.encoder))];
        }
        return [formatter(prefix) + "=" + formatter(String(obj))];
      }
      var values = [];
      if (typeof obj === "undefined") {
        return values;
      }
      var objKeys;
      if (isArray3(filter)) {
        objKeys = filter;
      } else {
        var keys = Object.keys(obj);
        objKeys = sort ? keys.sort(sort) : keys;
      }
      for (var i2 = 0; i2 < objKeys.length; ++i2) {
        var key2 = objKeys[i2];
        if (skipNulls && obj[key2] === null) {
          continue;
        }
        if (isArray3(obj)) {
          pushToArray(values, stringify3(
            obj[key2],
            generateArrayPrefix(prefix, key2),
            generateArrayPrefix,
            strictNullHandling,
            skipNulls,
            encoder,
            filter,
            sort,
            allowDots,
            serializeDate,
            formatter,
            encodeValuesOnly
          ));
        } else {
          pushToArray(values, stringify3(
            obj[key2],
            prefix + (allowDots ? "." + key2 : "[" + key2 + "]"),
            generateArrayPrefix,
            strictNullHandling,
            skipNulls,
            encoder,
            filter,
            sort,
            allowDots,
            serializeDate,
            formatter,
            encodeValuesOnly
          ));
        }
      }
      return values;
    };
    stringify_1 = function(object, opts) {
      var obj = object;
      var options = opts ? utils2.assign({}, opts) : {};
      if (options.encoder !== null && typeof options.encoder !== "undefined" && typeof options.encoder !== "function") {
        throw new TypeError("Encoder has to be a function.");
      }
      var delimiter2 = typeof options.delimiter === "undefined" ? defaults.delimiter : options.delimiter;
      var strictNullHandling = typeof options.strictNullHandling === "boolean" ? options.strictNullHandling : defaults.strictNullHandling;
      var skipNulls = typeof options.skipNulls === "boolean" ? options.skipNulls : defaults.skipNulls;
      var encode2 = typeof options.encode === "boolean" ? options.encode : defaults.encode;
      var encoder = typeof options.encoder === "function" ? options.encoder : defaults.encoder;
      var sort = typeof options.sort === "function" ? options.sort : null;
      var allowDots = typeof options.allowDots === "undefined" ? false : options.allowDots;
      var serializeDate = typeof options.serializeDate === "function" ? options.serializeDate : defaults.serializeDate;
      var encodeValuesOnly = typeof options.encodeValuesOnly === "boolean" ? options.encodeValuesOnly : defaults.encodeValuesOnly;
      if (typeof options.format === "undefined") {
        options.format = formats2["default"];
      } else if (!Object.prototype.hasOwnProperty.call(formats2.formatters, options.format)) {
        throw new TypeError("Unknown format option provided.");
      }
      var formatter = formats2.formatters[options.format];
      var objKeys;
      var filter;
      if (typeof options.filter === "function") {
        filter = options.filter;
        obj = filter("", obj);
      } else if (isArray3(options.filter)) {
        filter = options.filter;
        objKeys = filter;
      }
      var keys = [];
      if (typeof obj !== "object" || obj === null) {
        return "";
      }
      var arrayFormat;
      if (options.arrayFormat in arrayPrefixGenerators) {
        arrayFormat = options.arrayFormat;
      } else if ("indices" in options) {
        arrayFormat = options.indices ? "indices" : "repeat";
      } else {
        arrayFormat = "indices";
      }
      var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
      if (!objKeys) {
        objKeys = Object.keys(obj);
      }
      if (sort) {
        objKeys.sort(sort);
      }
      for (var i2 = 0; i2 < objKeys.length; ++i2) {
        var key2 = objKeys[i2];
        if (skipNulls && obj[key2] === null) {
          continue;
        }
        pushToArray(keys, stringify2(
          obj[key2],
          key2,
          generateArrayPrefix,
          strictNullHandling,
          skipNulls,
          encode2 ? encoder : null,
          filter,
          sort,
          allowDots,
          serializeDate,
          formatter,
          encodeValuesOnly
        ));
      }
      var joined = keys.join(delimiter2);
      var prefix = options.addQueryPrefix === true ? "?" : "";
      return joined.length > 0 ? prefix + joined : "";
    };
    return stringify_1;
  }
  var parse;
  var hasRequiredParse;
  function requireParse() {
    if (hasRequiredParse)
      return parse;
    hasRequiredParse = 1;
    var utils2 = requireUtils();
    var has = Object.prototype.hasOwnProperty;
    var defaults = {
      allowDots: false,
      allowPrototypes: false,
      arrayLimit: 20,
      decoder: utils2.decode,
      delimiter: "&",
      depth: 5,
      parameterLimit: 1e3,
      plainObjects: false,
      strictNullHandling: false
    };
    var parseValues = function parseQueryStringValues(str, options) {
      var obj = {};
      var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
      var parts = cleanStr.split(options.delimiter, limit);
      for (var i2 = 0; i2 < parts.length; ++i2) {
        var part = parts[i2];
        var bracketEqualsPos = part.indexOf("]=");
        var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
        var key2, val;
        if (pos === -1) {
          key2 = options.decoder(part, defaults.decoder);
          val = options.strictNullHandling ? null : "";
        } else {
          key2 = options.decoder(part.slice(0, pos), defaults.decoder);
          val = options.decoder(part.slice(pos + 1), defaults.decoder);
        }
        if (has.call(obj, key2)) {
          obj[key2] = [].concat(obj[key2]).concat(val);
        } else {
          obj[key2] = val;
        }
      }
      return obj;
    };
    var parseObject = function(chain, val, options) {
      var leaf = val;
      for (var i2 = chain.length - 1; i2 >= 0; --i2) {
        var obj;
        var root = chain[i2];
        if (root === "[]" && options.parseArrays) {
          obj = [].concat(leaf);
        } else {
          obj = options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
          var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
          var index = parseInt(cleanRoot, 10);
          if (!options.parseArrays && cleanRoot === "") {
            obj = { 0: leaf };
          } else if (!isNaN(index) && root !== cleanRoot && String(index) === cleanRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) {
            obj = [];
            obj[index] = leaf;
          } else if (cleanRoot !== "__proto__") {
            obj[cleanRoot] = leaf;
          }
        }
        leaf = obj;
      }
      return leaf;
    };
    var parseKeys = function parseQueryStringKeys(givenKey, val, options) {
      if (!givenKey) {
        return;
      }
      var key2 = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
      var brackets = /(\[[^[\]]*])/;
      var child = /(\[[^[\]]*])/g;
      var segment = brackets.exec(key2);
      var parent = segment ? key2.slice(0, segment.index) : key2;
      var keys = [];
      if (parent) {
        if (!options.plainObjects && has.call(Object.prototype, parent)) {
          if (!options.allowPrototypes) {
            return;
          }
        }
        keys.push(parent);
      }
      var i2 = 0;
      while ((segment = child.exec(key2)) !== null && i2 < options.depth) {
        i2 += 1;
        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
          if (!options.allowPrototypes) {
            return;
          }
        }
        keys.push(segment[1]);
      }
      if (segment) {
        keys.push("[" + key2.slice(segment.index) + "]");
      }
      return parseObject(keys, val, options);
    };
    parse = function(str, opts) {
      var options = opts ? utils2.assign({}, opts) : {};
      if (options.decoder !== null && options.decoder !== void 0 && typeof options.decoder !== "function") {
        throw new TypeError("Decoder has to be a function.");
      }
      options.ignoreQueryPrefix = options.ignoreQueryPrefix === true;
      options.delimiter = typeof options.delimiter === "string" || utils2.isRegExp(options.delimiter) ? options.delimiter : defaults.delimiter;
      options.depth = typeof options.depth === "number" ? options.depth : defaults.depth;
      options.arrayLimit = typeof options.arrayLimit === "number" ? options.arrayLimit : defaults.arrayLimit;
      options.parseArrays = options.parseArrays !== false;
      options.decoder = typeof options.decoder === "function" ? options.decoder : defaults.decoder;
      options.allowDots = typeof options.allowDots === "boolean" ? options.allowDots : defaults.allowDots;
      options.plainObjects = typeof options.plainObjects === "boolean" ? options.plainObjects : defaults.plainObjects;
      options.allowPrototypes = typeof options.allowPrototypes === "boolean" ? options.allowPrototypes : defaults.allowPrototypes;
      options.parameterLimit = typeof options.parameterLimit === "number" ? options.parameterLimit : defaults.parameterLimit;
      options.strictNullHandling = typeof options.strictNullHandling === "boolean" ? options.strictNullHandling : defaults.strictNullHandling;
      if (str === "" || str === null || typeof str === "undefined") {
        return options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      }
      var tempObj = typeof str === "string" ? parseValues(str, options) : str;
      var obj = options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
      var keys = Object.keys(tempObj);
      for (var i2 = 0; i2 < keys.length; ++i2) {
        var key2 = keys[i2];
        var newObj = parseKeys(key2, tempObj[key2], options);
        obj = utils2.merge(obj, newObj, options);
      }
      return utils2.compact(obj);
    };
    return parse;
  }
  var lib$1;
  var hasRequiredLib$1;
  function requireLib$1() {
    if (hasRequiredLib$1)
      return lib$1;
    hasRequiredLib$1 = 1;
    var stringify2 = requireStringify();
    var parse2 = requireParse();
    var formats2 = requireFormats$1();
    lib$1 = {
      formats: formats2,
      parse: parse2,
      stringify: stringify2
    };
    return lib$1;
  }
  var hasRequiredQuerystring;
  function requireQuerystring() {
    if (hasRequiredQuerystring)
      return querystring;
    hasRequiredQuerystring = 1;
    var qs = requireLib$1();
    var querystring$1 = require$$0$2;
    function Querystring(request2) {
      this.request = request2;
      this.lib = null;
      this.useQuerystring = null;
      this.parseOptions = null;
      this.stringifyOptions = null;
    }
    Querystring.prototype.init = function(options) {
      if (this.lib) {
        return;
      }
      this.useQuerystring = options.useQuerystring;
      this.lib = this.useQuerystring ? querystring$1 : qs;
      this.parseOptions = options.qsParseOptions || {};
      this.stringifyOptions = options.qsStringifyOptions || {};
    };
    Querystring.prototype.stringify = function(obj) {
      return this.useQuerystring ? this.rfc3986(this.lib.stringify(
        obj,
        this.stringifyOptions.sep || null,
        this.stringifyOptions.eq || null,
        this.stringifyOptions
      )) : this.lib.stringify(obj, this.stringifyOptions);
    };
    Querystring.prototype.parse = function(str) {
      return this.useQuerystring ? this.lib.parse(
        str,
        this.parseOptions.sep || null,
        this.parseOptions.eq || null,
        this.parseOptions
      ) : this.lib.parse(str, this.parseOptions);
    };
    Querystring.prototype.rfc3986 = function(str) {
      return str.replace(/[!'()*]/g, function(c2) {
        return "%" + c2.charCodeAt(0).toString(16).toUpperCase();
      });
    };
    Querystring.prototype.unescape = querystring$1.unescape;
    querystring.Querystring = Querystring;
    return querystring;
  }
  var har = {};
  var promise = {};
  var uri_all = { exports: {} };
  /** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
  var hasRequiredUri_all;
  function requireUri_all() {
    if (hasRequiredUri_all)
      return uri_all.exports;
    hasRequiredUri_all = 1;
    (function(module, exports) {
      (function(global2, factory) {
        factory(exports);
      })(commonjsGlobal, function(exports2) {
        function merge() {
          for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
            sets[_key] = arguments[_key];
          }
          if (sets.length > 1) {
            sets[0] = sets[0].slice(0, -1);
            var xl = sets.length - 1;
            for (var x = 1; x < xl; ++x) {
              sets[x] = sets[x].slice(1, -1);
            }
            sets[xl] = sets[xl].slice(1);
            return sets.join("");
          } else {
            return sets[0];
          }
        }
        function subexp(str) {
          return "(?:" + str + ")";
        }
        function typeOf(o) {
          return o === void 0 ? "undefined" : o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase();
        }
        function toUpperCase(str) {
          return str.toUpperCase();
        }
        function toArray(obj) {
          return obj !== void 0 && obj !== null ? obj instanceof Array ? obj : typeof obj.length !== "number" || obj.split || obj.setInterval || obj.call ? [obj] : Array.prototype.slice.call(obj) : [];
        }
        function assign(target, source) {
          var obj = target;
          if (source) {
            for (var key2 in source) {
              obj[key2] = source[key2];
            }
          }
          return obj;
        }
        function buildExps(isIRI) {
          var ALPHA$$ = "[A-Za-z]", DIGIT$$ = "[0-9]", HEXDIG$$2 = merge(DIGIT$$, "[A-Fa-f]"), PCT_ENCODED$2 = subexp(subexp("%[EFef]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%" + HEXDIG$$2 + HEXDIG$$2)), GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", RESERVED$$ = merge(GEN_DELIMS$$, SUB_DELIMS$$), UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]", UNRESERVED$$2 = merge(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$);
          subexp(ALPHA$$ + merge(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*");
          subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]")) + "*");
          var DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$), IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$), H16$ = subexp(HEXDIG$$2 + "{1,4}"), LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$), IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$), IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$), IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"), IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")), ZONEID$ = subexp(subexp(UNRESERVED$$2 + "|" + PCT_ENCODED$2) + "+");
          subexp("[vV]" + HEXDIG$$2 + "+\\." + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]") + "+");
          subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$)) + "*");
          var PCHAR$ = subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@]"));
          subexp(subexp(PCT_ENCODED$2 + "|" + merge(UNRESERVED$$2, SUB_DELIMS$$, "[\\@]")) + "+");
          subexp(subexp(PCHAR$ + "|" + merge("[\\/\\?]", IPRIVATE$$)) + "*");
          return {
            NOT_SCHEME: new RegExp(merge("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
            NOT_USERINFO: new RegExp(merge("[^\\%\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
            NOT_HOST: new RegExp(merge("[^\\%\\[\\]\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
            NOT_PATH: new RegExp(merge("[^\\%\\/\\:\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
            NOT_PATH_NOSCHEME: new RegExp(merge("[^\\%\\/\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
            NOT_QUERY: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
            NOT_FRAGMENT: new RegExp(merge("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
            ESCAPE: new RegExp(merge("[^]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
            UNRESERVED: new RegExp(UNRESERVED$$2, "g"),
            OTHER_CHARS: new RegExp(merge("[^\\%]", UNRESERVED$$2, RESERVED$$), "g"),
            PCT_ENCODED: new RegExp(PCT_ENCODED$2, "g"),
            IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
            IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$")
            //RFC 6874, with relaxed parsing rules
          };
        }
        var URI_PROTOCOL = buildExps(false);
        var IRI_PROTOCOL = buildExps(true);
        var slicedToArray = function() {
          function sliceIterator(arr, i2) {
            var _arr = [];
            var _n = true;
            var _d = false;
            var _e = void 0;
            try {
              for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
                _arr.push(_s.value);
                if (i2 && _arr.length === i2)
                  break;
              }
            } catch (err) {
              _d = true;
              _e = err;
            } finally {
              try {
                if (!_n && _i["return"])
                  _i["return"]();
              } finally {
                if (_d)
                  throw _e;
              }
            }
            return _arr;
          }
          return function(arr, i2) {
            if (Array.isArray(arr)) {
              return arr;
            } else if (Symbol.iterator in Object(arr)) {
              return sliceIterator(arr, i2);
            } else {
              throw new TypeError("Invalid attempt to destructure non-iterable instance");
            }
          };
        }();
        var toConsumableArray = function(arr) {
          if (Array.isArray(arr)) {
            for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++)
              arr2[i2] = arr[i2];
            return arr2;
          } else {
            return Array.from(arr);
          }
        };
        var maxInt2 = 2147483647;
        var base2 = 36;
        var tMin2 = 1;
        var tMax2 = 26;
        var skew2 = 38;
        var damp2 = 700;
        var initialBias2 = 72;
        var initialN2 = 128;
        var delimiter2 = "-";
        var regexPunycode2 = /^xn--/;
        var regexNonASCII2 = /[^\0-\x7E]/;
        var regexSeparators2 = /[\x2E\u3002\uFF0E\uFF61]/g;
        var errors2 = {
          "overflow": "Overflow: input needs wider integers to process",
          "not-basic": "Illegal input >= 0x80 (not a basic code point)",
          "invalid-input": "Invalid input"
        };
        var baseMinusTMin2 = base2 - tMin2;
        var floor2 = Math.floor;
        var stringFromCharCode2 = String.fromCharCode;
        function error$12(type2) {
          throw new RangeError(errors2[type2]);
        }
        function map2(array, fn) {
          var result2 = [];
          var length = array.length;
          while (length--) {
            result2[length] = fn(array[length]);
          }
          return result2;
        }
        function mapDomain2(string, fn) {
          var parts = string.split("@");
          var result2 = "";
          if (parts.length > 1) {
            result2 = parts[0] + "@";
            string = parts[1];
          }
          string = string.replace(regexSeparators2, ".");
          var labels = string.split(".");
          var encoded = map2(labels, fn).join(".");
          return result2 + encoded;
        }
        function ucs2decode2(string) {
          var output = [];
          var counter = 0;
          var length = string.length;
          while (counter < length) {
            var value = string.charCodeAt(counter++);
            if (value >= 55296 && value <= 56319 && counter < length) {
              var extra = string.charCodeAt(counter++);
              if ((extra & 64512) == 56320) {
                output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
              } else {
                output.push(value);
                counter--;
              }
            } else {
              output.push(value);
            }
          }
          return output;
        }
        var ucs2encode2 = function ucs2encode3(array) {
          return String.fromCodePoint.apply(String, toConsumableArray(array));
        };
        var basicToDigit2 = function basicToDigit3(codePoint) {
          if (codePoint - 48 < 10) {
            return codePoint - 22;
          }
          if (codePoint - 65 < 26) {
            return codePoint - 65;
          }
          if (codePoint - 97 < 26) {
            return codePoint - 97;
          }
          return base2;
        };
        var digitToBasic2 = function digitToBasic3(digit2, flag) {
          return digit2 + 22 + 75 * (digit2 < 26) - ((flag != 0) << 5);
        };
        var adapt2 = function adapt3(delta, numPoints, firstTime) {
          var k = 0;
          delta = firstTime ? floor2(delta / damp2) : delta >> 1;
          delta += floor2(delta / numPoints);
          for (
            ;
            /* no initialization */
            delta > baseMinusTMin2 * tMax2 >> 1;
            k += base2
          ) {
            delta = floor2(delta / baseMinusTMin2);
          }
          return floor2(k + (baseMinusTMin2 + 1) * delta / (delta + skew2));
        };
        var decode2 = function decode3(input) {
          var output = [];
          var inputLength = input.length;
          var i2 = 0;
          var n = initialN2;
          var bias = initialBias2;
          var basic = input.lastIndexOf(delimiter2);
          if (basic < 0) {
            basic = 0;
          }
          for (var j2 = 0; j2 < basic; ++j2) {
            if (input.charCodeAt(j2) >= 128) {
              error$12("not-basic");
            }
            output.push(input.charCodeAt(j2));
          }
          for (var index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
            var oldi = i2;
            for (
              var w = 1, k = base2;
              ;
              /* no condition */
              k += base2
            ) {
              if (index >= inputLength) {
                error$12("invalid-input");
              }
              var digit2 = basicToDigit2(input.charCodeAt(index++));
              if (digit2 >= base2 || digit2 > floor2((maxInt2 - i2) / w)) {
                error$12("overflow");
              }
              i2 += digit2 * w;
              var t = k <= bias ? tMin2 : k >= bias + tMax2 ? tMax2 : k - bias;
              if (digit2 < t) {
                break;
              }
              var baseMinusT = base2 - t;
              if (w > floor2(maxInt2 / baseMinusT)) {
                error$12("overflow");
              }
              w *= baseMinusT;
            }
            var out = output.length + 1;
            bias = adapt2(i2 - oldi, out, oldi == 0);
            if (floor2(i2 / out) > maxInt2 - n) {
              error$12("overflow");
            }
            n += floor2(i2 / out);
            i2 %= out;
            output.splice(i2++, 0, n);
          }
          return String.fromCodePoint.apply(String, output);
        };
        var encode2 = function encode3(input) {
          var output = [];
          input = ucs2decode2(input);
          var inputLength = input.length;
          var n = initialN2;
          var delta = 0;
          var bias = initialBias2;
          var _iteratorNormalCompletion = true;
          var _didIteratorError = false;
          var _iteratorError = void 0;
          try {
            for (var _iterator = input[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              var _currentValue2 = _step.value;
              if (_currentValue2 < 128) {
                output.push(stringFromCharCode2(_currentValue2));
              }
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator.return) {
                _iterator.return();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
          var basicLength = output.length;
          var handledCPCount = basicLength;
          if (basicLength) {
            output.push(delimiter2);
          }
          while (handledCPCount < inputLength) {
            var m = maxInt2;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = void 0;
            try {
              for (var _iterator2 = input[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                var currentValue = _step2.value;
                if (currentValue >= n && currentValue < m) {
                  m = currentValue;
                }
              }
            } catch (err) {
              _didIteratorError2 = true;
              _iteratorError2 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                  _iterator2.return();
                }
              } finally {
                if (_didIteratorError2) {
                  throw _iteratorError2;
                }
              }
            }
            var handledCPCountPlusOne = handledCPCount + 1;
            if (m - n > floor2((maxInt2 - delta) / handledCPCountPlusOne)) {
              error$12("overflow");
            }
            delta += (m - n) * handledCPCountPlusOne;
            n = m;
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = void 0;
            try {
              for (var _iterator3 = input[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                var _currentValue = _step3.value;
                if (_currentValue < n && ++delta > maxInt2) {
                  error$12("overflow");
                }
                if (_currentValue == n) {
                  var q2 = delta;
                  for (
                    var k = base2;
                    ;
                    /* no condition */
                    k += base2
                  ) {
                    var t = k <= bias ? tMin2 : k >= bias + tMax2 ? tMax2 : k - bias;
                    if (q2 < t) {
                      break;
                    }
                    var qMinusT = q2 - t;
                    var baseMinusT = base2 - t;
                    output.push(stringFromCharCode2(digitToBasic2(t + qMinusT % baseMinusT, 0)));
                    q2 = floor2(qMinusT / baseMinusT);
                  }
                  output.push(stringFromCharCode2(digitToBasic2(q2, 0)));
                  bias = adapt2(delta, handledCPCountPlusOne, handledCPCount == basicLength);
                  delta = 0;
                  ++handledCPCount;
                }
              }
            } catch (err) {
              _didIteratorError3 = true;
              _iteratorError3 = err;
            } finally {
              try {
                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                  _iterator3.return();
                }
              } finally {
                if (_didIteratorError3) {
                  throw _iteratorError3;
                }
              }
            }
            ++delta;
            ++n;
          }
          return output.join("");
        };
        var toUnicode2 = function toUnicode3(input) {
          return mapDomain2(input, function(string) {
            return regexPunycode2.test(string) ? decode2(string.slice(4).toLowerCase()) : string;
          });
        };
        var toASCII2 = function toASCII3(input) {
          return mapDomain2(input, function(string) {
            return regexNonASCII2.test(string) ? "xn--" + encode2(string) : string;
          });
        };
        var punycode2 = {
          /**
           * A string representing the current Punycode.js version number.
           * @memberOf punycode
           * @type String
           */
          "version": "2.1.0",
          /**
           * An object of methods to convert from JavaScript's internal character
           * representation (UCS-2) to Unicode code points, and back.
           * @see <https://mathiasbynens.be/notes/javascript-encoding>
           * @memberOf punycode
           * @type Object
           */
          "ucs2": {
            "decode": ucs2decode2,
            "encode": ucs2encode2
          },
          "decode": decode2,
          "encode": encode2,
          "toASCII": toASCII2,
          "toUnicode": toUnicode2
        };
        var SCHEMES = {};
        function pctEncChar(chr) {
          var c2 = chr.charCodeAt(0);
          var e = void 0;
          if (c2 < 16)
            e = "%0" + c2.toString(16).toUpperCase();
          else if (c2 < 128)
            e = "%" + c2.toString(16).toUpperCase();
          else if (c2 < 2048)
            e = "%" + (c2 >> 6 | 192).toString(16).toUpperCase() + "%" + (c2 & 63 | 128).toString(16).toUpperCase();
          else
            e = "%" + (c2 >> 12 | 224).toString(16).toUpperCase() + "%" + (c2 >> 6 & 63 | 128).toString(16).toUpperCase() + "%" + (c2 & 63 | 128).toString(16).toUpperCase();
          return e;
        }
        function pctDecChars(str) {
          var newStr = "";
          var i2 = 0;
          var il = str.length;
          while (i2 < il) {
            var c2 = parseInt(str.substr(i2 + 1, 2), 16);
            if (c2 < 128) {
              newStr += String.fromCharCode(c2);
              i2 += 3;
            } else if (c2 >= 194 && c2 < 224) {
              if (il - i2 >= 6) {
                var c22 = parseInt(str.substr(i2 + 4, 2), 16);
                newStr += String.fromCharCode((c2 & 31) << 6 | c22 & 63);
              } else {
                newStr += str.substr(i2, 6);
              }
              i2 += 6;
            } else if (c2 >= 224) {
              if (il - i2 >= 9) {
                var _c = parseInt(str.substr(i2 + 4, 2), 16);
                var c3 = parseInt(str.substr(i2 + 7, 2), 16);
                newStr += String.fromCharCode((c2 & 15) << 12 | (_c & 63) << 6 | c3 & 63);
              } else {
                newStr += str.substr(i2, 9);
              }
              i2 += 9;
            } else {
              newStr += str.substr(i2, 3);
              i2 += 3;
            }
          }
          return newStr;
        }
        function _normalizeComponentEncoding(components, protocol) {
          function decodeUnreserved2(str) {
            var decStr = pctDecChars(str);
            return !decStr.match(protocol.UNRESERVED) ? str : decStr;
          }
          if (components.scheme)
            components.scheme = String(components.scheme).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_SCHEME, "");
          if (components.userinfo !== void 0)
            components.userinfo = String(components.userinfo).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_USERINFO, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
          if (components.host !== void 0)
            components.host = String(components.host).replace(protocol.PCT_ENCODED, decodeUnreserved2).toLowerCase().replace(protocol.NOT_HOST, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
          if (components.path !== void 0)
            components.path = String(components.path).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(components.scheme ? protocol.NOT_PATH : protocol.NOT_PATH_NOSCHEME, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
          if (components.query !== void 0)
            components.query = String(components.query).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_QUERY, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
          if (components.fragment !== void 0)
            components.fragment = String(components.fragment).replace(protocol.PCT_ENCODED, decodeUnreserved2).replace(protocol.NOT_FRAGMENT, pctEncChar).replace(protocol.PCT_ENCODED, toUpperCase);
          return components;
        }
        function _stripLeadingZeros(str) {
          return str.replace(/^0*(.*)/, "$1") || "0";
        }
        function _normalizeIPv4(host, protocol) {
          var matches = host.match(protocol.IPV4ADDRESS) || [];
          var _matches = slicedToArray(matches, 2), address = _matches[1];
          if (address) {
            return address.split(".").map(_stripLeadingZeros).join(".");
          } else {
            return host;
          }
        }
        function _normalizeIPv6(host, protocol) {
          var matches = host.match(protocol.IPV6ADDRESS) || [];
          var _matches2 = slicedToArray(matches, 3), address = _matches2[1], zone = _matches2[2];
          if (address) {
            var _address$toLowerCase$ = address.toLowerCase().split("::").reverse(), _address$toLowerCase$2 = slicedToArray(_address$toLowerCase$, 2), last = _address$toLowerCase$2[0], first = _address$toLowerCase$2[1];
            var firstFields = first ? first.split(":").map(_stripLeadingZeros) : [];
            var lastFields = last.split(":").map(_stripLeadingZeros);
            var isLastFieldIPv4Address = protocol.IPV4ADDRESS.test(lastFields[lastFields.length - 1]);
            var fieldCount = isLastFieldIPv4Address ? 7 : 8;
            var lastFieldsStart = lastFields.length - fieldCount;
            var fields = Array(fieldCount);
            for (var x = 0; x < fieldCount; ++x) {
              fields[x] = firstFields[x] || lastFields[lastFieldsStart + x] || "";
            }
            if (isLastFieldIPv4Address) {
              fields[fieldCount - 1] = _normalizeIPv4(fields[fieldCount - 1], protocol);
            }
            var allZeroFields = fields.reduce(function(acc, field, index) {
              if (!field || field === "0") {
                var lastLongest = acc[acc.length - 1];
                if (lastLongest && lastLongest.index + lastLongest.length === index) {
                  lastLongest.length++;
                } else {
                  acc.push({ index, length: 1 });
                }
              }
              return acc;
            }, []);
            var longestZeroFields = allZeroFields.sort(function(a2, b2) {
              return b2.length - a2.length;
            })[0];
            var newHost = void 0;
            if (longestZeroFields && longestZeroFields.length > 1) {
              var newFirst = fields.slice(0, longestZeroFields.index);
              var newLast = fields.slice(longestZeroFields.index + longestZeroFields.length);
              newHost = newFirst.join(":") + "::" + newLast.join(":");
            } else {
              newHost = fields.join(":");
            }
            if (zone) {
              newHost += "%" + zone;
            }
            return newHost;
          } else {
            return host;
          }
        }
        var URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?(\[[^\/?#\]]+\]|[^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#((?:.|\n|\r)*))?/i;
        var NO_MATCH_IS_UNDEFINED = "".match(/(){0}/)[1] === void 0;
        function parse2(uriString) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var components = {};
          var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
          if (options.reference === "suffix")
            uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString;
          var matches = uriString.match(URI_PARSE);
          if (matches) {
            if (NO_MATCH_IS_UNDEFINED) {
              components.scheme = matches[1];
              components.userinfo = matches[3];
              components.host = matches[4];
              components.port = parseInt(matches[5], 10);
              components.path = matches[6] || "";
              components.query = matches[7];
              components.fragment = matches[8];
              if (isNaN(components.port)) {
                components.port = matches[5];
              }
            } else {
              components.scheme = matches[1] || void 0;
              components.userinfo = uriString.indexOf("@") !== -1 ? matches[3] : void 0;
              components.host = uriString.indexOf("//") !== -1 ? matches[4] : void 0;
              components.port = parseInt(matches[5], 10);
              components.path = matches[6] || "";
              components.query = uriString.indexOf("?") !== -1 ? matches[7] : void 0;
              components.fragment = uriString.indexOf("#") !== -1 ? matches[8] : void 0;
              if (isNaN(components.port)) {
                components.port = uriString.match(/\/\/(?:.|\n)*\:(?:\/|\?|\#|$)/) ? matches[4] : void 0;
              }
            }
            if (components.host) {
              components.host = _normalizeIPv6(_normalizeIPv4(components.host, protocol), protocol);
            }
            if (components.scheme === void 0 && components.userinfo === void 0 && components.host === void 0 && components.port === void 0 && !components.path && components.query === void 0) {
              components.reference = "same-document";
            } else if (components.scheme === void 0) {
              components.reference = "relative";
            } else if (components.fragment === void 0) {
              components.reference = "absolute";
            } else {
              components.reference = "uri";
            }
            if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) {
              components.error = components.error || "URI is not a " + options.reference + " reference.";
            }
            var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
            if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
              if (components.host && (options.domainHost || schemeHandler && schemeHandler.domainHost)) {
                try {
                  components.host = punycode2.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
                } catch (e) {
                  components.error = components.error || "Host's domain name can not be converted to ASCII via punycode: " + e;
                }
              }
              _normalizeComponentEncoding(components, URI_PROTOCOL);
            } else {
              _normalizeComponentEncoding(components, protocol);
            }
            if (schemeHandler && schemeHandler.parse) {
              schemeHandler.parse(components, options);
            }
          } else {
            components.error = components.error || "URI can not be parsed.";
          }
          return components;
        }
        function _recomposeAuthority(components, options) {
          var protocol = options.iri !== false ? IRI_PROTOCOL : URI_PROTOCOL;
          var uriTokens = [];
          if (components.userinfo !== void 0) {
            uriTokens.push(components.userinfo);
            uriTokens.push("@");
          }
          if (components.host !== void 0) {
            uriTokens.push(_normalizeIPv6(_normalizeIPv4(String(components.host), protocol), protocol).replace(protocol.IPV6ADDRESS, function(_, $1, $2) {
              return "[" + $1 + ($2 ? "%25" + $2 : "") + "]";
            }));
          }
          if (typeof components.port === "number" || typeof components.port === "string") {
            uriTokens.push(":");
            uriTokens.push(String(components.port));
          }
          return uriTokens.length ? uriTokens.join("") : void 0;
        }
        var RDS1 = /^\.\.?\//;
        var RDS2 = /^\/\.(\/|$)/;
        var RDS3 = /^\/\.\.(\/|$)/;
        var RDS5 = /^\/?(?:.|\n)*?(?=\/|$)/;
        function removeDotSegments(input) {
          var output = [];
          while (input.length) {
            if (input.match(RDS1)) {
              input = input.replace(RDS1, "");
            } else if (input.match(RDS2)) {
              input = input.replace(RDS2, "/");
            } else if (input.match(RDS3)) {
              input = input.replace(RDS3, "/");
              output.pop();
            } else if (input === "." || input === "..") {
              input = "";
            } else {
              var im = input.match(RDS5);
              if (im) {
                var s = im[0];
                input = input.slice(s.length);
                output.push(s);
              } else {
                throw new Error("Unexpected dot segment condition");
              }
            }
          }
          return output.join("");
        }
        function serialize(components) {
          var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
          var protocol = options.iri ? IRI_PROTOCOL : URI_PROTOCOL;
          var uriTokens = [];
          var schemeHandler = SCHEMES[(options.scheme || components.scheme || "").toLowerCase()];
          if (schemeHandler && schemeHandler.serialize)
            schemeHandler.serialize(components, options);
          if (components.host) {
            if (protocol.IPV6ADDRESS.test(components.host))
              ;
            else if (options.domainHost || schemeHandler && schemeHandler.domainHost) {
              try {
                components.host = !options.iri ? punycode2.toASCII(components.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode2.toUnicode(components.host);
              } catch (e) {
                components.error = components.error || "Host's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
              }
            }
          }
          _normalizeComponentEncoding(components, protocol);
          if (options.reference !== "suffix" && components.scheme) {
            uriTokens.push(components.scheme);
            uriTokens.push(":");
          }
          var authority = _recomposeAuthority(components, options);
          if (authority !== void 0) {
            if (options.reference !== "suffix") {
              uriTokens.push("//");
            }
            uriTokens.push(authority);
            if (components.path && components.path.charAt(0) !== "/") {
              uriTokens.push("/");
            }
          }
          if (components.path !== void 0) {
            var s = components.path;
            if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
              s = removeDotSegments(s);
            }
            if (authority === void 0) {
              s = s.replace(/^\/\//, "/%2F");
            }
            uriTokens.push(s);
          }
          if (components.query !== void 0) {
            uriTokens.push("?");
            uriTokens.push(components.query);
          }
          if (components.fragment !== void 0) {
            uriTokens.push("#");
            uriTokens.push(components.fragment);
          }
          return uriTokens.join("");
        }
        function resolveComponents(base3, relative) {
          var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
          var skipNormalization = arguments[3];
          var target = {};
          if (!skipNormalization) {
            base3 = parse2(serialize(base3, options), options);
            relative = parse2(serialize(relative, options), options);
          }
          options = options || {};
          if (!options.tolerant && relative.scheme) {
            target.scheme = relative.scheme;
            target.userinfo = relative.userinfo;
            target.host = relative.host;
            target.port = relative.port;
            target.path = removeDotSegments(relative.path || "");
            target.query = relative.query;
          } else {
            if (relative.userinfo !== void 0 || relative.host !== void 0 || relative.port !== void 0) {
              target.userinfo = relative.userinfo;
              target.host = relative.host;
              target.port = relative.port;
              target.path = removeDotSegments(relative.path || "");
              target.query = relative.query;
            } else {
              if (!relative.path) {
                target.path = base3.path;
                if (relative.query !== void 0) {
                  target.query = relative.query;
                } else {
                  target.query = base3.query;
                }
              } else {
                if (relative.path.charAt(0) === "/") {
                  target.path = removeDotSegments(relative.path);
                } else {
                  if ((base3.userinfo !== void 0 || base3.host !== void 0 || base3.port !== void 0) && !base3.path) {
                    target.path = "/" + relative.path;
                  } else if (!base3.path) {
                    target.path = relative.path;
                  } else {
                    target.path = base3.path.slice(0, base3.path.lastIndexOf("/") + 1) + relative.path;
                  }
                  target.path = removeDotSegments(target.path);
                }
                target.query = relative.query;
              }
              target.userinfo = base3.userinfo;
              target.host = base3.host;
              target.port = base3.port;
            }
            target.scheme = base3.scheme;
          }
          target.fragment = relative.fragment;
          return target;
        }
        function resolve(baseURI, relativeURI, options) {
          var schemelessOptions = assign({ scheme: "null" }, options);
          return serialize(resolveComponents(parse2(baseURI, schemelessOptions), parse2(relativeURI, schemelessOptions), schemelessOptions, true), schemelessOptions);
        }
        function normalize(uri, options) {
          if (typeof uri === "string") {
            uri = serialize(parse2(uri, options), options);
          } else if (typeOf(uri) === "object") {
            uri = parse2(serialize(uri, options), options);
          }
          return uri;
        }
        function equal(uriA, uriB, options) {
          if (typeof uriA === "string") {
            uriA = serialize(parse2(uriA, options), options);
          } else if (typeOf(uriA) === "object") {
            uriA = serialize(uriA, options);
          }
          if (typeof uriB === "string") {
            uriB = serialize(parse2(uriB, options), options);
          } else if (typeOf(uriB) === "object") {
            uriB = serialize(uriB, options);
          }
          return uriA === uriB;
        }
        function escapeComponent(str, options) {
          return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.ESCAPE : IRI_PROTOCOL.ESCAPE, pctEncChar);
        }
        function unescapeComponent(str, options) {
          return str && str.toString().replace(!options || !options.iri ? URI_PROTOCOL.PCT_ENCODED : IRI_PROTOCOL.PCT_ENCODED, pctDecChars);
        }
        var handler = {
          scheme: "http",
          domainHost: true,
          parse: function parse3(components, options) {
            if (!components.host) {
              components.error = components.error || "HTTP URIs must have a host.";
            }
            return components;
          },
          serialize: function serialize2(components, options) {
            var secure = String(components.scheme).toLowerCase() === "https";
            if (components.port === (secure ? 443 : 80) || components.port === "") {
              components.port = void 0;
            }
            if (!components.path) {
              components.path = "/";
            }
            return components;
          }
        };
        var handler$1 = {
          scheme: "https",
          domainHost: handler.domainHost,
          parse: handler.parse,
          serialize: handler.serialize
        };
        function isSecure(wsComponents) {
          return typeof wsComponents.secure === "boolean" ? wsComponents.secure : String(wsComponents.scheme).toLowerCase() === "wss";
        }
        var handler$2 = {
          scheme: "ws",
          domainHost: true,
          parse: function parse3(components, options) {
            var wsComponents = components;
            wsComponents.secure = isSecure(wsComponents);
            wsComponents.resourceName = (wsComponents.path || "/") + (wsComponents.query ? "?" + wsComponents.query : "");
            wsComponents.path = void 0;
            wsComponents.query = void 0;
            return wsComponents;
          },
          serialize: function serialize2(wsComponents, options) {
            if (wsComponents.port === (isSecure(wsComponents) ? 443 : 80) || wsComponents.port === "") {
              wsComponents.port = void 0;
            }
            if (typeof wsComponents.secure === "boolean") {
              wsComponents.scheme = wsComponents.secure ? "wss" : "ws";
              wsComponents.secure = void 0;
            }
            if (wsComponents.resourceName) {
              var _wsComponents$resourc = wsComponents.resourceName.split("?"), _wsComponents$resourc2 = slicedToArray(_wsComponents$resourc, 2), path = _wsComponents$resourc2[0], query = _wsComponents$resourc2[1];
              wsComponents.path = path && path !== "/" ? path : void 0;
              wsComponents.query = query;
              wsComponents.resourceName = void 0;
            }
            wsComponents.fragment = void 0;
            return wsComponents;
          }
        };
        var handler$3 = {
          scheme: "wss",
          domainHost: handler$2.domainHost,
          parse: handler$2.parse,
          serialize: handler$2.serialize
        };
        var O = {};
        var UNRESERVED$$ = "[A-Za-z0-9\\-\\.\\_\\~\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]";
        var HEXDIG$$ = "[0-9A-Fa-f]";
        var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$));
        var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]";
        var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]";
        var VCHAR$$ = merge(QTEXT$$, '[\\"\\\\]');
        var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]";
        var UNRESERVED = new RegExp(UNRESERVED$$, "g");
        var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");
        var NOT_LOCAL_PART = new RegExp(merge("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
        var NOT_HFNAME = new RegExp(merge("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
        var NOT_HFVALUE = NOT_HFNAME;
        function decodeUnreserved(str) {
          var decStr = pctDecChars(str);
          return !decStr.match(UNRESERVED) ? str : decStr;
        }
        var handler$4 = {
          scheme: "mailto",
          parse: function parse$$1(components, options) {
            var mailtoComponents = components;
            var to = mailtoComponents.to = mailtoComponents.path ? mailtoComponents.path.split(",") : [];
            mailtoComponents.path = void 0;
            if (mailtoComponents.query) {
              var unknownHeaders = false;
              var headers = {};
              var hfields = mailtoComponents.query.split("&");
              for (var x = 0, xl = hfields.length; x < xl; ++x) {
                var hfield = hfields[x].split("=");
                switch (hfield[0]) {
                  case "to":
                    var toAddrs = hfield[1].split(",");
                    for (var _x = 0, _xl = toAddrs.length; _x < _xl; ++_x) {
                      to.push(toAddrs[_x]);
                    }
                    break;
                  case "subject":
                    mailtoComponents.subject = unescapeComponent(hfield[1], options);
                    break;
                  case "body":
                    mailtoComponents.body = unescapeComponent(hfield[1], options);
                    break;
                  default:
                    unknownHeaders = true;
                    headers[unescapeComponent(hfield[0], options)] = unescapeComponent(hfield[1], options);
                    break;
                }
              }
              if (unknownHeaders)
                mailtoComponents.headers = headers;
            }
            mailtoComponents.query = void 0;
            for (var _x2 = 0, _xl2 = to.length; _x2 < _xl2; ++_x2) {
              var addr = to[_x2].split("@");
              addr[0] = unescapeComponent(addr[0]);
              if (!options.unicodeSupport) {
                try {
                  addr[1] = punycode2.toASCII(unescapeComponent(addr[1], options).toLowerCase());
                } catch (e) {
                  mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e;
                }
              } else {
                addr[1] = unescapeComponent(addr[1], options).toLowerCase();
              }
              to[_x2] = addr.join("@");
            }
            return mailtoComponents;
          },
          serialize: function serialize$$1(mailtoComponents, options) {
            var components = mailtoComponents;
            var to = toArray(mailtoComponents.to);
            if (to) {
              for (var x = 0, xl = to.length; x < xl; ++x) {
                var toAddr = String(to[x]);
                var atIdx = toAddr.lastIndexOf("@");
                var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);
                var domain = toAddr.slice(atIdx + 1);
                try {
                  domain = !options.iri ? punycode2.toASCII(unescapeComponent(domain, options).toLowerCase()) : punycode2.toUnicode(domain);
                } catch (e) {
                  components.error = components.error || "Email address's domain name can not be converted to " + (!options.iri ? "ASCII" : "Unicode") + " via punycode: " + e;
                }
                to[x] = localPart + "@" + domain;
              }
              components.path = to.join(",");
            }
            var headers = mailtoComponents.headers = mailtoComponents.headers || {};
            if (mailtoComponents.subject)
              headers["subject"] = mailtoComponents.subject;
            if (mailtoComponents.body)
              headers["body"] = mailtoComponents.body;
            var fields = [];
            for (var name in headers) {
              if (headers[name] !== O[name]) {
                fields.push(name.replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFNAME, pctEncChar) + "=" + headers[name].replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_HFVALUE, pctEncChar));
              }
            }
            if (fields.length) {
              components.query = fields.join("&");
            }
            return components;
          }
        };
        var URN_PARSE = /^([^\:]+)\:(.*)/;
        var handler$5 = {
          scheme: "urn",
          parse: function parse$$1(components, options) {
            var matches = components.path && components.path.match(URN_PARSE);
            var urnComponents = components;
            if (matches) {
              var scheme = options.scheme || urnComponents.scheme || "urn";
              var nid = matches[1].toLowerCase();
              var nss = matches[2];
              var urnScheme = scheme + ":" + (options.nid || nid);
              var schemeHandler = SCHEMES[urnScheme];
              urnComponents.nid = nid;
              urnComponents.nss = nss;
              urnComponents.path = void 0;
              if (schemeHandler) {
                urnComponents = schemeHandler.parse(urnComponents, options);
              }
            } else {
              urnComponents.error = urnComponents.error || "URN can not be parsed.";
            }
            return urnComponents;
          },
          serialize: function serialize$$1(urnComponents, options) {
            var scheme = options.scheme || urnComponents.scheme || "urn";
            var nid = urnComponents.nid;
            var urnScheme = scheme + ":" + (options.nid || nid);
            var schemeHandler = SCHEMES[urnScheme];
            if (schemeHandler) {
              urnComponents = schemeHandler.serialize(urnComponents, options);
            }
            var uriComponents = urnComponents;
            var nss = urnComponents.nss;
            uriComponents.path = (nid || options.nid) + ":" + nss;
            return uriComponents;
          }
        };
        var UUID = /^[0-9A-Fa-f]{8}(?:\-[0-9A-Fa-f]{4}){3}\-[0-9A-Fa-f]{12}$/;
        var handler$6 = {
          scheme: "urn:uuid",
          parse: function parse3(urnComponents, options) {
            var uuidComponents = urnComponents;
            uuidComponents.uuid = uuidComponents.nss;
            uuidComponents.nss = void 0;
            if (!options.tolerant && (!uuidComponents.uuid || !uuidComponents.uuid.match(UUID))) {
              uuidComponents.error = uuidComponents.error || "UUID is not valid.";
            }
            return uuidComponents;
          },
          serialize: function serialize2(uuidComponents, options) {
            var urnComponents = uuidComponents;
            urnComponents.nss = (uuidComponents.uuid || "").toLowerCase();
            return urnComponents;
          }
        };
        SCHEMES[handler.scheme] = handler;
        SCHEMES[handler$1.scheme] = handler$1;
        SCHEMES[handler$2.scheme] = handler$2;
        SCHEMES[handler$3.scheme] = handler$3;
        SCHEMES[handler$4.scheme] = handler$4;
        SCHEMES[handler$5.scheme] = handler$5;
        SCHEMES[handler$6.scheme] = handler$6;
        exports2.SCHEMES = SCHEMES;
        exports2.pctEncChar = pctEncChar;
        exports2.pctDecChars = pctDecChars;
        exports2.parse = parse2;
        exports2.removeDotSegments = removeDotSegments;
        exports2.serialize = serialize;
        exports2.resolveComponents = resolveComponents;
        exports2.resolve = resolve;
        exports2.normalize = normalize;
        exports2.equal = equal;
        exports2.escapeComponent = escapeComponent;
        exports2.unescapeComponent = unescapeComponent;
        Object.defineProperty(exports2, "__esModule", { value: true });
      });
    })(uri_all, uri_all.exports);
    return uri_all.exports;
  }
  var fastDeepEqual;
  var hasRequiredFastDeepEqual;
  function requireFastDeepEqual() {
    if (hasRequiredFastDeepEqual)
      return fastDeepEqual;
    hasRequiredFastDeepEqual = 1;
    fastDeepEqual = function equal(a2, b2) {
      if (a2 === b2)
        return true;
      if (a2 && b2 && typeof a2 == "object" && typeof b2 == "object") {
        if (a2.constructor !== b2.constructor)
          return false;
        var length, i2, keys;
        if (Array.isArray(a2)) {
          length = a2.length;
          if (length != b2.length)
            return false;
          for (i2 = length; i2-- !== 0; )
            if (!equal(a2[i2], b2[i2]))
              return false;
          return true;
        }
        if (a2.constructor === RegExp)
          return a2.source === b2.source && a2.flags === b2.flags;
        if (a2.valueOf !== Object.prototype.valueOf)
          return a2.valueOf() === b2.valueOf();
        if (a2.toString !== Object.prototype.toString)
          return a2.toString() === b2.toString();
        keys = Object.keys(a2);
        length = keys.length;
        if (length !== Object.keys(b2).length)
          return false;
        for (i2 = length; i2-- !== 0; )
          if (!Object.prototype.hasOwnProperty.call(b2, keys[i2]))
            return false;
        for (i2 = length; i2-- !== 0; ) {
          var key2 = keys[i2];
          if (!equal(a2[key2], b2[key2]))
            return false;
        }
        return true;
      }
      return a2 !== a2 && b2 !== b2;
    };
    return fastDeepEqual;
  }
  var ucs2length;
  var hasRequiredUcs2length;
  function requireUcs2length() {
    if (hasRequiredUcs2length)
      return ucs2length;
    hasRequiredUcs2length = 1;
    ucs2length = function ucs2length2(str) {
      var length = 0, len = str.length, pos = 0, value;
      while (pos < len) {
        length++;
        value = str.charCodeAt(pos++);
        if (value >= 55296 && value <= 56319 && pos < len) {
          value = str.charCodeAt(pos);
          if ((value & 64512) == 56320)
            pos++;
        }
      }
      return length;
    };
    return ucs2length;
  }
  var util;
  var hasRequiredUtil;
  function requireUtil() {
    if (hasRequiredUtil)
      return util;
    hasRequiredUtil = 1;
    util = {
      copy: copy2,
      checkDataType,
      checkDataTypes,
      coerceToTypes,
      toHash,
      getProperty: getProperty3,
      escapeQuotes,
      equal: requireFastDeepEqual(),
      ucs2length: requireUcs2length(),
      varOccurences,
      varReplace,
      schemaHasRules,
      schemaHasRulesExcept,
      schemaUnknownRules,
      toQuotedString,
      getPathExpr,
      getPath,
      getData,
      unescapeFragment,
      unescapeJsonPointer,
      escapeFragment,
      escapeJsonPointer
    };
    function copy2(o, to) {
      to = to || {};
      for (var key2 in o)
        to[key2] = o[key2];
      return to;
    }
    function checkDataType(dataType, data2, strictNumbers, negate) {
      var EQUAL = negate ? " !== " : " === ", AND = negate ? " || " : " && ", OK = negate ? "!" : "", NOT = negate ? "" : "!";
      switch (dataType) {
        case "null":
          return data2 + EQUAL + "null";
        case "array":
          return OK + "Array.isArray(" + data2 + ")";
        case "object":
          return "(" + OK + data2 + AND + "typeof " + data2 + EQUAL + '"object"' + AND + NOT + "Array.isArray(" + data2 + "))";
        case "integer":
          return "(typeof " + data2 + EQUAL + '"number"' + AND + NOT + "(" + data2 + " % 1)" + AND + data2 + EQUAL + data2 + (strictNumbers ? AND + OK + "isFinite(" + data2 + ")" : "") + ")";
        case "number":
          return "(typeof " + data2 + EQUAL + '"' + dataType + '"' + (strictNumbers ? AND + OK + "isFinite(" + data2 + ")" : "") + ")";
        default:
          return "typeof " + data2 + EQUAL + '"' + dataType + '"';
      }
    }
    function checkDataTypes(dataTypes, data2, strictNumbers) {
      switch (dataTypes.length) {
        case 1:
          return checkDataType(dataTypes[0], data2, strictNumbers, true);
        default:
          var code = "";
          var types2 = toHash(dataTypes);
          if (types2.array && types2.object) {
            code = types2.null ? "(" : "(!" + data2 + " || ";
            code += "typeof " + data2 + ' !== "object")';
            delete types2.null;
            delete types2.array;
            delete types2.object;
          }
          if (types2.number)
            delete types2.integer;
          for (var t in types2)
            code += (code ? " && " : "") + checkDataType(t, data2, strictNumbers, true);
          return code;
      }
    }
    var COERCE_TO_TYPES = toHash(["string", "number", "integer", "boolean", "null"]);
    function coerceToTypes(optionCoerceTypes, dataTypes) {
      if (Array.isArray(dataTypes)) {
        var types2 = [];
        for (var i2 = 0; i2 < dataTypes.length; i2++) {
          var t = dataTypes[i2];
          if (COERCE_TO_TYPES[t])
            types2[types2.length] = t;
          else if (optionCoerceTypes === "array" && t === "array")
            types2[types2.length] = t;
        }
        if (types2.length)
          return types2;
      } else if (COERCE_TO_TYPES[dataTypes]) {
        return [dataTypes];
      } else if (optionCoerceTypes === "array" && dataTypes === "array") {
        return ["array"];
      }
    }
    function toHash(arr) {
      var hash = {};
      for (var i2 = 0; i2 < arr.length; i2++)
        hash[arr[i2]] = true;
      return hash;
    }
    var IDENTIFIER = /^[a-z$_][a-z$_0-9]*$/i;
    var SINGLE_QUOTE = /'|\\/g;
    function getProperty3(key2) {
      return typeof key2 == "number" ? "[" + key2 + "]" : IDENTIFIER.test(key2) ? "." + key2 : "['" + escapeQuotes(key2) + "']";
    }
    function escapeQuotes(str) {
      return str.replace(SINGLE_QUOTE, "\\$&").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\f/g, "\\f").replace(/\t/g, "\\t");
    }
    function varOccurences(str, dataVar) {
      dataVar += "[^0-9]";
      var matches = str.match(new RegExp(dataVar, "g"));
      return matches ? matches.length : 0;
    }
    function varReplace(str, dataVar, expr) {
      dataVar += "([^0-9])";
      expr = expr.replace(/\$/g, "$$$$");
      return str.replace(new RegExp(dataVar, "g"), expr + "$1");
    }
    function schemaHasRules(schema, rules2) {
      if (typeof schema == "boolean")
        return !schema;
      for (var key2 in schema)
        if (rules2[key2])
          return true;
    }
    function schemaHasRulesExcept(schema, rules2, exceptKeyword) {
      if (typeof schema == "boolean")
        return !schema && exceptKeyword != "not";
      for (var key2 in schema)
        if (key2 != exceptKeyword && rules2[key2])
          return true;
    }
    function schemaUnknownRules(schema, rules2) {
      if (typeof schema == "boolean")
        return;
      for (var key2 in schema)
        if (!rules2[key2])
          return key2;
    }
    function toQuotedString(str) {
      return "'" + escapeQuotes(str) + "'";
    }
    function getPathExpr(currentPath, expr, jsonPointers, isNumber) {
      var path = jsonPointers ? "'/' + " + expr + (isNumber ? "" : ".replace(/~/g, '~0').replace(/\\//g, '~1')") : isNumber ? "'[' + " + expr + " + ']'" : "'[\\'' + " + expr + " + '\\']'";
      return joinPaths(currentPath, path);
    }
    function getPath(currentPath, prop, jsonPointers) {
      var path = jsonPointers ? toQuotedString("/" + escapeJsonPointer(prop)) : toQuotedString(getProperty3(prop));
      return joinPaths(currentPath, path);
    }
    var JSON_POINTER = /^\/(?:[^~]|~0|~1)*$/;
    var RELATIVE_JSON_POINTER = /^([0-9]+)(#|\/(?:[^~]|~0|~1)*)?$/;
    function getData($data, lvl, paths) {
      var up, jsonPointer, data2, matches;
      if ($data === "")
        return "rootData";
      if ($data[0] == "/") {
        if (!JSON_POINTER.test($data))
          throw new Error("Invalid JSON-pointer: " + $data);
        jsonPointer = $data;
        data2 = "rootData";
      } else {
        matches = $data.match(RELATIVE_JSON_POINTER);
        if (!matches)
          throw new Error("Invalid JSON-pointer: " + $data);
        up = +matches[1];
        jsonPointer = matches[2];
        if (jsonPointer == "#") {
          if (up >= lvl)
            throw new Error("Cannot access property/index " + up + " levels up, current level is " + lvl);
          return paths[lvl - up];
        }
        if (up > lvl)
          throw new Error("Cannot access data " + up + " levels up, current level is " + lvl);
        data2 = "data" + (lvl - up || "");
        if (!jsonPointer)
          return data2;
      }
      var expr = data2;
      var segments = jsonPointer.split("/");
      for (var i2 = 0; i2 < segments.length; i2++) {
        var segment = segments[i2];
        if (segment) {
          data2 += getProperty3(unescapeJsonPointer(segment));
          expr += " && " + data2;
        }
      }
      return expr;
    }
    function joinPaths(a2, b2) {
      if (a2 == '""')
        return b2;
      return (a2 + " + " + b2).replace(/([^\\])' \+ '/g, "$1");
    }
    function unescapeFragment(str) {
      return unescapeJsonPointer(decodeURIComponent(str));
    }
    function escapeFragment(str) {
      return encodeURIComponent(escapeJsonPointer(str));
    }
    function escapeJsonPointer(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    function unescapeJsonPointer(str) {
      return str.replace(/~1/g, "/").replace(/~0/g, "~");
    }
    return util;
  }
  var schema_obj;
  var hasRequiredSchema_obj;
  function requireSchema_obj() {
    if (hasRequiredSchema_obj)
      return schema_obj;
    hasRequiredSchema_obj = 1;
    var util2 = requireUtil();
    schema_obj = SchemaObject;
    function SchemaObject(obj) {
      util2.copy(obj, this);
    }
    return schema_obj;
  }
  var jsonSchemaTraverse = { exports: {} };
  var hasRequiredJsonSchemaTraverse;
  function requireJsonSchemaTraverse() {
    if (hasRequiredJsonSchemaTraverse)
      return jsonSchemaTraverse.exports;
    hasRequiredJsonSchemaTraverse = 1;
    var traverse = jsonSchemaTraverse.exports = function(schema, opts, cb) {
      if (typeof opts == "function") {
        cb = opts;
        opts = {};
      }
      cb = opts.cb || cb;
      var pre = typeof cb == "function" ? cb : cb.pre || function() {
      };
      var post = cb.post || function() {
      };
      _traverse(opts, pre, post, schema, "", schema);
    };
    traverse.keywords = {
      additionalItems: true,
      items: true,
      contains: true,
      additionalProperties: true,
      propertyNames: true,
      not: true
    };
    traverse.arrayKeywords = {
      items: true,
      allOf: true,
      anyOf: true,
      oneOf: true
    };
    traverse.propsKeywords = {
      definitions: true,
      properties: true,
      patternProperties: true,
      dependencies: true
    };
    traverse.skipKeywords = {
      default: true,
      enum: true,
      const: true,
      required: true,
      maximum: true,
      minimum: true,
      exclusiveMaximum: true,
      exclusiveMinimum: true,
      multipleOf: true,
      maxLength: true,
      minLength: true,
      pattern: true,
      format: true,
      maxItems: true,
      minItems: true,
      uniqueItems: true,
      maxProperties: true,
      minProperties: true
    };
    function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
      if (schema && typeof schema == "object" && !Array.isArray(schema)) {
        pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
        for (var key2 in schema) {
          var sch = schema[key2];
          if (Array.isArray(sch)) {
            if (key2 in traverse.arrayKeywords) {
              for (var i2 = 0; i2 < sch.length; i2++)
                _traverse(opts, pre, post, sch[i2], jsonPtr + "/" + key2 + "/" + i2, rootSchema, jsonPtr, key2, schema, i2);
            }
          } else if (key2 in traverse.propsKeywords) {
            if (sch && typeof sch == "object") {
              for (var prop in sch)
                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key2 + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key2, schema, prop);
            }
          } else if (key2 in traverse.keywords || opts.allKeys && !(key2 in traverse.skipKeywords)) {
            _traverse(opts, pre, post, sch, jsonPtr + "/" + key2, rootSchema, jsonPtr, key2, schema);
          }
        }
        post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
      }
    }
    function escapeJsonPtr(str) {
      return str.replace(/~/g, "~0").replace(/\//g, "~1");
    }
    return jsonSchemaTraverse.exports;
  }
  var resolve_1;
  var hasRequiredResolve;
  function requireResolve() {
    if (hasRequiredResolve)
      return resolve_1;
    hasRequiredResolve = 1;
    var URI = requireUri_all(), equal = requireFastDeepEqual(), util2 = requireUtil(), SchemaObject = requireSchema_obj(), traverse = requireJsonSchemaTraverse();
    resolve_1 = resolve;
    resolve.normalizeId = normalizeId;
    resolve.fullPath = getFullPath;
    resolve.url = resolveUrl;
    resolve.ids = resolveIds;
    resolve.inlineRef = inlineRef;
    resolve.schema = resolveSchema;
    function resolve(compile, root, ref2) {
      var refVal = this._refs[ref2];
      if (typeof refVal == "string") {
        if (this._refs[refVal])
          refVal = this._refs[refVal];
        else
          return resolve.call(this, compile, root, refVal);
      }
      refVal = refVal || this._schemas[ref2];
      if (refVal instanceof SchemaObject) {
        return inlineRef(refVal.schema, this._opts.inlineRefs) ? refVal.schema : refVal.validate || this._compile(refVal);
      }
      var res = resolveSchema.call(this, root, ref2);
      var schema, v, baseId;
      if (res) {
        schema = res.schema;
        root = res.root;
        baseId = res.baseId;
      }
      if (schema instanceof SchemaObject) {
        v = schema.validate || compile.call(this, schema.schema, root, void 0, baseId);
      } else if (schema !== void 0) {
        v = inlineRef(schema, this._opts.inlineRefs) ? schema : compile.call(this, schema, root, void 0, baseId);
      }
      return v;
    }
    function resolveSchema(root, ref2) {
      var p = URI.parse(ref2), refPath = _getFullPath(p), baseId = getFullPath(this._getId(root.schema));
      if (Object.keys(root.schema).length === 0 || refPath !== baseId) {
        var id = normalizeId(refPath);
        var refVal = this._refs[id];
        if (typeof refVal == "string") {
          return resolveRecursive.call(this, root, refVal, p);
        } else if (refVal instanceof SchemaObject) {
          if (!refVal.validate)
            this._compile(refVal);
          root = refVal;
        } else {
          refVal = this._schemas[id];
          if (refVal instanceof SchemaObject) {
            if (!refVal.validate)
              this._compile(refVal);
            if (id == normalizeId(ref2))
              return { schema: refVal, root, baseId };
            root = refVal;
          } else {
            return;
          }
        }
        if (!root.schema)
          return;
        baseId = getFullPath(this._getId(root.schema));
      }
      return getJsonPointer.call(this, p, baseId, root.schema, root);
    }
    function resolveRecursive(root, ref2, parsedRef) {
      var res = resolveSchema.call(this, root, ref2);
      if (res) {
        var schema = res.schema;
        var baseId = res.baseId;
        root = res.root;
        var id = this._getId(schema);
        if (id)
          baseId = resolveUrl(baseId, id);
        return getJsonPointer.call(this, parsedRef, baseId, schema, root);
      }
    }
    var PREVENT_SCOPE_CHANGE = util2.toHash(["properties", "patternProperties", "enum", "dependencies", "definitions"]);
    function getJsonPointer(parsedRef, baseId, schema, root) {
      parsedRef.fragment = parsedRef.fragment || "";
      if (parsedRef.fragment.slice(0, 1) != "/")
        return;
      var parts = parsedRef.fragment.split("/");
      for (var i2 = 1; i2 < parts.length; i2++) {
        var part = parts[i2];
        if (part) {
          part = util2.unescapeFragment(part);
          schema = schema[part];
          if (schema === void 0)
            break;
          var id;
          if (!PREVENT_SCOPE_CHANGE[part]) {
            id = this._getId(schema);
            if (id)
              baseId = resolveUrl(baseId, id);
            if (schema.$ref) {
              var $ref = resolveUrl(baseId, schema.$ref);
              var res = resolveSchema.call(this, root, $ref);
              if (res) {
                schema = res.schema;
                root = res.root;
                baseId = res.baseId;
              }
            }
          }
        }
      }
      if (schema !== void 0 && schema !== root.schema)
        return { schema, root, baseId };
    }
    var SIMPLE_INLINED = util2.toHash([
      "type",
      "format",
      "pattern",
      "maxLength",
      "minLength",
      "maxProperties",
      "minProperties",
      "maxItems",
      "minItems",
      "maximum",
      "minimum",
      "uniqueItems",
      "multipleOf",
      "required",
      "enum"
    ]);
    function inlineRef(schema, limit) {
      if (limit === false)
        return false;
      if (limit === void 0 || limit === true)
        return checkNoRef(schema);
      else if (limit)
        return countKeys(schema) <= limit;
    }
    function checkNoRef(schema) {
      var item;
      if (Array.isArray(schema)) {
        for (var i2 = 0; i2 < schema.length; i2++) {
          item = schema[i2];
          if (typeof item == "object" && !checkNoRef(item))
            return false;
        }
      } else {
        for (var key2 in schema) {
          if (key2 == "$ref")
            return false;
          item = schema[key2];
          if (typeof item == "object" && !checkNoRef(item))
            return false;
        }
      }
      return true;
    }
    function countKeys(schema) {
      var count = 0, item;
      if (Array.isArray(schema)) {
        for (var i2 = 0; i2 < schema.length; i2++) {
          item = schema[i2];
          if (typeof item == "object")
            count += countKeys(item);
          if (count == Infinity)
            return Infinity;
        }
      } else {
        for (var key2 in schema) {
          if (key2 == "$ref")
            return Infinity;
          if (SIMPLE_INLINED[key2]) {
            count++;
          } else {
            item = schema[key2];
            if (typeof item == "object")
              count += countKeys(item) + 1;
            if (count == Infinity)
              return Infinity;
          }
        }
      }
      return count;
    }
    function getFullPath(id, normalize) {
      if (normalize !== false)
        id = normalizeId(id);
      var p = URI.parse(id);
      return _getFullPath(p);
    }
    function _getFullPath(p) {
      return URI.serialize(p).split("#")[0] + "#";
    }
    var TRAILING_SLASH_HASH = /#\/?$/;
    function normalizeId(id) {
      return id ? id.replace(TRAILING_SLASH_HASH, "") : "";
    }
    function resolveUrl(baseId, id) {
      id = normalizeId(id);
      return URI.resolve(baseId, id);
    }
    function resolveIds(schema) {
      var schemaId = normalizeId(this._getId(schema));
      var baseIds = { "": schemaId };
      var fullPaths = { "": getFullPath(schemaId, false) };
      var localRefs = {};
      var self2 = this;
      traverse(schema, { allKeys: true }, function(sch, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
        if (jsonPtr === "")
          return;
        var id = self2._getId(sch);
        var baseId = baseIds[parentJsonPtr];
        var fullPath = fullPaths[parentJsonPtr] + "/" + parentKeyword;
        if (keyIndex !== void 0)
          fullPath += "/" + (typeof keyIndex == "number" ? keyIndex : util2.escapeFragment(keyIndex));
        if (typeof id == "string") {
          id = baseId = normalizeId(baseId ? URI.resolve(baseId, id) : id);
          var refVal = self2._refs[id];
          if (typeof refVal == "string")
            refVal = self2._refs[refVal];
          if (refVal && refVal.schema) {
            if (!equal(sch, refVal.schema))
              throw new Error('id "' + id + '" resolves to more than one schema');
          } else if (id != normalizeId(fullPath)) {
            if (id[0] == "#") {
              if (localRefs[id] && !equal(sch, localRefs[id]))
                throw new Error('id "' + id + '" resolves to more than one schema');
              localRefs[id] = sch;
            } else {
              self2._refs[id] = fullPath;
            }
          }
        }
        baseIds[jsonPtr] = baseId;
        fullPaths[jsonPtr] = fullPath;
      });
      return localRefs;
    }
    return resolve_1;
  }
  var error_classes;
  var hasRequiredError_classes;
  function requireError_classes() {
    if (hasRequiredError_classes)
      return error_classes;
    hasRequiredError_classes = 1;
    var resolve = requireResolve();
    error_classes = {
      Validation: errorSubclass(ValidationError),
      MissingRef: errorSubclass(MissingRefError)
    };
    function ValidationError(errors2) {
      this.message = "validation failed";
      this.errors = errors2;
      this.ajv = this.validation = true;
    }
    MissingRefError.message = function(baseId, ref2) {
      return "can't resolve reference " + ref2 + " from id " + baseId;
    };
    function MissingRefError(baseId, ref2, message) {
      this.message = message || MissingRefError.message(baseId, ref2);
      this.missingRef = resolve.url(baseId, ref2);
      this.missingSchema = resolve.normalizeId(resolve.fullPath(this.missingRef));
    }
    function errorSubclass(Subclass) {
      Subclass.prototype = Object.create(Error.prototype);
      Subclass.prototype.constructor = Subclass;
      return Subclass;
    }
    return error_classes;
  }
  var fastJsonStableStringify;
  var hasRequiredFastJsonStableStringify;
  function requireFastJsonStableStringify() {
    if (hasRequiredFastJsonStableStringify)
      return fastJsonStableStringify;
    hasRequiredFastJsonStableStringify = 1;
    fastJsonStableStringify = function(data2, opts) {
      if (!opts)
        opts = {};
      if (typeof opts === "function")
        opts = { cmp: opts };
      var cycles = typeof opts.cycles === "boolean" ? opts.cycles : false;
      var cmp = opts.cmp && function(f) {
        return function(node) {
          return function(a2, b2) {
            var aobj = { key: a2, value: node[a2] };
            var bobj = { key: b2, value: node[b2] };
            return f(aobj, bobj);
          };
        };
      }(opts.cmp);
      var seen = [];
      return function stringify2(node) {
        if (node && node.toJSON && typeof node.toJSON === "function") {
          node = node.toJSON();
        }
        if (node === void 0)
          return;
        if (typeof node == "number")
          return isFinite(node) ? "" + node : "null";
        if (typeof node !== "object")
          return JSON.stringify(node);
        var i2, out;
        if (Array.isArray(node)) {
          out = "[";
          for (i2 = 0; i2 < node.length; i2++) {
            if (i2)
              out += ",";
            out += stringify2(node[i2]) || "null";
          }
          return out + "]";
        }
        if (node === null)
          return "null";
        if (seen.indexOf(node) !== -1) {
          if (cycles)
            return JSON.stringify("__cycle__");
          throw new TypeError("Converting circular structure to JSON");
        }
        var seenIndex = seen.push(node) - 1;
        var keys = Object.keys(node).sort(cmp && cmp(node));
        out = "";
        for (i2 = 0; i2 < keys.length; i2++) {
          var key2 = keys[i2];
          var value = stringify2(node[key2]);
          if (!value)
            continue;
          if (out)
            out += ",";
          out += JSON.stringify(key2) + ":" + value;
        }
        seen.splice(seenIndex, 1);
        return "{" + out + "}";
      }(data2);
    };
    return fastJsonStableStringify;
  }
  var validate2;
  var hasRequiredValidate;
  function requireValidate() {
    if (hasRequiredValidate)
      return validate2;
    hasRequiredValidate = 1;
    validate2 = function generate_validate(it, $keyword, $ruleType) {
      var out = "";
      var $async = it.schema.$async === true, $refKeywords = it.util.schemaHasRulesExcept(it.schema, it.RULES.all, "$ref"), $id2 = it.self._getId(it.schema);
      if (it.opts.strictKeywords) {
        var $unknownKwd = it.util.schemaUnknownRules(it.schema, it.RULES.keywords);
        if ($unknownKwd) {
          var $keywordsMsg = "unknown keyword: " + $unknownKwd;
          if (it.opts.strictKeywords === "log")
            it.logger.warn($keywordsMsg);
          else
            throw new Error($keywordsMsg);
        }
      }
      if (it.isTop) {
        out += " var validate = ";
        if ($async) {
          it.async = true;
          out += "async ";
        }
        out += "function(data, dataPath, parentData, parentDataProperty, rootData) { 'use strict'; ";
        if ($id2 && (it.opts.sourceCode || it.opts.processCode)) {
          out += " " + ("/*# sourceURL=" + $id2 + " */") + " ";
        }
      }
      if (typeof it.schema == "boolean" || !($refKeywords || it.schema.$ref)) {
        var $keyword = "false schema";
        var $lvl = it.level;
        var $dataLvl = it.dataLevel;
        var $schema2 = it.schema[$keyword];
        var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
        var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
        var $breakOnError = !it.opts.allErrors;
        var $errorKeyword;
        var $data = "data" + ($dataLvl || "");
        var $valid = "valid" + $lvl;
        if (it.schema === false) {
          if (it.isTop) {
            $breakOnError = true;
          } else {
            out += " var " + $valid + " = false; ";
          }
          var $$outStack = $$outStack || [];
          $$outStack.push(out);
          out = "";
          if (it.createErrors !== false) {
            out += " { keyword: '" + ($errorKeyword || "false schema") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
            if (it.opts.messages !== false) {
              out += " , message: 'boolean schema is false' ";
            }
            if (it.opts.verbose) {
              out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          var __err = out;
          out = $$outStack.pop();
          if (!it.compositeRule && $breakOnError) {
            if (it.async) {
              out += " throw new ValidationError([" + __err + "]); ";
            } else {
              out += " validate.errors = [" + __err + "]; return false; ";
            }
          } else {
            out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          }
        } else {
          if (it.isTop) {
            if ($async) {
              out += " return data; ";
            } else {
              out += " validate.errors = null; return true; ";
            }
          } else {
            out += " var " + $valid + " = true; ";
          }
        }
        if (it.isTop) {
          out += " }; return validate; ";
        }
        return out;
      }
      if (it.isTop) {
        var $top = it.isTop, $lvl = it.level = 0, $dataLvl = it.dataLevel = 0, $data = "data";
        it.rootId = it.resolve.fullPath(it.self._getId(it.root.schema));
        it.baseId = it.baseId || it.rootId;
        delete it.isTop;
        it.dataPathArr = [""];
        if (it.schema.default !== void 0 && it.opts.useDefaults && it.opts.strictDefaults) {
          var $defaultMsg = "default is ignored in the schema root";
          if (it.opts.strictDefaults === "log")
            it.logger.warn($defaultMsg);
          else
            throw new Error($defaultMsg);
        }
        out += " var vErrors = null; ";
        out += " var errors = 0;     ";
        out += " if (rootData === undefined) rootData = data; ";
      } else {
        var $lvl = it.level, $dataLvl = it.dataLevel, $data = "data" + ($dataLvl || "");
        if ($id2)
          it.baseId = it.resolve.url(it.baseId, $id2);
        if ($async && !it.async)
          throw new Error("async schema in sync schema");
        out += " var errs_" + $lvl + " = errors;";
      }
      var $valid = "valid" + $lvl, $breakOnError = !it.opts.allErrors, $closingBraces1 = "", $closingBraces2 = "";
      var $errorKeyword;
      var $typeSchema = it.schema.type, $typeIsArray = Array.isArray($typeSchema);
      if ($typeSchema && it.opts.nullable && it.schema.nullable === true) {
        if ($typeIsArray) {
          if ($typeSchema.indexOf("null") == -1)
            $typeSchema = $typeSchema.concat("null");
        } else if ($typeSchema != "null") {
          $typeSchema = [$typeSchema, "null"];
          $typeIsArray = true;
        }
      }
      if ($typeIsArray && $typeSchema.length == 1) {
        $typeSchema = $typeSchema[0];
        $typeIsArray = false;
      }
      if (it.schema.$ref && $refKeywords) {
        if (it.opts.extendRefs == "fail") {
          throw new Error('$ref: validation keywords used in schema at path "' + it.errSchemaPath + '" (see option extendRefs)');
        } else if (it.opts.extendRefs !== true) {
          $refKeywords = false;
          it.logger.warn('$ref: keywords ignored in schema at path "' + it.errSchemaPath + '"');
        }
      }
      if (it.schema.$comment && it.opts.$comment) {
        out += " " + it.RULES.all.$comment.code(it, "$comment");
      }
      if ($typeSchema) {
        if (it.opts.coerceTypes) {
          var $coerceToTypes = it.util.coerceToTypes(it.opts.coerceTypes, $typeSchema);
        }
        var $rulesGroup = it.RULES.types[$typeSchema];
        if ($coerceToTypes || $typeIsArray || $rulesGroup === true || $rulesGroup && !$shouldUseGroup($rulesGroup)) {
          var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type";
          var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type", $method = $typeIsArray ? "checkDataTypes" : "checkDataType";
          out += " if (" + it.util[$method]($typeSchema, $data, it.opts.strictNumbers, true) + ") { ";
          if ($coerceToTypes) {
            var $dataType = "dataType" + $lvl, $coerced = "coerced" + $lvl;
            out += " var " + $dataType + " = typeof " + $data + "; var " + $coerced + " = undefined; ";
            if (it.opts.coerceTypes == "array") {
              out += " if (" + $dataType + " == 'object' && Array.isArray(" + $data + ") && " + $data + ".length == 1) { " + $data + " = " + $data + "[0]; " + $dataType + " = typeof " + $data + "; if (" + it.util.checkDataType(it.schema.type, $data, it.opts.strictNumbers) + ") " + $coerced + " = " + $data + "; } ";
            }
            out += " if (" + $coerced + " !== undefined) ; ";
            var arr1 = $coerceToTypes;
            if (arr1) {
              var $type, $i = -1, l1 = arr1.length - 1;
              while ($i < l1) {
                $type = arr1[$i += 1];
                if ($type == "string") {
                  out += " else if (" + $dataType + " == 'number' || " + $dataType + " == 'boolean') " + $coerced + " = '' + " + $data + "; else if (" + $data + " === null) " + $coerced + " = ''; ";
                } else if ($type == "number" || $type == "integer") {
                  out += " else if (" + $dataType + " == 'boolean' || " + $data + " === null || (" + $dataType + " == 'string' && " + $data + " && " + $data + " == +" + $data + " ";
                  if ($type == "integer") {
                    out += " && !(" + $data + " % 1)";
                  }
                  out += ")) " + $coerced + " = +" + $data + "; ";
                } else if ($type == "boolean") {
                  out += " else if (" + $data + " === 'false' || " + $data + " === 0 || " + $data + " === null) " + $coerced + " = false; else if (" + $data + " === 'true' || " + $data + " === 1) " + $coerced + " = true; ";
                } else if ($type == "null") {
                  out += " else if (" + $data + " === '' || " + $data + " === 0 || " + $data + " === false) " + $coerced + " = null; ";
                } else if (it.opts.coerceTypes == "array" && $type == "array") {
                  out += " else if (" + $dataType + " == 'string' || " + $dataType + " == 'number' || " + $dataType + " == 'boolean' || " + $data + " == null) " + $coerced + " = [" + $data + "]; ";
                }
              }
            }
            out += " else {   ";
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '";
              if ($typeIsArray) {
                out += "" + $typeSchema.join(",");
              } else {
                out += "" + $typeSchema;
              }
              out += "' } ";
              if (it.opts.messages !== false) {
                out += " , message: 'should be ";
                if ($typeIsArray) {
                  out += "" + $typeSchema.join(",");
                } else {
                  out += "" + $typeSchema;
                }
                out += "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } if (" + $coerced + " !== undefined) {  ";
            var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty";
            out += " " + $data + " = " + $coerced + "; ";
            if (!$dataLvl) {
              out += "if (" + $parentData + " !== undefined)";
            }
            out += " " + $parentData + "[" + $parentDataProperty + "] = " + $coerced + "; } ";
          } else {
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '";
              if ($typeIsArray) {
                out += "" + $typeSchema.join(",");
              } else {
                out += "" + $typeSchema;
              }
              out += "' } ";
              if (it.opts.messages !== false) {
                out += " , message: 'should be ";
                if ($typeIsArray) {
                  out += "" + $typeSchema.join(",");
                } else {
                  out += "" + $typeSchema;
                }
                out += "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
          }
          out += " } ";
        }
      }
      if (it.schema.$ref && !$refKeywords) {
        out += " " + it.RULES.all.$ref.code(it, "$ref") + " ";
        if ($breakOnError) {
          out += " } if (errors === ";
          if ($top) {
            out += "0";
          } else {
            out += "errs_" + $lvl;
          }
          out += ") { ";
          $closingBraces2 += "}";
        }
      } else {
        var arr2 = it.RULES;
        if (arr2) {
          var $rulesGroup, i2 = -1, l2 = arr2.length - 1;
          while (i2 < l2) {
            $rulesGroup = arr2[i2 += 1];
            if ($shouldUseGroup($rulesGroup)) {
              if ($rulesGroup.type) {
                out += " if (" + it.util.checkDataType($rulesGroup.type, $data, it.opts.strictNumbers) + ") { ";
              }
              if (it.opts.useDefaults) {
                if ($rulesGroup.type == "object" && it.schema.properties) {
                  var $schema2 = it.schema.properties, $schemaKeys = Object.keys($schema2);
                  var arr3 = $schemaKeys;
                  if (arr3) {
                    var $propertyKey, i3 = -1, l3 = arr3.length - 1;
                    while (i3 < l3) {
                      $propertyKey = arr3[i3 += 1];
                      var $sch = $schema2[$propertyKey];
                      if ($sch.default !== void 0) {
                        var $passData = $data + it.util.getProperty($propertyKey);
                        if (it.compositeRule) {
                          if (it.opts.strictDefaults) {
                            var $defaultMsg = "default is ignored for: " + $passData;
                            if (it.opts.strictDefaults === "log")
                              it.logger.warn($defaultMsg);
                            else
                              throw new Error($defaultMsg);
                          }
                        } else {
                          out += " if (" + $passData + " === undefined ";
                          if (it.opts.useDefaults == "empty") {
                            out += " || " + $passData + " === null || " + $passData + " === '' ";
                          }
                          out += " ) " + $passData + " = ";
                          if (it.opts.useDefaults == "shared") {
                            out += " " + it.useDefault($sch.default) + " ";
                          } else {
                            out += " " + JSON.stringify($sch.default) + " ";
                          }
                          out += "; ";
                        }
                      }
                    }
                  }
                } else if ($rulesGroup.type == "array" && Array.isArray(it.schema.items)) {
                  var arr4 = it.schema.items;
                  if (arr4) {
                    var $sch, $i = -1, l4 = arr4.length - 1;
                    while ($i < l4) {
                      $sch = arr4[$i += 1];
                      if ($sch.default !== void 0) {
                        var $passData = $data + "[" + $i + "]";
                        if (it.compositeRule) {
                          if (it.opts.strictDefaults) {
                            var $defaultMsg = "default is ignored for: " + $passData;
                            if (it.opts.strictDefaults === "log")
                              it.logger.warn($defaultMsg);
                            else
                              throw new Error($defaultMsg);
                          }
                        } else {
                          out += " if (" + $passData + " === undefined ";
                          if (it.opts.useDefaults == "empty") {
                            out += " || " + $passData + " === null || " + $passData + " === '' ";
                          }
                          out += " ) " + $passData + " = ";
                          if (it.opts.useDefaults == "shared") {
                            out += " " + it.useDefault($sch.default) + " ";
                          } else {
                            out += " " + JSON.stringify($sch.default) + " ";
                          }
                          out += "; ";
                        }
                      }
                    }
                  }
                }
              }
              var arr5 = $rulesGroup.rules;
              if (arr5) {
                var $rule, i5 = -1, l5 = arr5.length - 1;
                while (i5 < l5) {
                  $rule = arr5[i5 += 1];
                  if ($shouldUseRule($rule)) {
                    var $code = $rule.code(it, $rule.keyword, $rulesGroup.type);
                    if ($code) {
                      out += " " + $code + " ";
                      if ($breakOnError) {
                        $closingBraces1 += "}";
                      }
                    }
                  }
                }
              }
              if ($breakOnError) {
                out += " " + $closingBraces1 + " ";
                $closingBraces1 = "";
              }
              if ($rulesGroup.type) {
                out += " } ";
                if ($typeSchema && $typeSchema === $rulesGroup.type && !$coerceToTypes) {
                  out += " else { ";
                  var $schemaPath = it.schemaPath + ".type", $errSchemaPath = it.errSchemaPath + "/type";
                  var $$outStack = $$outStack || [];
                  $$outStack.push(out);
                  out = "";
                  if (it.createErrors !== false) {
                    out += " { keyword: '" + ($errorKeyword || "type") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { type: '";
                    if ($typeIsArray) {
                      out += "" + $typeSchema.join(",");
                    } else {
                      out += "" + $typeSchema;
                    }
                    out += "' } ";
                    if (it.opts.messages !== false) {
                      out += " , message: 'should be ";
                      if ($typeIsArray) {
                        out += "" + $typeSchema.join(",");
                      } else {
                        out += "" + $typeSchema;
                      }
                      out += "' ";
                    }
                    if (it.opts.verbose) {
                      out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                    }
                    out += " } ";
                  } else {
                    out += " {} ";
                  }
                  var __err = out;
                  out = $$outStack.pop();
                  if (!it.compositeRule && $breakOnError) {
                    if (it.async) {
                      out += " throw new ValidationError([" + __err + "]); ";
                    } else {
                      out += " validate.errors = [" + __err + "]; return false; ";
                    }
                  } else {
                    out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
                  }
                  out += " } ";
                }
              }
              if ($breakOnError) {
                out += " if (errors === ";
                if ($top) {
                  out += "0";
                } else {
                  out += "errs_" + $lvl;
                }
                out += ") { ";
                $closingBraces2 += "}";
              }
            }
          }
        }
      }
      if ($breakOnError) {
        out += " " + $closingBraces2 + " ";
      }
      if ($top) {
        if ($async) {
          out += " if (errors === 0) return data;           ";
          out += " else throw new ValidationError(vErrors); ";
        } else {
          out += " validate.errors = vErrors; ";
          out += " return errors === 0;       ";
        }
        out += " }; return validate;";
      } else {
        out += " var " + $valid + " = errors === errs_" + $lvl + ";";
      }
      function $shouldUseGroup($rulesGroup2) {
        var rules2 = $rulesGroup2.rules;
        for (var i4 = 0; i4 < rules2.length; i4++)
          if ($shouldUseRule(rules2[i4]))
            return true;
      }
      function $shouldUseRule($rule2) {
        return it.schema[$rule2.keyword] !== void 0 || $rule2.implements && $ruleImplementsSomeKeyword($rule2);
      }
      function $ruleImplementsSomeKeyword($rule2) {
        var impl = $rule2.implements;
        for (var i4 = 0; i4 < impl.length; i4++)
          if (it.schema[impl[i4]] !== void 0)
            return true;
      }
      return out;
    };
    return validate2;
  }
  var compile_1;
  var hasRequiredCompile;
  function requireCompile() {
    if (hasRequiredCompile)
      return compile_1;
    hasRequiredCompile = 1;
    var resolve = requireResolve(), util2 = requireUtil(), errorClasses = requireError_classes(), stableStringify = requireFastJsonStableStringify();
    var validateGenerator = requireValidate();
    var ucs2length2 = util2.ucs2length;
    var equal = requireFastDeepEqual();
    var ValidationError = errorClasses.Validation;
    compile_1 = compile;
    function compile(schema, root, localRefs, baseId) {
      var self2 = this, opts = this._opts, refVal = [void 0], refs = {}, patterns = [], patternsHash = {}, defaults = [], defaultsHash = {}, customRules = [];
      root = root || { schema, refVal, refs };
      var c2 = checkCompiling.call(this, schema, root, baseId);
      var compilation = this._compilations[c2.index];
      if (c2.compiling)
        return compilation.callValidate = callValidate;
      var formats2 = this._formats;
      var RULES = this.RULES;
      try {
        var v = localCompile(schema, root, localRefs, baseId);
        compilation.validate = v;
        var cv = compilation.callValidate;
        if (cv) {
          cv.schema = v.schema;
          cv.errors = null;
          cv.refs = v.refs;
          cv.refVal = v.refVal;
          cv.root = v.root;
          cv.$async = v.$async;
          if (opts.sourceCode)
            cv.source = v.source;
        }
        return v;
      } finally {
        endCompiling.call(this, schema, root, baseId);
      }
      function callValidate() {
        var validate3 = compilation.validate;
        var result2 = validate3.apply(this, arguments);
        callValidate.errors = validate3.errors;
        return result2;
      }
      function localCompile(_schema, _root, localRefs2, baseId2) {
        var isRoot = !_root || _root && _root.schema == _schema;
        if (_root.schema != root.schema)
          return compile.call(self2, _schema, _root, localRefs2, baseId2);
        var $async = _schema.$async === true;
        var sourceCode = validateGenerator({
          isTop: true,
          schema: _schema,
          isRoot,
          baseId: baseId2,
          root: _root,
          schemaPath: "",
          errSchemaPath: "#",
          errorPath: '""',
          MissingRefError: errorClasses.MissingRef,
          RULES,
          validate: validateGenerator,
          util: util2,
          resolve,
          resolveRef,
          usePattern,
          useDefault,
          useCustomRule,
          opts,
          formats: formats2,
          logger: self2.logger,
          self: self2
        });
        sourceCode = vars(refVal, refValCode) + vars(patterns, patternCode) + vars(defaults, defaultCode) + vars(customRules, customRuleCode) + sourceCode;
        if (opts.processCode)
          sourceCode = opts.processCode(sourceCode, _schema);
        var validate3;
        try {
          var makeValidate = new Function(
            "self",
            "RULES",
            "formats",
            "root",
            "refVal",
            "defaults",
            "customRules",
            "equal",
            "ucs2length",
            "ValidationError",
            sourceCode
          );
          validate3 = makeValidate(
            self2,
            RULES,
            formats2,
            root,
            refVal,
            defaults,
            customRules,
            equal,
            ucs2length2,
            ValidationError
          );
          refVal[0] = validate3;
        } catch (e) {
          self2.logger.error("Error compiling schema, function code:", sourceCode);
          throw e;
        }
        validate3.schema = _schema;
        validate3.errors = null;
        validate3.refs = refs;
        validate3.refVal = refVal;
        validate3.root = isRoot ? validate3 : _root;
        if ($async)
          validate3.$async = true;
        if (opts.sourceCode === true) {
          validate3.source = {
            code: sourceCode,
            patterns,
            defaults
          };
        }
        return validate3;
      }
      function resolveRef(baseId2, ref2, isRoot) {
        ref2 = resolve.url(baseId2, ref2);
        var refIndex = refs[ref2];
        var _refVal, refCode;
        if (refIndex !== void 0) {
          _refVal = refVal[refIndex];
          refCode = "refVal[" + refIndex + "]";
          return resolvedRef(_refVal, refCode);
        }
        if (!isRoot && root.refs) {
          var rootRefId = root.refs[ref2];
          if (rootRefId !== void 0) {
            _refVal = root.refVal[rootRefId];
            refCode = addLocalRef(ref2, _refVal);
            return resolvedRef(_refVal, refCode);
          }
        }
        refCode = addLocalRef(ref2);
        var v2 = resolve.call(self2, localCompile, root, ref2);
        if (v2 === void 0) {
          var localSchema = localRefs && localRefs[ref2];
          if (localSchema) {
            v2 = resolve.inlineRef(localSchema, opts.inlineRefs) ? localSchema : compile.call(self2, localSchema, root, localRefs, baseId2);
          }
        }
        if (v2 === void 0) {
          removeLocalRef(ref2);
        } else {
          replaceLocalRef(ref2, v2);
          return resolvedRef(v2, refCode);
        }
      }
      function addLocalRef(ref2, v2) {
        var refId = refVal.length;
        refVal[refId] = v2;
        refs[ref2] = refId;
        return "refVal" + refId;
      }
      function removeLocalRef(ref2) {
        delete refs[ref2];
      }
      function replaceLocalRef(ref2, v2) {
        var refId = refs[ref2];
        refVal[refId] = v2;
      }
      function resolvedRef(refVal2, code) {
        return typeof refVal2 == "object" || typeof refVal2 == "boolean" ? { code, schema: refVal2, inline: true } : { code, $async: refVal2 && !!refVal2.$async };
      }
      function usePattern(regexStr) {
        var index = patternsHash[regexStr];
        if (index === void 0) {
          index = patternsHash[regexStr] = patterns.length;
          patterns[index] = regexStr;
        }
        return "pattern" + index;
      }
      function useDefault(value) {
        switch (typeof value) {
          case "boolean":
          case "number":
            return "" + value;
          case "string":
            return util2.toQuotedString(value);
          case "object":
            if (value === null)
              return "null";
            var valueStr = stableStringify(value);
            var index = defaultsHash[valueStr];
            if (index === void 0) {
              index = defaultsHash[valueStr] = defaults.length;
              defaults[index] = value;
            }
            return "default" + index;
        }
      }
      function useCustomRule(rule, schema2, parentSchema, it) {
        if (self2._opts.validateSchema !== false) {
          var deps = rule.definition.dependencies;
          if (deps && !deps.every(function(keyword2) {
            return Object.prototype.hasOwnProperty.call(parentSchema, keyword2);
          }))
            throw new Error("parent schema must have all required keywords: " + deps.join(","));
          var validateSchema = rule.definition.validateSchema;
          if (validateSchema) {
            var valid = validateSchema(schema2);
            if (!valid) {
              var message = "keyword schema is invalid: " + self2.errorsText(validateSchema.errors);
              if (self2._opts.validateSchema == "log")
                self2.logger.error(message);
              else
                throw new Error(message);
            }
          }
        }
        var compile2 = rule.definition.compile, inline = rule.definition.inline, macro = rule.definition.macro;
        var validate3;
        if (compile2) {
          validate3 = compile2.call(self2, schema2, parentSchema, it);
        } else if (macro) {
          validate3 = macro.call(self2, schema2, parentSchema, it);
          if (opts.validateSchema !== false)
            self2.validateSchema(validate3, true);
        } else if (inline) {
          validate3 = inline.call(self2, it, rule.keyword, schema2, parentSchema);
        } else {
          validate3 = rule.definition.validate;
          if (!validate3)
            return;
        }
        if (validate3 === void 0)
          throw new Error('custom keyword "' + rule.keyword + '"failed to compile');
        var index = customRules.length;
        customRules[index] = validate3;
        return {
          code: "customRule" + index,
          validate: validate3
        };
      }
    }
    function checkCompiling(schema, root, baseId) {
      var index = compIndex.call(this, schema, root, baseId);
      if (index >= 0)
        return { index, compiling: true };
      index = this._compilations.length;
      this._compilations[index] = {
        schema,
        root,
        baseId
      };
      return { index, compiling: false };
    }
    function endCompiling(schema, root, baseId) {
      var i2 = compIndex.call(this, schema, root, baseId);
      if (i2 >= 0)
        this._compilations.splice(i2, 1);
    }
    function compIndex(schema, root, baseId) {
      for (var i2 = 0; i2 < this._compilations.length; i2++) {
        var c2 = this._compilations[i2];
        if (c2.schema == schema && c2.root == root && c2.baseId == baseId)
          return i2;
      }
      return -1;
    }
    function patternCode(i2, patterns) {
      return "var pattern" + i2 + " = new RegExp(" + util2.toQuotedString(patterns[i2]) + ");";
    }
    function defaultCode(i2) {
      return "var default" + i2 + " = defaults[" + i2 + "];";
    }
    function refValCode(i2, refVal) {
      return refVal[i2] === void 0 ? "" : "var refVal" + i2 + " = refVal[" + i2 + "];";
    }
    function customRuleCode(i2) {
      return "var customRule" + i2 + " = customRules[" + i2 + "];";
    }
    function vars(arr, statement) {
      if (!arr.length)
        return "";
      var code = "";
      for (var i2 = 0; i2 < arr.length; i2++)
        code += statement(i2, arr);
      return code;
    }
    return compile_1;
  }
  var cache = { exports: {} };
  var hasRequiredCache;
  function requireCache() {
    if (hasRequiredCache)
      return cache.exports;
    hasRequiredCache = 1;
    var Cache = cache.exports = function Cache2() {
      this._cache = {};
    };
    Cache.prototype.put = function Cache_put(key2, value) {
      this._cache[key2] = value;
    };
    Cache.prototype.get = function Cache_get(key2) {
      return this._cache[key2];
    };
    Cache.prototype.del = function Cache_del(key2) {
      delete this._cache[key2];
    };
    Cache.prototype.clear = function Cache_clear() {
      this._cache = {};
    };
    return cache.exports;
  }
  var formats_1;
  var hasRequiredFormats;
  function requireFormats() {
    if (hasRequiredFormats)
      return formats_1;
    hasRequiredFormats = 1;
    var util2 = requireUtil();
    var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
    var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
    var HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
    var URI = /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\?(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    var URIREF = /^(?:[a-z][a-z0-9+\-.]*:)?(?:\/?\/(?:(?:[a-z0-9\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\.[a-z0-9\-._~!$&'()*+,;=:]+)\]|(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)|(?:[a-z0-9\-._~!$&'"()*+,;=]|%[0-9a-f]{2})*)(?::\d*)?(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*|\/(?:(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})+(?:\/(?:[a-z0-9\-._~!$&'"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\?(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\-._~!$&'"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i;
    var URITEMPLATE = /^(?:(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2})|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
    var URL = /^(?:(?:http[s\u017F]?|ftp):\/\/)(?:(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+(?::(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?@)?(?:(?!10(?:\.[0-9]{1,3}){3})(?!127(?:\.[0-9]{1,3}){3})(?!169\.254(?:\.[0-9]{1,3}){2})(?!192\.168(?:\.[0-9]{1,3}){2})(?!172\.(?:1[6-9]|2[0-9]|3[01])(?:\.[0-9]{1,3}){2})(?:[1-9][0-9]?|1[0-9][0-9]|2[01][0-9]|22[0-3])(?:\.(?:1?[0-9]{1,2}|2[0-4][0-9]|25[0-5])){2}(?:\.(?:[1-9][0-9]?|1[0-9][0-9]|2[0-4][0-9]|25[0-4]))|(?:(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)(?:\.(?:(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+-)*(?:[0-9a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])+)*(?:\.(?:(?:[a-z\xA1-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]){2,})))(?::[0-9]{2,5})?(?:\/(?:[\0-\x08\x0E-\x1F!-\x9F\xA1-\u167F\u1681-\u1FFF\u200B-\u2027\u202A-\u202E\u2030-\u205E\u2060-\u2FFF\u3001-\uD7FF\uE000-\uFEFE\uFF00-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])*)?$/i;
    var UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
    var JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
    var JSON_POINTER_URI_FRAGMENT = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
    var RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
    formats_1 = formats2;
    function formats2(mode) {
      mode = mode == "full" ? "full" : "fast";
      return util2.copy(formats2[mode]);
    }
    formats2.fast = {
      // date: http://tools.ietf.org/html/rfc3339#section-5.6
      date: /^\d\d\d\d-[0-1]\d-[0-3]\d$/,
      // date-time: http://tools.ietf.org/html/rfc3339#section-5.6
      time: /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)?$/i,
      "date-time": /^\d\d\d\d-[0-1]\d-[0-3]\d[t\s](?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i,
      // uri: https://github.com/mafintosh/is-my-json-valid/blob/master/formats.js
      uri: /^(?:[a-z][a-z0-9+\-.]*:)(?:\/?\/)?[^\s]*$/i,
      "uri-reference": /^(?:(?:[a-z][a-z0-9+\-.]*:)?\/?\/)?(?:[^\\\s#][^\s#]*)?(?:#[^\\\s]*)?$/i,
      "uri-template": URITEMPLATE,
      url: URL,
      // email (sources from jsen validator):
      // http://stackoverflow.com/questions/201323/using-a-regular-expression-to-validate-an-email-address#answer-8829363
      // http://www.w3.org/TR/html5/forms.html#valid-e-mail-address (search for 'willful violation')
      email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i,
      hostname: HOSTNAME,
      // optimized https://www.safaribooksonline.com/library/view/regular-expressions-cookbook/9780596802837/ch07s16.html
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
      // optimized http://stackoverflow.com/questions/53497/regular-expression-that-matches-valid-ipv6-addresses
      ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i,
      regex,
      // uuid: http://tools.ietf.org/html/rfc4122
      uuid: UUID,
      // JSON-pointer: https://tools.ietf.org/html/rfc6901
      // uri fragment: https://tools.ietf.org/html/rfc3986#appendix-A
      "json-pointer": JSON_POINTER,
      "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT,
      // relative JSON-pointer: http://tools.ietf.org/html/draft-luff-relative-json-pointer-00
      "relative-json-pointer": RELATIVE_JSON_POINTER
    };
    formats2.full = {
      date,
      time,
      "date-time": date_time,
      uri,
      "uri-reference": URIREF,
      "uri-template": URITEMPLATE,
      url: URL,
      email: /^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i,
      hostname: HOSTNAME,
      ipv4: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)$/,
      ipv6: /^\s*(?:(?:(?:[0-9a-f]{1,4}:){7}(?:[0-9a-f]{1,4}|:))|(?:(?:[0-9a-f]{1,4}:){6}(?::[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){5}(?:(?:(?::[0-9a-f]{1,4}){1,2})|:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(?:(?:[0-9a-f]{1,4}:){4}(?:(?:(?::[0-9a-f]{1,4}){1,3})|(?:(?::[0-9a-f]{1,4})?:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){3}(?:(?:(?::[0-9a-f]{1,4}){1,4})|(?:(?::[0-9a-f]{1,4}){0,2}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){2}(?:(?:(?::[0-9a-f]{1,4}){1,5})|(?:(?::[0-9a-f]{1,4}){0,3}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?:(?:[0-9a-f]{1,4}:){1}(?:(?:(?::[0-9a-f]{1,4}){1,6})|(?:(?::[0-9a-f]{1,4}){0,4}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(?::(?:(?:(?::[0-9a-f]{1,4}){1,7})|(?:(?::[0-9a-f]{1,4}){0,5}:(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(?:%.+)?\s*$/i,
      regex,
      uuid: UUID,
      "json-pointer": JSON_POINTER,
      "json-pointer-uri-fragment": JSON_POINTER_URI_FRAGMENT,
      "relative-json-pointer": RELATIVE_JSON_POINTER
    };
    function isLeapYear(year) {
      return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
    }
    function date(str) {
      var matches = str.match(DATE);
      if (!matches)
        return false;
      var year = +matches[1];
      var month = +matches[2];
      var day = +matches[3];
      return month >= 1 && month <= 12 && day >= 1 && day <= (month == 2 && isLeapYear(year) ? 29 : DAYS[month]);
    }
    function time(str, full) {
      var matches = str.match(TIME);
      if (!matches)
        return false;
      var hour = matches[1];
      var minute = matches[2];
      var second = matches[3];
      var timeZone = matches[5];
      return (hour <= 23 && minute <= 59 && second <= 59 || hour == 23 && minute == 59 && second == 60) && (!full || timeZone);
    }
    var DATE_TIME_SEPARATOR = /t|\s/i;
    function date_time(str) {
      var dateTime = str.split(DATE_TIME_SEPARATOR);
      return dateTime.length == 2 && date(dateTime[0]) && time(dateTime[1], true);
    }
    var NOT_URI_FRAGMENT = /\/|:/;
    function uri(str) {
      return NOT_URI_FRAGMENT.test(str) && URI.test(str);
    }
    var Z_ANCHOR = /[^\\]\\Z/;
    function regex(str) {
      if (Z_ANCHOR.test(str))
        return false;
      try {
        new RegExp(str);
        return true;
      } catch (e) {
        return false;
      }
    }
    return formats_1;
  }
  var ref;
  var hasRequiredRef;
  function requireRef() {
    if (hasRequiredRef)
      return ref;
    hasRequiredRef = 1;
    ref = function generate_ref(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $async, $refCode;
      if ($schema2 == "#" || $schema2 == "#/") {
        if (it.isRoot) {
          $async = it.async;
          $refCode = "validate";
        } else {
          $async = it.root.schema.$async === true;
          $refCode = "root.refVal[0]";
        }
      } else {
        var $refVal = it.resolveRef(it.baseId, $schema2, it.isRoot);
        if ($refVal === void 0) {
          var $message = it.MissingRefError.message(it.baseId, $schema2);
          if (it.opts.missingRefs == "fail") {
            it.logger.error($message);
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: '$ref' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { ref: '" + it.util.escapeQuotes($schema2) + "' } ";
              if (it.opts.messages !== false) {
                out += " , message: 'can\\'t resolve reference " + it.util.escapeQuotes($schema2) + "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: " + it.util.toQuotedString($schema2) + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            if ($breakOnError) {
              out += " if (false) { ";
            }
          } else if (it.opts.missingRefs == "ignore") {
            it.logger.warn($message);
            if ($breakOnError) {
              out += " if (true) { ";
            }
          } else {
            throw new it.MissingRefError(it.baseId, $schema2, $message);
          }
        } else if ($refVal.inline) {
          var $it = it.util.copy(it);
          $it.level++;
          var $nextValid = "valid" + $it.level;
          $it.schema = $refVal.schema;
          $it.schemaPath = "";
          $it.errSchemaPath = $schema2;
          var $code = it.validate($it).replace(/validate\.schema/g, $refVal.code);
          out += " " + $code + " ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
          }
        } else {
          $async = $refVal.$async === true || it.async && $refVal.$async !== false;
          $refCode = $refVal.code;
        }
      }
      if ($refCode) {
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it.opts.passContext) {
          out += " " + $refCode + ".call(this, ";
        } else {
          out += " " + $refCode + "( ";
        }
        out += " " + $data + ", (dataPath || '')";
        if (it.errorPath != '""') {
          out += " + " + it.errorPath;
        }
        var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty";
        out += " , " + $parentData + " , " + $parentDataProperty + ", rootData)  ";
        var __callValidate = out;
        out = $$outStack.pop();
        if ($async) {
          if (!it.async)
            throw new Error("async schema referenced by sync schema");
          if ($breakOnError) {
            out += " var " + $valid + "; ";
          }
          out += " try { await " + __callValidate + "; ";
          if ($breakOnError) {
            out += " " + $valid + " = true; ";
          }
          out += " } catch (e) { if (!(e instanceof ValidationError)) throw e; if (vErrors === null) vErrors = e.errors; else vErrors = vErrors.concat(e.errors); errors = vErrors.length; ";
          if ($breakOnError) {
            out += " " + $valid + " = false; ";
          }
          out += " } ";
          if ($breakOnError) {
            out += " if (" + $valid + ") { ";
          }
        } else {
          out += " if (!" + __callValidate + ") { if (vErrors === null) vErrors = " + $refCode + ".errors; else vErrors = vErrors.concat(" + $refCode + ".errors); errors = vErrors.length; } ";
          if ($breakOnError) {
            out += " else { ";
          }
        }
      }
      return out;
    };
    return ref;
  }
  var allOf;
  var hasRequiredAllOf;
  function requireAllOf() {
    if (hasRequiredAllOf)
      return allOf;
    hasRequiredAllOf = 1;
    allOf = function generate_allOf(it, $keyword, $ruleType) {
      var out = " ";
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $currentBaseId = $it.baseId, $allSchemasEmpty = true;
      var arr1 = $schema2;
      if (arr1) {
        var $sch, $i = -1, l1 = arr1.length - 1;
        while ($i < l1) {
          $sch = arr1[$i += 1];
          if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
            $allSchemasEmpty = false;
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it.validate($it) + " ";
            $it.baseId = $currentBaseId;
            if ($breakOnError) {
              out += " if (" + $nextValid + ") { ";
              $closingBraces += "}";
            }
          }
        }
      }
      if ($breakOnError) {
        if ($allSchemasEmpty) {
          out += " if (true) { ";
        } else {
          out += " " + $closingBraces.slice(0, -1) + " ";
        }
      }
      return out;
    };
    return allOf;
  }
  var anyOf;
  var hasRequiredAnyOf;
  function requireAnyOf() {
    if (hasRequiredAnyOf)
      return anyOf;
    hasRequiredAnyOf = 1;
    anyOf = function generate_anyOf(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $noEmptySchema = $schema2.every(function($sch2) {
        return it.opts.strictKeywords ? typeof $sch2 == "object" && Object.keys($sch2).length > 0 || $sch2 === false : it.util.schemaHasRules($sch2, it.RULES.all);
      });
      if ($noEmptySchema) {
        var $currentBaseId = $it.baseId;
        out += " var " + $errs + " = errors; var " + $valid + " = false;  ";
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        var arr1 = $schema2;
        if (arr1) {
          var $sch, $i = -1, l1 = arr1.length - 1;
          while ($i < l1) {
            $sch = arr1[$i += 1];
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it.validate($it) + " ";
            $it.baseId = $currentBaseId;
            out += " " + $valid + " = " + $valid + " || " + $nextValid + "; if (!" + $valid + ") { ";
            $closingBraces += "}";
          }
        }
        it.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $closingBraces + " if (!" + $valid + ") {   var err =   ";
        if (it.createErrors !== false) {
          out += " { keyword: 'anyOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it.opts.messages !== false) {
            out += " , message: 'should match some schema in anyOf' ";
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        out += " } else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
        if (it.opts.allErrors) {
          out += " } ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    };
    return anyOf;
  }
  var comment;
  var hasRequiredComment;
  function requireComment() {
    if (hasRequiredComment)
      return comment;
    hasRequiredComment = 1;
    comment = function generate_comment(it, $keyword, $ruleType) {
      var out = " ";
      var $schema2 = it.schema[$keyword];
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      !it.opts.allErrors;
      var $comment = it.util.toQuotedString($schema2);
      if (it.opts.$comment === true) {
        out += " console.log(" + $comment + ");";
      } else if (typeof it.opts.$comment == "function") {
        out += " self._opts.$comment(" + $comment + ", " + it.util.toQuotedString($errSchemaPath) + ", validate.root.schema);";
      }
      return out;
    };
    return comment;
  }
  var _const;
  var hasRequired_const;
  function require_const() {
    if (hasRequired_const)
      return _const;
    hasRequired_const = 1;
    _const = function generate_const(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it.opts.$data && $schema2 && $schema2.$data;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
      }
      if (!$isData) {
        out += " var schema" + $lvl + " = validate.schema" + $schemaPath + ";";
      }
      out += "var " + $valid + " = equal(" + $data + ", schema" + $lvl + "); if (!" + $valid + ") {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'const' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { allowedValue: schema" + $lvl + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should be equal to constant' ";
        }
        if (it.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " }";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _const;
  }
  var contains;
  var hasRequiredContains;
  function requireContains() {
    if (hasRequiredContains)
      return contains;
    hasRequiredContains = 1;
    contains = function generate_contains(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it.baseId, $nonEmptySchema = it.opts.strictKeywords ? typeof $schema2 == "object" && Object.keys($schema2).length > 0 || $schema2 === false : it.util.schemaHasRules($schema2, it.RULES.all);
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if ($nonEmptySchema) {
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        $it.schema = $schema2;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $nextValid + " = false; for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
        $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);
        var $passData = $data + "[" + $idx + "]";
        $it.dataPathArr[$dataNxt] = $idx;
        var $code = it.validate($it);
        $it.baseId = $currentBaseId;
        if (it.util.varOccurences($code, $nextData) < 2) {
          out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        out += " if (" + $nextValid + ") break; }  ";
        it.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $closingBraces + " if (!" + $nextValid + ") {";
      } else {
        out += " if (" + $data + ".length == 0) {";
      }
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'contains' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
        if (it.opts.messages !== false) {
          out += " , message: 'should contain a valid item' ";
        }
        if (it.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } else { ";
      if ($nonEmptySchema) {
        out += "  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
      }
      if (it.opts.allErrors) {
        out += " } ";
      }
      return out;
    };
    return contains;
  }
  var dependencies;
  var hasRequiredDependencies;
  function requireDependencies() {
    if (hasRequiredDependencies)
      return dependencies;
    hasRequiredDependencies = 1;
    dependencies = function generate_dependencies(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $schemaDeps = {}, $propertyDeps = {}, $ownProperties = it.opts.ownProperties;
      for ($property in $schema2) {
        if ($property == "__proto__")
          continue;
        var $sch = $schema2[$property];
        var $deps = Array.isArray($sch) ? $propertyDeps : $schemaDeps;
        $deps[$property] = $sch;
      }
      out += "var " + $errs + " = errors;";
      var $currentErrorPath = it.errorPath;
      out += "var missing" + $lvl + ";";
      for (var $property in $propertyDeps) {
        $deps = $propertyDeps[$property];
        if ($deps.length) {
          out += " if ( " + $data + it.util.getProperty($property) + " !== undefined ";
          if ($ownProperties) {
            out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($property) + "') ";
          }
          if ($breakOnError) {
            out += " && ( ";
            var arr1 = $deps;
            if (arr1) {
              var $propertyKey, $i = -1, l1 = arr1.length - 1;
              while ($i < l1) {
                $propertyKey = arr1[$i += 1];
                if ($i) {
                  out += " || ";
                }
                var $prop = it.util.getProperty($propertyKey), $useData = $data + $prop;
                out += " ( ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") && (missing" + $lvl + " = " + it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
              }
            }
            out += ")) {  ";
            var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
            if (it.opts._errorDataPathProperty) {
              it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
            }
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
              if (it.opts.messages !== false) {
                out += " , message: 'should have ";
                if ($deps.length == 1) {
                  out += "property " + it.util.escapeQuotes($deps[0]);
                } else {
                  out += "properties " + it.util.escapeQuotes($deps.join(", "));
                }
                out += " when property " + it.util.escapeQuotes($property) + " is present' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
          } else {
            out += " ) { ";
            var arr2 = $deps;
            if (arr2) {
              var $propertyKey, i2 = -1, l2 = arr2.length - 1;
              while (i2 < l2) {
                $propertyKey = arr2[i2 += 1];
                var $prop = it.util.getProperty($propertyKey), $missingProperty = it.util.escapeQuotes($propertyKey), $useData = $data + $prop;
                if (it.opts._errorDataPathProperty) {
                  it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);
                }
                out += " if ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") {  var err =   ";
                if (it.createErrors !== false) {
                  out += " { keyword: 'dependencies' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { property: '" + it.util.escapeQuotes($property) + "', missingProperty: '" + $missingProperty + "', depsCount: " + $deps.length + ", deps: '" + it.util.escapeQuotes($deps.length == 1 ? $deps[0] : $deps.join(", ")) + "' } ";
                  if (it.opts.messages !== false) {
                    out += " , message: 'should have ";
                    if ($deps.length == 1) {
                      out += "property " + it.util.escapeQuotes($deps[0]);
                    } else {
                      out += "properties " + it.util.escapeQuotes($deps.join(", "));
                    }
                    out += " when property " + it.util.escapeQuotes($property) + " is present' ";
                  }
                  if (it.opts.verbose) {
                    out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                  }
                  out += " } ";
                } else {
                  out += " {} ";
                }
                out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
              }
            }
          }
          out += " }   ";
          if ($breakOnError) {
            $closingBraces += "}";
            out += " else { ";
          }
        }
      }
      it.errorPath = $currentErrorPath;
      var $currentBaseId = $it.baseId;
      for (var $property in $schemaDeps) {
        var $sch = $schemaDeps[$property];
        if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
          out += " " + $nextValid + " = true; if ( " + $data + it.util.getProperty($property) + " !== undefined ";
          if ($ownProperties) {
            out += " && Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($property) + "') ";
          }
          out += ") { ";
          $it.schema = $sch;
          $it.schemaPath = $schemaPath + it.util.getProperty($property);
          $it.errSchemaPath = $errSchemaPath + "/" + it.util.escapeFragment($property);
          out += "  " + it.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " }  ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
            $closingBraces += "}";
          }
        }
      }
      if ($breakOnError) {
        out += "   " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    };
    return dependencies;
  }
  var _enum;
  var hasRequired_enum;
  function require_enum() {
    if (hasRequired_enum)
      return _enum;
    hasRequired_enum = 1;
    _enum = function generate_enum(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it.opts.$data && $schema2 && $schema2.$data;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
      }
      var $i = "i" + $lvl, $vSchema = "schema" + $lvl;
      if (!$isData) {
        out += " var " + $vSchema + " = validate.schema" + $schemaPath + ";";
      }
      out += "var " + $valid + ";";
      if ($isData) {
        out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {";
      }
      out += "" + $valid + " = false;for (var " + $i + "=0; " + $i + "<" + $vSchema + ".length; " + $i + "++) if (equal(" + $data + ", " + $vSchema + "[" + $i + "])) { " + $valid + " = true; break; }";
      if ($isData) {
        out += "  }  ";
      }
      out += " if (!" + $valid + ") {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'enum' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { allowedValues: schema" + $lvl + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should be equal to one of the allowed values' ";
        }
        if (it.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " }";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _enum;
  }
  var format;
  var hasRequiredFormat;
  function requireFormat() {
    if (hasRequiredFormat)
      return format;
    hasRequiredFormat = 1;
    format = function generate_format(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      if (it.opts.format === false) {
        if ($breakOnError) {
          out += " if (true) { ";
        }
        return out;
      }
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      var $unknownFormats = it.opts.unknownFormats, $allowUnknown = Array.isArray($unknownFormats);
      if ($isData) {
        var $format = "format" + $lvl, $isObject = "isObject" + $lvl, $formatType = "formatType" + $lvl;
        out += " var " + $format + " = formats[" + $schemaValue + "]; var " + $isObject + " = typeof " + $format + " == 'object' && !(" + $format + " instanceof RegExp) && " + $format + ".validate; var " + $formatType + " = " + $isObject + " && " + $format + ".type || 'string'; if (" + $isObject + ") { ";
        if (it.async) {
          out += " var async" + $lvl + " = " + $format + ".async; ";
        }
        out += " " + $format + " = " + $format + ".validate; } if (  ";
        if ($isData) {
          out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || ";
        }
        out += " (";
        if ($unknownFormats != "ignore") {
          out += " (" + $schemaValue + " && !" + $format + " ";
          if ($allowUnknown) {
            out += " && self._opts.unknownFormats.indexOf(" + $schemaValue + ") == -1 ";
          }
          out += ") || ";
        }
        out += " (" + $format + " && " + $formatType + " == '" + $ruleType + "' && !(typeof " + $format + " == 'function' ? ";
        if (it.async) {
          out += " (async" + $lvl + " ? await " + $format + "(" + $data + ") : " + $format + "(" + $data + ")) ";
        } else {
          out += " " + $format + "(" + $data + ") ";
        }
        out += " : " + $format + ".test(" + $data + "))))) {";
      } else {
        var $format = it.formats[$schema2];
        if (!$format) {
          if ($unknownFormats == "ignore") {
            it.logger.warn('unknown format "' + $schema2 + '" ignored in schema at path "' + it.errSchemaPath + '"');
            if ($breakOnError) {
              out += " if (true) { ";
            }
            return out;
          } else if ($allowUnknown && $unknownFormats.indexOf($schema2) >= 0) {
            if ($breakOnError) {
              out += " if (true) { ";
            }
            return out;
          } else {
            throw new Error('unknown format "' + $schema2 + '" is used in schema at path "' + it.errSchemaPath + '"');
          }
        }
        var $isObject = typeof $format == "object" && !($format instanceof RegExp) && $format.validate;
        var $formatType = $isObject && $format.type || "string";
        if ($isObject) {
          var $async = $format.async === true;
          $format = $format.validate;
        }
        if ($formatType != $ruleType) {
          if ($breakOnError) {
            out += " if (true) { ";
          }
          return out;
        }
        if ($async) {
          if (!it.async)
            throw new Error("async format in sync schema");
          var $formatRef = "formats" + it.util.getProperty($schema2) + ".validate";
          out += " if (!(await " + $formatRef + "(" + $data + "))) { ";
        } else {
          out += " if (! ";
          var $formatRef = "formats" + it.util.getProperty($schema2);
          if ($isObject)
            $formatRef += ".validate";
          if (typeof $format == "function") {
            out += " " + $formatRef + "(" + $data + ") ";
          } else {
            out += " " + $formatRef + ".test(" + $data + ") ";
          }
          out += ") { ";
        }
      }
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'format' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { format:  ";
        if ($isData) {
          out += "" + $schemaValue;
        } else {
          out += "" + it.util.toQuotedString($schema2);
        }
        out += "  } ";
        if (it.opts.messages !== false) {
          out += ` , message: 'should match format "`;
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + it.util.escapeQuotes($schema2);
          }
          out += `"' `;
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + it.util.toQuotedString($schema2);
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return format;
  }
  var _if;
  var hasRequired_if;
  function require_if() {
    if (hasRequired_if)
      return _if;
    hasRequired_if = 1;
    _if = function generate_if(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $thenSch = it.schema["then"], $elseSch = it.schema["else"], $thenPresent = $thenSch !== void 0 && (it.opts.strictKeywords ? typeof $thenSch == "object" && Object.keys($thenSch).length > 0 || $thenSch === false : it.util.schemaHasRules($thenSch, it.RULES.all)), $elsePresent = $elseSch !== void 0 && (it.opts.strictKeywords ? typeof $elseSch == "object" && Object.keys($elseSch).length > 0 || $elseSch === false : it.util.schemaHasRules($elseSch, it.RULES.all)), $currentBaseId = $it.baseId;
      if ($thenPresent || $elsePresent) {
        var $ifClause;
        $it.createErrors = false;
        $it.schema = $schema2;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $errs + " = errors; var " + $valid + " = true;  ";
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        out += "  " + it.validate($it) + " ";
        $it.baseId = $currentBaseId;
        $it.createErrors = true;
        out += "  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; }  ";
        it.compositeRule = $it.compositeRule = $wasComposite;
        if ($thenPresent) {
          out += " if (" + $nextValid + ") {  ";
          $it.schema = it.schema["then"];
          $it.schemaPath = it.schemaPath + ".then";
          $it.errSchemaPath = it.errSchemaPath + "/then";
          out += "  " + it.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " " + $valid + " = " + $nextValid + "; ";
          if ($thenPresent && $elsePresent) {
            $ifClause = "ifClause" + $lvl;
            out += " var " + $ifClause + " = 'then'; ";
          } else {
            $ifClause = "'then'";
          }
          out += " } ";
          if ($elsePresent) {
            out += " else { ";
          }
        } else {
          out += " if (!" + $nextValid + ") { ";
        }
        if ($elsePresent) {
          $it.schema = it.schema["else"];
          $it.schemaPath = it.schemaPath + ".else";
          $it.errSchemaPath = it.errSchemaPath + "/else";
          out += "  " + it.validate($it) + " ";
          $it.baseId = $currentBaseId;
          out += " " + $valid + " = " + $nextValid + "; ";
          if ($thenPresent && $elsePresent) {
            $ifClause = "ifClause" + $lvl;
            out += " var " + $ifClause + " = 'else'; ";
          } else {
            $ifClause = "'else'";
          }
          out += " } ";
        }
        out += " if (!" + $valid + ") {   var err =   ";
        if (it.createErrors !== false) {
          out += " { keyword: 'if' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { failingKeyword: " + $ifClause + " } ";
          if (it.opts.messages !== false) {
            out += ` , message: 'should match "' + ` + $ifClause + ` + '" schema' `;
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        out += " }   ";
        if ($breakOnError) {
          out += " else { ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    };
    return _if;
  }
  var items;
  var hasRequiredItems;
  function requireItems() {
    if (hasRequiredItems)
      return items;
    hasRequiredItems = 1;
    items = function generate_items(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $idx = "i" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $currentBaseId = it.baseId;
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if (Array.isArray($schema2)) {
        var $additionalItems = it.schema.additionalItems;
        if ($additionalItems === false) {
          out += " " + $valid + " = " + $data + ".length <= " + $schema2.length + "; ";
          var $currErrSchemaPath = $errSchemaPath;
          $errSchemaPath = it.errSchemaPath + "/additionalItems";
          out += "  if (!" + $valid + ") {   ";
          var $$outStack = $$outStack || [];
          $$outStack.push(out);
          out = "";
          if (it.createErrors !== false) {
            out += " { keyword: 'additionalItems' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schema2.length + " } ";
            if (it.opts.messages !== false) {
              out += " , message: 'should NOT have more than " + $schema2.length + " items' ";
            }
            if (it.opts.verbose) {
              out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          var __err = out;
          out = $$outStack.pop();
          if (!it.compositeRule && $breakOnError) {
            if (it.async) {
              out += " throw new ValidationError([" + __err + "]); ";
            } else {
              out += " validate.errors = [" + __err + "]; return false; ";
            }
          } else {
            out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          }
          out += " } ";
          $errSchemaPath = $currErrSchemaPath;
          if ($breakOnError) {
            $closingBraces += "}";
            out += " else { ";
          }
        }
        var arr1 = $schema2;
        if (arr1) {
          var $sch, $i = -1, l1 = arr1.length - 1;
          while ($i < l1) {
            $sch = arr1[$i += 1];
            if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
              out += " " + $nextValid + " = true; if (" + $data + ".length > " + $i + ") { ";
              var $passData = $data + "[" + $i + "]";
              $it.schema = $sch;
              $it.schemaPath = $schemaPath + "[" + $i + "]";
              $it.errSchemaPath = $errSchemaPath + "/" + $i;
              $it.errorPath = it.util.getPathExpr(it.errorPath, $i, it.opts.jsonPointers, true);
              $it.dataPathArr[$dataNxt] = $i;
              var $code = it.validate($it);
              $it.baseId = $currentBaseId;
              if (it.util.varOccurences($code, $nextData) < 2) {
                out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              out += " }  ";
              if ($breakOnError) {
                out += " if (" + $nextValid + ") { ";
                $closingBraces += "}";
              }
            }
          }
        }
        if (typeof $additionalItems == "object" && (it.opts.strictKeywords ? typeof $additionalItems == "object" && Object.keys($additionalItems).length > 0 || $additionalItems === false : it.util.schemaHasRules($additionalItems, it.RULES.all))) {
          $it.schema = $additionalItems;
          $it.schemaPath = it.schemaPath + ".additionalItems";
          $it.errSchemaPath = it.errSchemaPath + "/additionalItems";
          out += " " + $nextValid + " = true; if (" + $data + ".length > " + $schema2.length + ") {  for (var " + $idx + " = " + $schema2.length + "; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
          $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);
          var $passData = $data + "[" + $idx + "]";
          $it.dataPathArr[$dataNxt] = $idx;
          var $code = it.validate($it);
          $it.baseId = $currentBaseId;
          if (it.util.varOccurences($code, $nextData) < 2) {
            out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
          } else {
            out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
          }
          if ($breakOnError) {
            out += " if (!" + $nextValid + ") break; ";
          }
          out += " } }  ";
          if ($breakOnError) {
            out += " if (" + $nextValid + ") { ";
            $closingBraces += "}";
          }
        }
      } else if (it.opts.strictKeywords ? typeof $schema2 == "object" && Object.keys($schema2).length > 0 || $schema2 === false : it.util.schemaHasRules($schema2, it.RULES.all)) {
        $it.schema = $schema2;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += "  for (var " + $idx + " = 0; " + $idx + " < " + $data + ".length; " + $idx + "++) { ";
        $it.errorPath = it.util.getPathExpr(it.errorPath, $idx, it.opts.jsonPointers, true);
        var $passData = $data + "[" + $idx + "]";
        $it.dataPathArr[$dataNxt] = $idx;
        var $code = it.validate($it);
        $it.baseId = $currentBaseId;
        if (it.util.varOccurences($code, $nextData) < 2) {
          out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        if ($breakOnError) {
          out += " if (!" + $nextValid + ") break; ";
        }
        out += " }";
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    };
    return items;
  }
  var _limit;
  var hasRequired_limit;
  function require_limit() {
    if (hasRequired_limit)
      return _limit;
    hasRequired_limit = 1;
    _limit = function generate__limit(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      var $isMax = $keyword == "maximum", $exclusiveKeyword = $isMax ? "exclusiveMaximum" : "exclusiveMinimum", $schemaExcl = it.schema[$exclusiveKeyword], $isDataExcl = it.opts.$data && $schemaExcl && $schemaExcl.$data, $op = $isMax ? "<" : ">", $notOp = $isMax ? ">" : "<", $errorKeyword = void 0;
      if (!($isData || typeof $schema2 == "number" || $schema2 === void 0)) {
        throw new Error($keyword + " must be number");
      }
      if (!($isDataExcl || $schemaExcl === void 0 || typeof $schemaExcl == "number" || typeof $schemaExcl == "boolean")) {
        throw new Error($exclusiveKeyword + " must be number or boolean");
      }
      if ($isDataExcl) {
        var $schemaValueExcl = it.util.getData($schemaExcl.$data, $dataLvl, it.dataPathArr), $exclusive = "exclusive" + $lvl, $exclType = "exclType" + $lvl, $exclIsNumber = "exclIsNumber" + $lvl, $opExpr = "op" + $lvl, $opStr = "' + " + $opExpr + " + '";
        out += " var schemaExcl" + $lvl + " = " + $schemaValueExcl + "; ";
        $schemaValueExcl = "schemaExcl" + $lvl;
        out += " var " + $exclusive + "; var " + $exclType + " = typeof " + $schemaValueExcl + "; if (" + $exclType + " != 'boolean' && " + $exclType + " != 'undefined' && " + $exclType + " != 'number') { ";
        var $errorKeyword = $exclusiveKeyword;
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it.createErrors !== false) {
          out += " { keyword: '" + ($errorKeyword || "_exclusiveLimit") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it.opts.messages !== false) {
            out += " , message: '" + $exclusiveKeyword + " should be boolean' ";
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } else if ( ";
        if ($isData) {
          out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
        }
        out += " " + $exclType + " == 'number' ? ( (" + $exclusive + " = " + $schemaValue + " === undefined || " + $schemaValueExcl + " " + $op + "= " + $schemaValue + ") ? " + $data + " " + $notOp + "= " + $schemaValueExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) : ( (" + $exclusive + " = " + $schemaValueExcl + " === true) ? " + $data + " " + $notOp + "= " + $schemaValue + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { var op" + $lvl + " = " + $exclusive + " ? '" + $op + "' : '" + $op + "='; ";
        if ($schema2 === void 0) {
          $errorKeyword = $exclusiveKeyword;
          $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword;
          $schemaValue = $schemaValueExcl;
          $isData = $isDataExcl;
        }
      } else {
        var $exclIsNumber = typeof $schemaExcl == "number", $opStr = $op;
        if ($exclIsNumber && $isData) {
          var $opExpr = "'" + $opStr + "'";
          out += " if ( ";
          if ($isData) {
            out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
          }
          out += " ( " + $schemaValue + " === undefined || " + $schemaExcl + " " + $op + "= " + $schemaValue + " ? " + $data + " " + $notOp + "= " + $schemaExcl + " : " + $data + " " + $notOp + " " + $schemaValue + " ) || " + $data + " !== " + $data + ") { ";
        } else {
          if ($exclIsNumber && $schema2 === void 0) {
            $exclusive = true;
            $errorKeyword = $exclusiveKeyword;
            $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword;
            $schemaValue = $schemaExcl;
            $notOp += "=";
          } else {
            if ($exclIsNumber)
              $schemaValue = Math[$isMax ? "min" : "max"]($schemaExcl, $schema2);
            if ($schemaExcl === ($exclIsNumber ? $schemaValue : true)) {
              $exclusive = true;
              $errorKeyword = $exclusiveKeyword;
              $errSchemaPath = it.errSchemaPath + "/" + $exclusiveKeyword;
              $notOp += "=";
            } else {
              $exclusive = false;
              $opStr += "=";
            }
          }
          var $opExpr = "'" + $opStr + "'";
          out += " if ( ";
          if ($isData) {
            out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
          }
          out += " " + $data + " " + $notOp + " " + $schemaValue + " || " + $data + " !== " + $data + ") { ";
        }
      }
      $errorKeyword = $errorKeyword || $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limit") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { comparison: " + $opExpr + ", limit: " + $schemaValue + ", exclusive: " + $exclusive + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should be " + $opStr + " ";
          if ($isData) {
            out += "' + " + $schemaValue;
          } else {
            out += "" + $schemaValue + "'";
          }
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema2;
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += " } ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _limit;
  }
  var _limitItems;
  var hasRequired_limitItems;
  function require_limitItems() {
    if (hasRequired_limitItems)
      return _limitItems;
    hasRequired_limitItems = 1;
    _limitItems = function generate__limitItems(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      if (!($isData || typeof $schema2 == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxItems" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      out += " " + $data + ".length " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitItems") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should NOT have ";
          if ($keyword == "maxItems") {
            out += "more";
          } else {
            out += "fewer";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema2;
          }
          out += " items' ";
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema2;
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _limitItems;
  }
  var _limitLength;
  var hasRequired_limitLength;
  function require_limitLength() {
    if (hasRequired_limitLength)
      return _limitLength;
    hasRequired_limitLength = 1;
    _limitLength = function generate__limitLength(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      if (!($isData || typeof $schema2 == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxLength" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      if (it.opts.unicode === false) {
        out += " " + $data + ".length ";
      } else {
        out += " ucs2length(" + $data + ") ";
      }
      out += " " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitLength") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should NOT be ";
          if ($keyword == "maxLength") {
            out += "longer";
          } else {
            out += "shorter";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema2;
          }
          out += " characters' ";
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema2;
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _limitLength;
  }
  var _limitProperties;
  var hasRequired_limitProperties;
  function require_limitProperties() {
    if (hasRequired_limitProperties)
      return _limitProperties;
    hasRequired_limitProperties = 1;
    _limitProperties = function generate__limitProperties(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      if (!($isData || typeof $schema2 == "number")) {
        throw new Error($keyword + " must be number");
      }
      var $op = $keyword == "maxProperties" ? ">" : "<";
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'number') || ";
      }
      out += " Object.keys(" + $data + ").length " + $op + " " + $schemaValue + ") { ";
      var $errorKeyword = $keyword;
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: '" + ($errorKeyword || "_limitProperties") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { limit: " + $schemaValue + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should NOT have ";
          if ($keyword == "maxProperties") {
            out += "more";
          } else {
            out += "fewer";
          }
          out += " than ";
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + $schema2;
          }
          out += " properties' ";
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema2;
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return _limitProperties;
  }
  var multipleOf;
  var hasRequiredMultipleOf;
  function requireMultipleOf() {
    if (hasRequiredMultipleOf)
      return multipleOf;
    hasRequiredMultipleOf = 1;
    multipleOf = function generate_multipleOf(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      if (!($isData || typeof $schema2 == "number")) {
        throw new Error($keyword + " must be number");
      }
      out += "var division" + $lvl + ";if (";
      if ($isData) {
        out += " " + $schemaValue + " !== undefined && ( typeof " + $schemaValue + " != 'number' || ";
      }
      out += " (division" + $lvl + " = " + $data + " / " + $schemaValue + ", ";
      if (it.opts.multipleOfPrecision) {
        out += " Math.abs(Math.round(division" + $lvl + ") - division" + $lvl + ") > 1e-" + it.opts.multipleOfPrecision + " ";
      } else {
        out += " division" + $lvl + " !== parseInt(division" + $lvl + ") ";
      }
      out += " ) ";
      if ($isData) {
        out += "  )  ";
      }
      out += " ) {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'multipleOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { multipleOf: " + $schemaValue + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should be multiple of ";
          if ($isData) {
            out += "' + " + $schemaValue;
          } else {
            out += "" + $schemaValue + "'";
          }
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + $schema2;
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return multipleOf;
  }
  var not;
  var hasRequiredNot;
  function requireNot() {
    if (hasRequiredNot)
      return not;
    hasRequiredNot = 1;
    not = function generate_not(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      $it.level++;
      var $nextValid = "valid" + $it.level;
      if (it.opts.strictKeywords ? typeof $schema2 == "object" && Object.keys($schema2).length > 0 || $schema2 === false : it.util.schemaHasRules($schema2, it.RULES.all)) {
        $it.schema = $schema2;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        out += " var " + $errs + " = errors;  ";
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        $it.createErrors = false;
        var $allErrorsOption;
        if ($it.opts.allErrors) {
          $allErrorsOption = $it.opts.allErrors;
          $it.opts.allErrors = false;
        }
        out += " " + it.validate($it) + " ";
        $it.createErrors = true;
        if ($allErrorsOption)
          $it.opts.allErrors = $allErrorsOption;
        it.compositeRule = $it.compositeRule = $wasComposite;
        out += " if (" + $nextValid + ") {   ";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it.createErrors !== false) {
          out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it.opts.messages !== false) {
            out += " , message: 'should NOT be valid' ";
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; } ";
        if (it.opts.allErrors) {
          out += " } ";
        }
      } else {
        out += "  var err =   ";
        if (it.createErrors !== false) {
          out += " { keyword: 'not' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: {} ";
          if (it.opts.messages !== false) {
            out += " , message: 'should NOT be valid' ";
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if ($breakOnError) {
          out += " if (false) { ";
        }
      }
      return out;
    };
    return not;
  }
  var oneOf;
  var hasRequiredOneOf;
  function requireOneOf() {
    if (hasRequiredOneOf)
      return oneOf;
    hasRequiredOneOf = 1;
    oneOf = function generate_oneOf(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $currentBaseId = $it.baseId, $prevValid = "prevValid" + $lvl, $passingSchemas = "passingSchemas" + $lvl;
      out += "var " + $errs + " = errors , " + $prevValid + " = false , " + $valid + " = false , " + $passingSchemas + " = null; ";
      var $wasComposite = it.compositeRule;
      it.compositeRule = $it.compositeRule = true;
      var arr1 = $schema2;
      if (arr1) {
        var $sch, $i = -1, l1 = arr1.length - 1;
        while ($i < l1) {
          $sch = arr1[$i += 1];
          if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
            $it.schema = $sch;
            $it.schemaPath = $schemaPath + "[" + $i + "]";
            $it.errSchemaPath = $errSchemaPath + "/" + $i;
            out += "  " + it.validate($it) + " ";
            $it.baseId = $currentBaseId;
          } else {
            out += " var " + $nextValid + " = true; ";
          }
          if ($i) {
            out += " if (" + $nextValid + " && " + $prevValid + ") { " + $valid + " = false; " + $passingSchemas + " = [" + $passingSchemas + ", " + $i + "]; } else { ";
            $closingBraces += "}";
          }
          out += " if (" + $nextValid + ") { " + $valid + " = " + $prevValid + " = true; " + $passingSchemas + " = " + $i + "; }";
        }
      }
      it.compositeRule = $it.compositeRule = $wasComposite;
      out += "" + $closingBraces + "if (!" + $valid + ") {   var err =   ";
      if (it.createErrors !== false) {
        out += " { keyword: 'oneOf' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { passingSchemas: " + $passingSchemas + " } ";
        if (it.opts.messages !== false) {
          out += " , message: 'should match exactly one schema in oneOf' ";
        }
        if (it.opts.verbose) {
          out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError(vErrors); ";
        } else {
          out += " validate.errors = vErrors; return false; ";
        }
      }
      out += "} else {  errors = " + $errs + "; if (vErrors !== null) { if (" + $errs + ") vErrors.length = " + $errs + "; else vErrors = null; }";
      if (it.opts.allErrors) {
        out += " } ";
      }
      return out;
    };
    return oneOf;
  }
  var pattern;
  var hasRequiredPattern;
  function requirePattern() {
    if (hasRequiredPattern)
      return pattern;
    hasRequiredPattern = 1;
    pattern = function generate_pattern(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      var $regexp = $isData ? "(new RegExp(" + $schemaValue + "))" : it.usePattern($schema2);
      out += "if ( ";
      if ($isData) {
        out += " (" + $schemaValue + " !== undefined && typeof " + $schemaValue + " != 'string') || ";
      }
      out += " !" + $regexp + ".test(" + $data + ") ) {   ";
      var $$outStack = $$outStack || [];
      $$outStack.push(out);
      out = "";
      if (it.createErrors !== false) {
        out += " { keyword: 'pattern' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { pattern:  ";
        if ($isData) {
          out += "" + $schemaValue;
        } else {
          out += "" + it.util.toQuotedString($schema2);
        }
        out += "  } ";
        if (it.opts.messages !== false) {
          out += ` , message: 'should match pattern "`;
          if ($isData) {
            out += "' + " + $schemaValue + " + '";
          } else {
            out += "" + it.util.escapeQuotes($schema2);
          }
          out += `"' `;
        }
        if (it.opts.verbose) {
          out += " , schema:  ";
          if ($isData) {
            out += "validate.schema" + $schemaPath;
          } else {
            out += "" + it.util.toQuotedString($schema2);
          }
          out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
        }
        out += " } ";
      } else {
        out += " {} ";
      }
      var __err = out;
      out = $$outStack.pop();
      if (!it.compositeRule && $breakOnError) {
        if (it.async) {
          out += " throw new ValidationError([" + __err + "]); ";
        } else {
          out += " validate.errors = [" + __err + "]; return false; ";
        }
      } else {
        out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
      }
      out += "} ";
      if ($breakOnError) {
        out += " else { ";
      }
      return out;
    };
    return pattern;
  }
  var properties$l;
  var hasRequiredProperties;
  function requireProperties() {
    if (hasRequiredProperties)
      return properties$l;
    hasRequiredProperties = 1;
    properties$l = function generate_properties(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      var $key = "key" + $lvl, $idx = "idx" + $lvl, $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl;
      var $schemaKeys = Object.keys($schema2 || {}).filter(notProto), $pProperties = it.schema.patternProperties || {}, $pPropertyKeys = Object.keys($pProperties).filter(notProto), $aProperties = it.schema.additionalProperties, $someProperties = $schemaKeys.length || $pPropertyKeys.length, $noAdditional = $aProperties === false, $additionalIsSchema = typeof $aProperties == "object" && Object.keys($aProperties).length, $removeAdditional = it.opts.removeAdditional, $checkAdditional = $noAdditional || $additionalIsSchema || $removeAdditional, $ownProperties = it.opts.ownProperties, $currentBaseId = it.baseId;
      var $required = it.schema.required;
      if ($required && !(it.opts.$data && $required.$data) && $required.length < it.opts.loopRequired) {
        var $requiredHash = it.util.toHash($required);
      }
      function notProto(p) {
        return p !== "__proto__";
      }
      out += "var " + $errs + " = errors;var " + $nextValid + " = true;";
      if ($ownProperties) {
        out += " var " + $dataProperties + " = undefined;";
      }
      if ($checkAdditional) {
        if ($ownProperties) {
          out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
        } else {
          out += " for (var " + $key + " in " + $data + ") { ";
        }
        if ($someProperties) {
          out += " var isAdditional" + $lvl + " = !(false ";
          if ($schemaKeys.length) {
            if ($schemaKeys.length > 8) {
              out += " || validate.schema" + $schemaPath + ".hasOwnProperty(" + $key + ") ";
            } else {
              var arr1 = $schemaKeys;
              if (arr1) {
                var $propertyKey, i1 = -1, l1 = arr1.length - 1;
                while (i1 < l1) {
                  $propertyKey = arr1[i1 += 1];
                  out += " || " + $key + " == " + it.util.toQuotedString($propertyKey) + " ";
                }
              }
            }
          }
          if ($pPropertyKeys.length) {
            var arr2 = $pPropertyKeys;
            if (arr2) {
              var $pProperty, $i = -1, l2 = arr2.length - 1;
              while ($i < l2) {
                $pProperty = arr2[$i += 1];
                out += " || " + it.usePattern($pProperty) + ".test(" + $key + ") ";
              }
            }
          }
          out += " ); if (isAdditional" + $lvl + ") { ";
        }
        if ($removeAdditional == "all") {
          out += " delete " + $data + "[" + $key + "]; ";
        } else {
          var $currentErrorPath = it.errorPath;
          var $additionalProperty = "' + " + $key + " + '";
          if (it.opts._errorDataPathProperty) {
            it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);
          }
          if ($noAdditional) {
            if ($removeAdditional) {
              out += " delete " + $data + "[" + $key + "]; ";
            } else {
              out += " " + $nextValid + " = false; ";
              var $currErrSchemaPath = $errSchemaPath;
              $errSchemaPath = it.errSchemaPath + "/additionalProperties";
              var $$outStack = $$outStack || [];
              $$outStack.push(out);
              out = "";
              if (it.createErrors !== false) {
                out += " { keyword: 'additionalProperties' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { additionalProperty: '" + $additionalProperty + "' } ";
                if (it.opts.messages !== false) {
                  out += " , message: '";
                  if (it.opts._errorDataPathProperty) {
                    out += "is an invalid additional property";
                  } else {
                    out += "should NOT have additional properties";
                  }
                  out += "' ";
                }
                if (it.opts.verbose) {
                  out += " , schema: false , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                }
                out += " } ";
              } else {
                out += " {} ";
              }
              var __err = out;
              out = $$outStack.pop();
              if (!it.compositeRule && $breakOnError) {
                if (it.async) {
                  out += " throw new ValidationError([" + __err + "]); ";
                } else {
                  out += " validate.errors = [" + __err + "]; return false; ";
                }
              } else {
                out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
              }
              $errSchemaPath = $currErrSchemaPath;
              if ($breakOnError) {
                out += " break; ";
              }
            }
          } else if ($additionalIsSchema) {
            if ($removeAdditional == "failing") {
              out += " var " + $errs + " = errors;  ";
              var $wasComposite = it.compositeRule;
              it.compositeRule = $it.compositeRule = true;
              $it.schema = $aProperties;
              $it.schemaPath = it.schemaPath + ".additionalProperties";
              $it.errSchemaPath = it.errSchemaPath + "/additionalProperties";
              $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it.validate($it);
              $it.baseId = $currentBaseId;
              if (it.util.varOccurences($code, $nextData) < 2) {
                out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              out += " if (!" + $nextValid + ") { errors = " + $errs + "; if (validate.errors !== null) { if (errors) validate.errors.length = errors; else validate.errors = null; } delete " + $data + "[" + $key + "]; }  ";
              it.compositeRule = $it.compositeRule = $wasComposite;
            } else {
              $it.schema = $aProperties;
              $it.schemaPath = it.schemaPath + ".additionalProperties";
              $it.errSchemaPath = it.errSchemaPath + "/additionalProperties";
              $it.errorPath = it.opts._errorDataPathProperty ? it.errorPath : it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it.validate($it);
              $it.baseId = $currentBaseId;
              if (it.util.varOccurences($code, $nextData) < 2) {
                out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              if ($breakOnError) {
                out += " if (!" + $nextValid + ") break; ";
              }
            }
          }
          it.errorPath = $currentErrorPath;
        }
        if ($someProperties) {
          out += " } ";
        }
        out += " }  ";
        if ($breakOnError) {
          out += " if (" + $nextValid + ") { ";
          $closingBraces += "}";
        }
      }
      var $useDefaults = it.opts.useDefaults && !it.compositeRule;
      if ($schemaKeys.length) {
        var arr3 = $schemaKeys;
        if (arr3) {
          var $propertyKey, i3 = -1, l3 = arr3.length - 1;
          while (i3 < l3) {
            $propertyKey = arr3[i3 += 1];
            var $sch = $schema2[$propertyKey];
            if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
              var $prop = it.util.getProperty($propertyKey), $passData = $data + $prop, $hasDefault = $useDefaults && $sch.default !== void 0;
              $it.schema = $sch;
              $it.schemaPath = $schemaPath + $prop;
              $it.errSchemaPath = $errSchemaPath + "/" + it.util.escapeFragment($propertyKey);
              $it.errorPath = it.util.getPath(it.errorPath, $propertyKey, it.opts.jsonPointers);
              $it.dataPathArr[$dataNxt] = it.util.toQuotedString($propertyKey);
              var $code = it.validate($it);
              $it.baseId = $currentBaseId;
              if (it.util.varOccurences($code, $nextData) < 2) {
                $code = it.util.varReplace($code, $nextData, $passData);
                var $useData = $passData;
              } else {
                var $useData = $nextData;
                out += " var " + $nextData + " = " + $passData + "; ";
              }
              if ($hasDefault) {
                out += " " + $code + " ";
              } else {
                if ($requiredHash && $requiredHash[$propertyKey]) {
                  out += " if ( " + $useData + " === undefined ";
                  if ($ownProperties) {
                    out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                  }
                  out += ") { " + $nextValid + " = false; ";
                  var $currentErrorPath = it.errorPath, $currErrSchemaPath = $errSchemaPath, $missingProperty = it.util.escapeQuotes($propertyKey);
                  if (it.opts._errorDataPathProperty) {
                    it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);
                  }
                  $errSchemaPath = it.errSchemaPath + "/required";
                  var $$outStack = $$outStack || [];
                  $$outStack.push(out);
                  out = "";
                  if (it.createErrors !== false) {
                    out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                    if (it.opts.messages !== false) {
                      out += " , message: '";
                      if (it.opts._errorDataPathProperty) {
                        out += "is a required property";
                      } else {
                        out += "should have required property \\'" + $missingProperty + "\\'";
                      }
                      out += "' ";
                    }
                    if (it.opts.verbose) {
                      out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                    }
                    out += " } ";
                  } else {
                    out += " {} ";
                  }
                  var __err = out;
                  out = $$outStack.pop();
                  if (!it.compositeRule && $breakOnError) {
                    if (it.async) {
                      out += " throw new ValidationError([" + __err + "]); ";
                    } else {
                      out += " validate.errors = [" + __err + "]; return false; ";
                    }
                  } else {
                    out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
                  }
                  $errSchemaPath = $currErrSchemaPath;
                  it.errorPath = $currentErrorPath;
                  out += " } else { ";
                } else {
                  if ($breakOnError) {
                    out += " if ( " + $useData + " === undefined ";
                    if ($ownProperties) {
                      out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                    }
                    out += ") { " + $nextValid + " = true; } else { ";
                  } else {
                    out += " if (" + $useData + " !== undefined ";
                    if ($ownProperties) {
                      out += " &&   Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                    }
                    out += " ) { ";
                  }
                }
                out += " " + $code + " } ";
              }
            }
            if ($breakOnError) {
              out += " if (" + $nextValid + ") { ";
              $closingBraces += "}";
            }
          }
        }
      }
      if ($pPropertyKeys.length) {
        var arr4 = $pPropertyKeys;
        if (arr4) {
          var $pProperty, i4 = -1, l4 = arr4.length - 1;
          while (i4 < l4) {
            $pProperty = arr4[i4 += 1];
            var $sch = $pProperties[$pProperty];
            if (it.opts.strictKeywords ? typeof $sch == "object" && Object.keys($sch).length > 0 || $sch === false : it.util.schemaHasRules($sch, it.RULES.all)) {
              $it.schema = $sch;
              $it.schemaPath = it.schemaPath + ".patternProperties" + it.util.getProperty($pProperty);
              $it.errSchemaPath = it.errSchemaPath + "/patternProperties/" + it.util.escapeFragment($pProperty);
              if ($ownProperties) {
                out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
              } else {
                out += " for (var " + $key + " in " + $data + ") { ";
              }
              out += " if (" + it.usePattern($pProperty) + ".test(" + $key + ")) { ";
              $it.errorPath = it.util.getPathExpr(it.errorPath, $key, it.opts.jsonPointers);
              var $passData = $data + "[" + $key + "]";
              $it.dataPathArr[$dataNxt] = $key;
              var $code = it.validate($it);
              $it.baseId = $currentBaseId;
              if (it.util.varOccurences($code, $nextData) < 2) {
                out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
              } else {
                out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
              }
              if ($breakOnError) {
                out += " if (!" + $nextValid + ") break; ";
              }
              out += " } ";
              if ($breakOnError) {
                out += " else " + $nextValid + " = true; ";
              }
              out += " }  ";
              if ($breakOnError) {
                out += " if (" + $nextValid + ") { ";
                $closingBraces += "}";
              }
            }
          }
        }
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    };
    return properties$l;
  }
  var propertyNames;
  var hasRequiredPropertyNames;
  function requirePropertyNames() {
    if (hasRequiredPropertyNames)
      return propertyNames;
    hasRequiredPropertyNames = 1;
    propertyNames = function generate_propertyNames(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $errs = "errs__" + $lvl;
      var $it = it.util.copy(it);
      var $closingBraces = "";
      $it.level++;
      var $nextValid = "valid" + $it.level;
      out += "var " + $errs + " = errors;";
      if (it.opts.strictKeywords ? typeof $schema2 == "object" && Object.keys($schema2).length > 0 || $schema2 === false : it.util.schemaHasRules($schema2, it.RULES.all)) {
        $it.schema = $schema2;
        $it.schemaPath = $schemaPath;
        $it.errSchemaPath = $errSchemaPath;
        var $key = "key" + $lvl, $idx = "idx" + $lvl, $i = "i" + $lvl, $invalidName = "' + " + $key + " + '", $dataNxt = $it.dataLevel = it.dataLevel + 1, $nextData = "data" + $dataNxt, $dataProperties = "dataProperties" + $lvl, $ownProperties = it.opts.ownProperties, $currentBaseId = it.baseId;
        if ($ownProperties) {
          out += " var " + $dataProperties + " = undefined; ";
        }
        if ($ownProperties) {
          out += " " + $dataProperties + " = " + $dataProperties + " || Object.keys(" + $data + "); for (var " + $idx + "=0; " + $idx + "<" + $dataProperties + ".length; " + $idx + "++) { var " + $key + " = " + $dataProperties + "[" + $idx + "]; ";
        } else {
          out += " for (var " + $key + " in " + $data + ") { ";
        }
        out += " var startErrs" + $lvl + " = errors; ";
        var $passData = $key;
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        var $code = it.validate($it);
        $it.baseId = $currentBaseId;
        if (it.util.varOccurences($code, $nextData) < 2) {
          out += " " + it.util.varReplace($code, $nextData, $passData) + " ";
        } else {
          out += " var " + $nextData + " = " + $passData + "; " + $code + " ";
        }
        it.compositeRule = $it.compositeRule = $wasComposite;
        out += " if (!" + $nextValid + ") { for (var " + $i + "=startErrs" + $lvl + "; " + $i + "<errors; " + $i + "++) { vErrors[" + $i + "].propertyName = " + $key + "; }   var err =   ";
        if (it.createErrors !== false) {
          out += " { keyword: 'propertyNames' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { propertyName: '" + $invalidName + "' } ";
          if (it.opts.messages !== false) {
            out += " , message: 'property name \\'" + $invalidName + "\\' is invalid' ";
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError(vErrors); ";
          } else {
            out += " validate.errors = vErrors; return false; ";
          }
        }
        if ($breakOnError) {
          out += " break; ";
        }
        out += " } }";
      }
      if ($breakOnError) {
        out += " " + $closingBraces + " if (" + $errs + " == errors) {";
      }
      return out;
    };
    return propertyNames;
  }
  var required$h;
  var hasRequiredRequired;
  function requireRequired() {
    if (hasRequiredRequired)
      return required$h;
    hasRequiredRequired = 1;
    required$h = function generate_required(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it.opts.$data && $schema2 && $schema2.$data;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
      }
      var $vSchema = "schema" + $lvl;
      if (!$isData) {
        if ($schema2.length < it.opts.loopRequired && it.schema.properties && Object.keys(it.schema.properties).length) {
          var $required = [];
          var arr1 = $schema2;
          if (arr1) {
            var $property, i1 = -1, l1 = arr1.length - 1;
            while (i1 < l1) {
              $property = arr1[i1 += 1];
              var $propertySch = it.schema.properties[$property];
              if (!($propertySch && (it.opts.strictKeywords ? typeof $propertySch == "object" && Object.keys($propertySch).length > 0 || $propertySch === false : it.util.schemaHasRules($propertySch, it.RULES.all)))) {
                $required[$required.length] = $property;
              }
            }
          }
        } else {
          var $required = $schema2;
        }
      }
      if ($isData || $required.length) {
        var $currentErrorPath = it.errorPath, $loopRequired = $isData || $required.length >= it.opts.loopRequired, $ownProperties = it.opts.ownProperties;
        if ($breakOnError) {
          out += " var missing" + $lvl + "; ";
          if ($loopRequired) {
            if (!$isData) {
              out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; ";
            }
            var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '";
            if (it.opts._errorDataPathProperty) {
              it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);
            }
            out += " var " + $valid + " = true; ";
            if ($isData) {
              out += " if (schema" + $lvl + " === undefined) " + $valid + " = true; else if (!Array.isArray(schema" + $lvl + ")) " + $valid + " = false; else {";
            }
            out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { " + $valid + " = " + $data + "[" + $vSchema + "[" + $i + "]] !== undefined ";
            if ($ownProperties) {
              out += " &&   Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) ";
            }
            out += "; if (!" + $valid + ") break; } ";
            if ($isData) {
              out += "  }  ";
            }
            out += "  if (!" + $valid + ") {   ";
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it.opts.messages !== false) {
                out += " , message: '";
                if (it.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } else { ";
          } else {
            out += " if ( ";
            var arr2 = $required;
            if (arr2) {
              var $propertyKey, $i = -1, l2 = arr2.length - 1;
              while ($i < l2) {
                $propertyKey = arr2[$i += 1];
                if ($i) {
                  out += " || ";
                }
                var $prop = it.util.getProperty($propertyKey), $useData = $data + $prop;
                out += " ( ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") && (missing" + $lvl + " = " + it.util.toQuotedString(it.opts.jsonPointers ? $propertyKey : $prop) + ") ) ";
              }
            }
            out += ") {  ";
            var $propertyPath = "missing" + $lvl, $missingProperty = "' + " + $propertyPath + " + '";
            if (it.opts._errorDataPathProperty) {
              it.errorPath = it.opts.jsonPointers ? it.util.getPathExpr($currentErrorPath, $propertyPath, true) : $currentErrorPath + " + " + $propertyPath;
            }
            var $$outStack = $$outStack || [];
            $$outStack.push(out);
            out = "";
            if (it.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it.opts.messages !== false) {
                out += " , message: '";
                if (it.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            var __err = out;
            out = $$outStack.pop();
            if (!it.compositeRule && $breakOnError) {
              if (it.async) {
                out += " throw new ValidationError([" + __err + "]); ";
              } else {
                out += " validate.errors = [" + __err + "]; return false; ";
              }
            } else {
              out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
            }
            out += " } else { ";
          }
        } else {
          if ($loopRequired) {
            if (!$isData) {
              out += " var " + $vSchema + " = validate.schema" + $schemaPath + "; ";
            }
            var $i = "i" + $lvl, $propertyPath = "schema" + $lvl + "[" + $i + "]", $missingProperty = "' + " + $propertyPath + " + '";
            if (it.opts._errorDataPathProperty) {
              it.errorPath = it.util.getPathExpr($currentErrorPath, $propertyPath, it.opts.jsonPointers);
            }
            if ($isData) {
              out += " if (" + $vSchema + " && !Array.isArray(" + $vSchema + ")) {  var err =   ";
              if (it.createErrors !== false) {
                out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                if (it.opts.messages !== false) {
                  out += " , message: '";
                  if (it.opts._errorDataPathProperty) {
                    out += "is a required property";
                  } else {
                    out += "should have required property \\'" + $missingProperty + "\\'";
                  }
                  out += "' ";
                }
                if (it.opts.verbose) {
                  out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                }
                out += " } ";
              } else {
                out += " {} ";
              }
              out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } else if (" + $vSchema + " !== undefined) { ";
            }
            out += " for (var " + $i + " = 0; " + $i + " < " + $vSchema + ".length; " + $i + "++) { if (" + $data + "[" + $vSchema + "[" + $i + "]] === undefined ";
            if ($ownProperties) {
              out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", " + $vSchema + "[" + $i + "]) ";
            }
            out += ") {  var err =   ";
            if (it.createErrors !== false) {
              out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
              if (it.opts.messages !== false) {
                out += " , message: '";
                if (it.opts._errorDataPathProperty) {
                  out += "is a required property";
                } else {
                  out += "should have required property \\'" + $missingProperty + "\\'";
                }
                out += "' ";
              }
              if (it.opts.verbose) {
                out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
              }
              out += " } ";
            } else {
              out += " {} ";
            }
            out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } } ";
            if ($isData) {
              out += "  }  ";
            }
          } else {
            var arr3 = $required;
            if (arr3) {
              var $propertyKey, i3 = -1, l3 = arr3.length - 1;
              while (i3 < l3) {
                $propertyKey = arr3[i3 += 1];
                var $prop = it.util.getProperty($propertyKey), $missingProperty = it.util.escapeQuotes($propertyKey), $useData = $data + $prop;
                if (it.opts._errorDataPathProperty) {
                  it.errorPath = it.util.getPath($currentErrorPath, $propertyKey, it.opts.jsonPointers);
                }
                out += " if ( " + $useData + " === undefined ";
                if ($ownProperties) {
                  out += " || ! Object.prototype.hasOwnProperty.call(" + $data + ", '" + it.util.escapeQuotes($propertyKey) + "') ";
                }
                out += ") {  var err =   ";
                if (it.createErrors !== false) {
                  out += " { keyword: 'required' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { missingProperty: '" + $missingProperty + "' } ";
                  if (it.opts.messages !== false) {
                    out += " , message: '";
                    if (it.opts._errorDataPathProperty) {
                      out += "is a required property";
                    } else {
                      out += "should have required property \\'" + $missingProperty + "\\'";
                    }
                    out += "' ";
                  }
                  if (it.opts.verbose) {
                    out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
                  }
                  out += " } ";
                } else {
                  out += " {} ";
                }
                out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; } ";
              }
            }
          }
        }
        it.errorPath = $currentErrorPath;
      } else if ($breakOnError) {
        out += " if (true) {";
      }
      return out;
    };
    return required$h;
  }
  var uniqueItems;
  var hasRequiredUniqueItems;
  function requireUniqueItems() {
    if (hasRequiredUniqueItems)
      return uniqueItems;
    hasRequiredUniqueItems = 1;
    uniqueItems = function generate_uniqueItems(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      if (($schema2 || $isData) && it.opts.uniqueItems !== false) {
        if ($isData) {
          out += " var " + $valid + "; if (" + $schemaValue + " === false || " + $schemaValue + " === undefined) " + $valid + " = true; else if (typeof " + $schemaValue + " != 'boolean') " + $valid + " = false; else { ";
        }
        out += " var i = " + $data + ".length , " + $valid + " = true , j; if (i > 1) { ";
        var $itemType = it.schema.items && it.schema.items.type, $typeIsArray = Array.isArray($itemType);
        if (!$itemType || $itemType == "object" || $itemType == "array" || $typeIsArray && ($itemType.indexOf("object") >= 0 || $itemType.indexOf("array") >= 0)) {
          out += " outer: for (;i--;) { for (j = i; j--;) { if (equal(" + $data + "[i], " + $data + "[j])) { " + $valid + " = false; break outer; } } } ";
        } else {
          out += " var itemIndices = {}, item; for (;i--;) { var item = " + $data + "[i]; ";
          var $method = "checkDataType" + ($typeIsArray ? "s" : "");
          out += " if (" + it.util[$method]($itemType, "item", it.opts.strictNumbers, true) + ") continue; ";
          if ($typeIsArray) {
            out += ` if (typeof item == 'string') item = '"' + item; `;
          }
          out += " if (typeof itemIndices[item] == 'number') { " + $valid + " = false; j = itemIndices[item]; break; } itemIndices[item] = i; } ";
        }
        out += " } ";
        if ($isData) {
          out += "  }  ";
        }
        out += " if (!" + $valid + ") {   ";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it.createErrors !== false) {
          out += " { keyword: 'uniqueItems' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { i: i, j: j } ";
          if (it.opts.messages !== false) {
            out += " , message: 'should NOT have duplicate items (items ## ' + j + ' and ' + i + ' are identical)' ";
          }
          if (it.opts.verbose) {
            out += " , schema:  ";
            if ($isData) {
              out += "validate.schema" + $schemaPath;
            } else {
              out += "" + $schema2;
            }
            out += "         , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        out += " } ";
        if ($breakOnError) {
          out += " else { ";
        }
      } else {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      }
      return out;
    };
    return uniqueItems;
  }
  var dotjs;
  var hasRequiredDotjs;
  function requireDotjs() {
    if (hasRequiredDotjs)
      return dotjs;
    hasRequiredDotjs = 1;
    dotjs = {
      "$ref": requireRef(),
      allOf: requireAllOf(),
      anyOf: requireAnyOf(),
      "$comment": requireComment(),
      const: require_const(),
      contains: requireContains(),
      dependencies: requireDependencies(),
      "enum": require_enum(),
      format: requireFormat(),
      "if": require_if(),
      items: requireItems(),
      maximum: require_limit(),
      minimum: require_limit(),
      maxItems: require_limitItems(),
      minItems: require_limitItems(),
      maxLength: require_limitLength(),
      minLength: require_limitLength(),
      maxProperties: require_limitProperties(),
      minProperties: require_limitProperties(),
      multipleOf: requireMultipleOf(),
      not: requireNot(),
      oneOf: requireOneOf(),
      pattern: requirePattern(),
      properties: requireProperties(),
      propertyNames: requirePropertyNames(),
      required: requireRequired(),
      uniqueItems: requireUniqueItems(),
      validate: requireValidate()
    };
    return dotjs;
  }
  var rules;
  var hasRequiredRules;
  function requireRules() {
    if (hasRequiredRules)
      return rules;
    hasRequiredRules = 1;
    var ruleModules = requireDotjs(), toHash = requireUtil().toHash;
    rules = function rules2() {
      var RULES = [
        {
          type: "number",
          rules: [
            { "maximum": ["exclusiveMaximum"] },
            { "minimum": ["exclusiveMinimum"] },
            "multipleOf",
            "format"
          ]
        },
        {
          type: "string",
          rules: ["maxLength", "minLength", "pattern", "format"]
        },
        {
          type: "array",
          rules: ["maxItems", "minItems", "items", "contains", "uniqueItems"]
        },
        {
          type: "object",
          rules: [
            "maxProperties",
            "minProperties",
            "required",
            "dependencies",
            "propertyNames",
            { "properties": ["additionalProperties", "patternProperties"] }
          ]
        },
        { rules: ["$ref", "const", "enum", "not", "anyOf", "oneOf", "allOf", "if"] }
      ];
      var ALL = ["type", "$comment"];
      var KEYWORDS = [
        "$schema",
        "$id",
        "id",
        "$data",
        "$async",
        "title",
        "description",
        "default",
        "definitions",
        "examples",
        "readOnly",
        "writeOnly",
        "contentMediaType",
        "contentEncoding",
        "additionalItems",
        "then",
        "else"
      ];
      var TYPES = ["number", "integer", "string", "array", "object", "boolean", "null"];
      RULES.all = toHash(ALL);
      RULES.types = toHash(TYPES);
      RULES.forEach(function(group) {
        group.rules = group.rules.map(function(keyword2) {
          var implKeywords;
          if (typeof keyword2 == "object") {
            var key2 = Object.keys(keyword2)[0];
            implKeywords = keyword2[key2];
            keyword2 = key2;
            implKeywords.forEach(function(k) {
              ALL.push(k);
              RULES.all[k] = true;
            });
          }
          ALL.push(keyword2);
          var rule = RULES.all[keyword2] = {
            keyword: keyword2,
            code: ruleModules[keyword2],
            implements: implKeywords
          };
          return rule;
        });
        RULES.all.$comment = {
          keyword: "$comment",
          code: ruleModules.$comment
        };
        if (group.type)
          RULES.types[group.type] = group;
      });
      RULES.keywords = toHash(ALL.concat(KEYWORDS));
      RULES.custom = {};
      return RULES;
    };
    return rules;
  }
  var data;
  var hasRequiredData;
  function requireData() {
    if (hasRequiredData)
      return data;
    hasRequiredData = 1;
    var KEYWORDS = [
      "multipleOf",
      "maximum",
      "exclusiveMaximum",
      "minimum",
      "exclusiveMinimum",
      "maxLength",
      "minLength",
      "pattern",
      "additionalItems",
      "maxItems",
      "minItems",
      "uniqueItems",
      "maxProperties",
      "minProperties",
      "required",
      "additionalProperties",
      "enum",
      "format",
      "const"
    ];
    data = function(metaSchema, keywordsJsonPointers) {
      for (var i2 = 0; i2 < keywordsJsonPointers.length; i2++) {
        metaSchema = JSON.parse(JSON.stringify(metaSchema));
        var segments = keywordsJsonPointers[i2].split("/");
        var keywords = metaSchema;
        var j2;
        for (j2 = 1; j2 < segments.length; j2++)
          keywords = keywords[segments[j2]];
        for (j2 = 0; j2 < KEYWORDS.length; j2++) {
          var key2 = KEYWORDS[j2];
          var schema = keywords[key2];
          if (schema) {
            keywords[key2] = {
              anyOf: [
                schema,
                { $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" }
              ]
            };
          }
        }
      }
      return metaSchema;
    };
    return data;
  }
  var async;
  var hasRequiredAsync;
  function requireAsync() {
    if (hasRequiredAsync)
      return async;
    hasRequiredAsync = 1;
    var MissingRefError = requireError_classes().MissingRef;
    async = compileAsync;
    function compileAsync(schema, meta, callback) {
      var self2 = this;
      if (typeof this._opts.loadSchema != "function")
        throw new Error("options.loadSchema should be a function");
      if (typeof meta == "function") {
        callback = meta;
        meta = void 0;
      }
      var p = loadMetaSchemaOf(schema).then(function() {
        var schemaObj = self2._addSchema(schema, void 0, meta);
        return schemaObj.validate || _compileAsync(schemaObj);
      });
      if (callback) {
        p.then(
          function(v) {
            callback(null, v);
          },
          callback
        );
      }
      return p;
      function loadMetaSchemaOf(sch) {
        var $schema2 = sch.$schema;
        return $schema2 && !self2.getSchema($schema2) ? compileAsync.call(self2, { $ref: $schema2 }, true) : Promise.resolve();
      }
      function _compileAsync(schemaObj) {
        try {
          return self2._compile(schemaObj);
        } catch (e) {
          if (e instanceof MissingRefError)
            return loadMissingSchema(e);
          throw e;
        }
        function loadMissingSchema(e) {
          var ref2 = e.missingSchema;
          if (added(ref2))
            throw new Error("Schema " + ref2 + " is loaded but " + e.missingRef + " cannot be resolved");
          var schemaPromise = self2._loadingSchemas[ref2];
          if (!schemaPromise) {
            schemaPromise = self2._loadingSchemas[ref2] = self2._opts.loadSchema(ref2);
            schemaPromise.then(removePromise, removePromise);
          }
          return schemaPromise.then(function(sch) {
            if (!added(ref2)) {
              return loadMetaSchemaOf(sch).then(function() {
                if (!added(ref2))
                  self2.addSchema(sch, ref2, void 0, meta);
              });
            }
          }).then(function() {
            return _compileAsync(schemaObj);
          });
          function removePromise() {
            delete self2._loadingSchemas[ref2];
          }
          function added(ref3) {
            return self2._refs[ref3] || self2._schemas[ref3];
          }
        }
      }
    }
    return async;
  }
  var custom;
  var hasRequiredCustom;
  function requireCustom() {
    if (hasRequiredCustom)
      return custom;
    hasRequiredCustom = 1;
    custom = function generate_custom(it, $keyword, $ruleType) {
      var out = " ";
      var $lvl = it.level;
      var $dataLvl = it.dataLevel;
      var $schema2 = it.schema[$keyword];
      var $schemaPath = it.schemaPath + it.util.getProperty($keyword);
      var $errSchemaPath = it.errSchemaPath + "/" + $keyword;
      var $breakOnError = !it.opts.allErrors;
      var $errorKeyword;
      var $data = "data" + ($dataLvl || "");
      var $valid = "valid" + $lvl;
      var $errs = "errs__" + $lvl;
      var $isData = it.opts.$data && $schema2 && $schema2.$data, $schemaValue;
      if ($isData) {
        out += " var schema" + $lvl + " = " + it.util.getData($schema2.$data, $dataLvl, it.dataPathArr) + "; ";
        $schemaValue = "schema" + $lvl;
      } else {
        $schemaValue = $schema2;
      }
      var $rule = this, $definition = "definition" + $lvl, $rDef = $rule.definition, $closingBraces = "";
      var $compile, $inline, $macro, $ruleValidate, $validateCode;
      if ($isData && $rDef.$data) {
        $validateCode = "keywordValidate" + $lvl;
        var $validateSchema = $rDef.validateSchema;
        out += " var " + $definition + " = RULES.custom['" + $keyword + "'].definition; var " + $validateCode + " = " + $definition + ".validate;";
      } else {
        $ruleValidate = it.useCustomRule($rule, $schema2, it.schema, it);
        if (!$ruleValidate)
          return;
        $schemaValue = "validate.schema" + $schemaPath;
        $validateCode = $ruleValidate.code;
        $compile = $rDef.compile;
        $inline = $rDef.inline;
        $macro = $rDef.macro;
      }
      var $ruleErrs = $validateCode + ".errors", $i = "i" + $lvl, $ruleErr = "ruleErr" + $lvl, $asyncKeyword = $rDef.async;
      if ($asyncKeyword && !it.async)
        throw new Error("async keyword in sync schema");
      if (!($inline || $macro)) {
        out += "" + $ruleErrs + " = null;";
      }
      out += "var " + $errs + " = errors;var " + $valid + ";";
      if ($isData && $rDef.$data) {
        $closingBraces += "}";
        out += " if (" + $schemaValue + " === undefined) { " + $valid + " = true; } else { ";
        if ($validateSchema) {
          $closingBraces += "}";
          out += " " + $valid + " = " + $definition + ".validateSchema(" + $schemaValue + "); if (" + $valid + ") { ";
        }
      }
      if ($inline) {
        if ($rDef.statements) {
          out += " " + $ruleValidate.validate + " ";
        } else {
          out += " " + $valid + " = " + $ruleValidate.validate + "; ";
        }
      } else if ($macro) {
        var $it = it.util.copy(it);
        var $closingBraces = "";
        $it.level++;
        var $nextValid = "valid" + $it.level;
        $it.schema = $ruleValidate.validate;
        $it.schemaPath = "";
        var $wasComposite = it.compositeRule;
        it.compositeRule = $it.compositeRule = true;
        var $code = it.validate($it).replace(/validate\.schema/g, $validateCode);
        it.compositeRule = $it.compositeRule = $wasComposite;
        out += " " + $code;
      } else {
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        out += "  " + $validateCode + ".call( ";
        if (it.opts.passContext) {
          out += "this";
        } else {
          out += "self";
        }
        if ($compile || $rDef.schema === false) {
          out += " , " + $data + " ";
        } else {
          out += " , " + $schemaValue + " , " + $data + " , validate.schema" + it.schemaPath + " ";
        }
        out += " , (dataPath || '')";
        if (it.errorPath != '""') {
          out += " + " + it.errorPath;
        }
        var $parentData = $dataLvl ? "data" + ($dataLvl - 1 || "") : "parentData", $parentDataProperty = $dataLvl ? it.dataPathArr[$dataLvl] : "parentDataProperty";
        out += " , " + $parentData + " , " + $parentDataProperty + " , rootData )  ";
        var def_callRuleValidate = out;
        out = $$outStack.pop();
        if ($rDef.errors === false) {
          out += " " + $valid + " = ";
          if ($asyncKeyword) {
            out += "await ";
          }
          out += "" + def_callRuleValidate + "; ";
        } else {
          if ($asyncKeyword) {
            $ruleErrs = "customErrors" + $lvl;
            out += " var " + $ruleErrs + " = null; try { " + $valid + " = await " + def_callRuleValidate + "; } catch (e) { " + $valid + " = false; if (e instanceof ValidationError) " + $ruleErrs + " = e.errors; else throw e; } ";
          } else {
            out += " " + $ruleErrs + " = null; " + $valid + " = " + def_callRuleValidate + "; ";
          }
        }
      }
      if ($rDef.modifying) {
        out += " if (" + $parentData + ") " + $data + " = " + $parentData + "[" + $parentDataProperty + "];";
      }
      out += "" + $closingBraces;
      if ($rDef.valid) {
        if ($breakOnError) {
          out += " if (true) { ";
        }
      } else {
        out += " if ( ";
        if ($rDef.valid === void 0) {
          out += " !";
          if ($macro) {
            out += "" + $nextValid;
          } else {
            out += "" + $valid;
          }
        } else {
          out += " " + !$rDef.valid + " ";
        }
        out += ") { ";
        $errorKeyword = $rule.keyword;
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        var $$outStack = $$outStack || [];
        $$outStack.push(out);
        out = "";
        if (it.createErrors !== false) {
          out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } ";
          if (it.opts.messages !== false) {
            out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `;
          }
          if (it.opts.verbose) {
            out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
          }
          out += " } ";
        } else {
          out += " {} ";
        }
        var __err = out;
        out = $$outStack.pop();
        if (!it.compositeRule && $breakOnError) {
          if (it.async) {
            out += " throw new ValidationError([" + __err + "]); ";
          } else {
            out += " validate.errors = [" + __err + "]; return false; ";
          }
        } else {
          out += " var err = " + __err + ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
        }
        var def_customError = out;
        out = $$outStack.pop();
        if ($inline) {
          if ($rDef.errors) {
            if ($rDef.errors != "full") {
              out += "  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it.errorPath + "; if (" + $ruleErr + ".schemaPath === undefined) { " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '"; } ';
              if (it.opts.verbose) {
                out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
              }
              out += " } ";
            }
          } else {
            if ($rDef.errors === false) {
              out += " " + def_customError + " ";
            } else {
              out += " if (" + $errs + " == errors) { " + def_customError + " } else {  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it.errorPath + "; if (" + $ruleErr + ".schemaPath === undefined) { " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '"; } ';
              if (it.opts.verbose) {
                out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
              }
              out += " } } ";
            }
          }
        } else if ($macro) {
          out += "   var err =   ";
          if (it.createErrors !== false) {
            out += " { keyword: '" + ($errorKeyword || "custom") + "' , dataPath: (dataPath || '') + " + it.errorPath + " , schemaPath: " + it.util.toQuotedString($errSchemaPath) + " , params: { keyword: '" + $rule.keyword + "' } ";
            if (it.opts.messages !== false) {
              out += ` , message: 'should pass "` + $rule.keyword + `" keyword validation' `;
            }
            if (it.opts.verbose) {
              out += " , schema: validate.schema" + $schemaPath + " , parentSchema: validate.schema" + it.schemaPath + " , data: " + $data + " ";
            }
            out += " } ";
          } else {
            out += " {} ";
          }
          out += ";  if (vErrors === null) vErrors = [err]; else vErrors.push(err); errors++; ";
          if (!it.compositeRule && $breakOnError) {
            if (it.async) {
              out += " throw new ValidationError(vErrors); ";
            } else {
              out += " validate.errors = vErrors; return false; ";
            }
          }
        } else {
          if ($rDef.errors === false) {
            out += " " + def_customError + " ";
          } else {
            out += " if (Array.isArray(" + $ruleErrs + ")) { if (vErrors === null) vErrors = " + $ruleErrs + "; else vErrors = vErrors.concat(" + $ruleErrs + "); errors = vErrors.length;  for (var " + $i + "=" + $errs + "; " + $i + "<errors; " + $i + "++) { var " + $ruleErr + " = vErrors[" + $i + "]; if (" + $ruleErr + ".dataPath === undefined) " + $ruleErr + ".dataPath = (dataPath || '') + " + it.errorPath + ";  " + $ruleErr + '.schemaPath = "' + $errSchemaPath + '";  ';
            if (it.opts.verbose) {
              out += " " + $ruleErr + ".schema = " + $schemaValue + "; " + $ruleErr + ".data = " + $data + "; ";
            }
            out += " } } else { " + def_customError + " } ";
          }
        }
        out += " } ";
        if ($breakOnError) {
          out += " else { ";
        }
      }
      return out;
    };
    return custom;
  }
  const $schema$k = "http://json-schema.org/draft-07/schema#";
  const $id$k = "http://json-schema.org/draft-07/schema#";
  const title$1 = "Core schema meta-schema";
  const definitions$1 = {
    schemaArray: {
      type: "array",
      minItems: 1,
      items: {
        $ref: "#"
      }
    },
    nonNegativeInteger: {
      type: "integer",
      minimum: 0
    },
    nonNegativeIntegerDefault0: {
      allOf: [
        {
          $ref: "#/definitions/nonNegativeInteger"
        },
        {
          "default": 0
        }
      ]
    },
    simpleTypes: {
      "enum": [
        "array",
        "boolean",
        "integer",
        "null",
        "number",
        "object",
        "string"
      ]
    },
    stringArray: {
      type: "array",
      items: {
        type: "string"
      },
      uniqueItems: true,
      "default": []
    }
  };
  const type$i = [
    "object",
    "boolean"
  ];
  const properties$k = {
    $id: {
      type: "string",
      format: "uri-reference"
    },
    $schema: {
      type: "string",
      format: "uri"
    },
    $ref: {
      type: "string",
      format: "uri-reference"
    },
    $comment: {
      type: "string"
    },
    title: {
      type: "string"
    },
    description: {
      type: "string"
    },
    "default": true,
    readOnly: {
      type: "boolean",
      "default": false
    },
    examples: {
      type: "array",
      items: true
    },
    multipleOf: {
      type: "number",
      exclusiveMinimum: 0
    },
    maximum: {
      type: "number"
    },
    exclusiveMaximum: {
      type: "number"
    },
    minimum: {
      type: "number"
    },
    exclusiveMinimum: {
      type: "number"
    },
    maxLength: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minLength: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    pattern: {
      type: "string",
      format: "regex"
    },
    additionalItems: {
      $ref: "#"
    },
    items: {
      anyOf: [
        {
          $ref: "#"
        },
        {
          $ref: "#/definitions/schemaArray"
        }
      ],
      "default": true
    },
    maxItems: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minItems: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    uniqueItems: {
      type: "boolean",
      "default": false
    },
    contains: {
      $ref: "#"
    },
    maxProperties: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minProperties: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    required: {
      $ref: "#/definitions/stringArray"
    },
    additionalProperties: {
      $ref: "#"
    },
    definitions: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      "default": {}
    },
    properties: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      "default": {}
    },
    patternProperties: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      propertyNames: {
        format: "regex"
      },
      "default": {}
    },
    dependencies: {
      type: "object",
      additionalProperties: {
        anyOf: [
          {
            $ref: "#"
          },
          {
            $ref: "#/definitions/stringArray"
          }
        ]
      }
    },
    propertyNames: {
      $ref: "#"
    },
    "const": true,
    "enum": {
      type: "array",
      items: true,
      minItems: 1,
      uniqueItems: true
    },
    type: {
      anyOf: [
        {
          $ref: "#/definitions/simpleTypes"
        },
        {
          type: "array",
          items: {
            $ref: "#/definitions/simpleTypes"
          },
          minItems: 1,
          uniqueItems: true
        }
      ]
    },
    format: {
      type: "string"
    },
    contentMediaType: {
      type: "string"
    },
    contentEncoding: {
      type: "string"
    },
    "if": {
      $ref: "#"
    },
    then: {
      $ref: "#"
    },
    "else": {
      $ref: "#"
    },
    allOf: {
      $ref: "#/definitions/schemaArray"
    },
    anyOf: {
      $ref: "#/definitions/schemaArray"
    },
    oneOf: {
      $ref: "#/definitions/schemaArray"
    },
    not: {
      $ref: "#"
    }
  };
  const require$$13$1 = {
    $schema: $schema$k,
    $id: $id$k,
    title: title$1,
    definitions: definitions$1,
    type: type$i,
    properties: properties$k,
    "default": true
  };
  var definition_schema;
  var hasRequiredDefinition_schema;
  function requireDefinition_schema() {
    if (hasRequiredDefinition_schema)
      return definition_schema;
    hasRequiredDefinition_schema = 1;
    var metaSchema = require$$13$1;
    definition_schema = {
      $id: "https://github.com/ajv-validator/ajv/blob/master/lib/definition_schema.js",
      definitions: {
        simpleTypes: metaSchema.definitions.simpleTypes
      },
      type: "object",
      dependencies: {
        schema: ["validate"],
        $data: ["validate"],
        statements: ["inline"],
        valid: { not: { required: ["macro"] } }
      },
      properties: {
        type: metaSchema.properties.type,
        schema: { type: "boolean" },
        statements: { type: "boolean" },
        dependencies: {
          type: "array",
          items: { type: "string" }
        },
        metaSchema: { type: "object" },
        modifying: { type: "boolean" },
        valid: { type: "boolean" },
        $data: { type: "boolean" },
        async: { type: "boolean" },
        errors: {
          anyOf: [
            { type: "boolean" },
            { const: "full" }
          ]
        }
      }
    };
    return definition_schema;
  }
  var keyword;
  var hasRequiredKeyword;
  function requireKeyword() {
    if (hasRequiredKeyword)
      return keyword;
    hasRequiredKeyword = 1;
    var IDENTIFIER = /^[a-z_$][a-z0-9_$-]*$/i;
    var customRuleCode = requireCustom();
    var definitionSchema = requireDefinition_schema();
    keyword = {
      add: addKeyword,
      get: getKeyword,
      remove: removeKeyword,
      validate: validateKeyword
    };
    function addKeyword(keyword2, definition) {
      var RULES = this.RULES;
      if (RULES.keywords[keyword2])
        throw new Error("Keyword " + keyword2 + " is already defined");
      if (!IDENTIFIER.test(keyword2))
        throw new Error("Keyword " + keyword2 + " is not a valid identifier");
      if (definition) {
        this.validateKeyword(definition, true);
        var dataType = definition.type;
        if (Array.isArray(dataType)) {
          for (var i2 = 0; i2 < dataType.length; i2++)
            _addRule(keyword2, dataType[i2], definition);
        } else {
          _addRule(keyword2, dataType, definition);
        }
        var metaSchema = definition.metaSchema;
        if (metaSchema) {
          if (definition.$data && this._opts.$data) {
            metaSchema = {
              anyOf: [
                metaSchema,
                { "$ref": "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#" }
              ]
            };
          }
          definition.validateSchema = this.compile(metaSchema, true);
        }
      }
      RULES.keywords[keyword2] = RULES.all[keyword2] = true;
      function _addRule(keyword3, dataType2, definition2) {
        var ruleGroup;
        for (var i3 = 0; i3 < RULES.length; i3++) {
          var rg = RULES[i3];
          if (rg.type == dataType2) {
            ruleGroup = rg;
            break;
          }
        }
        if (!ruleGroup) {
          ruleGroup = { type: dataType2, rules: [] };
          RULES.push(ruleGroup);
        }
        var rule = {
          keyword: keyword3,
          definition: definition2,
          custom: true,
          code: customRuleCode,
          implements: definition2.implements
        };
        ruleGroup.rules.push(rule);
        RULES.custom[keyword3] = rule;
      }
      return this;
    }
    function getKeyword(keyword2) {
      var rule = this.RULES.custom[keyword2];
      return rule ? rule.definition : this.RULES.keywords[keyword2] || false;
    }
    function removeKeyword(keyword2) {
      var RULES = this.RULES;
      delete RULES.keywords[keyword2];
      delete RULES.all[keyword2];
      delete RULES.custom[keyword2];
      for (var i2 = 0; i2 < RULES.length; i2++) {
        var rules2 = RULES[i2].rules;
        for (var j2 = 0; j2 < rules2.length; j2++) {
          if (rules2[j2].keyword == keyword2) {
            rules2.splice(j2, 1);
            break;
          }
        }
      }
      return this;
    }
    function validateKeyword(definition, throwError) {
      validateKeyword.errors = null;
      var v = this._validateKeyword = this._validateKeyword || this.compile(definitionSchema, true);
      if (v(definition))
        return true;
      validateKeyword.errors = v.errors;
      if (throwError)
        throw new Error("custom keyword definition is invalid: " + this.errorsText(v.errors));
      else
        return false;
    }
    return keyword;
  }
  const $schema$j = "http://json-schema.org/draft-07/schema#";
  const $id$j = "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#";
  const description = "Meta-schema for $data reference (JSON Schema extension proposal)";
  const type$h = "object";
  const required$g = [
    "$data"
  ];
  const properties$j = {
    $data: {
      type: "string",
      anyOf: [
        {
          format: "relative-json-pointer"
        },
        {
          format: "json-pointer"
        }
      ]
    }
  };
  const additionalProperties = false;
  const require$$12$1 = {
    $schema: $schema$j,
    $id: $id$j,
    description,
    type: type$h,
    required: required$g,
    properties: properties$j,
    additionalProperties
  };
  var ajv;
  var hasRequiredAjv;
  function requireAjv() {
    if (hasRequiredAjv)
      return ajv;
    hasRequiredAjv = 1;
    var compileSchema = requireCompile(), resolve = requireResolve(), Cache = requireCache(), SchemaObject = requireSchema_obj(), stableStringify = requireFastJsonStableStringify(), formats2 = requireFormats(), rules2 = requireRules(), $dataMetaSchema = requireData(), util2 = requireUtil();
    ajv = Ajv;
    Ajv.prototype.validate = validate3;
    Ajv.prototype.compile = compile;
    Ajv.prototype.addSchema = addSchema;
    Ajv.prototype.addMetaSchema = addMetaSchema;
    Ajv.prototype.validateSchema = validateSchema;
    Ajv.prototype.getSchema = getSchema;
    Ajv.prototype.removeSchema = removeSchema;
    Ajv.prototype.addFormat = addFormat;
    Ajv.prototype.errorsText = errorsText;
    Ajv.prototype._addSchema = _addSchema;
    Ajv.prototype._compile = _compile;
    Ajv.prototype.compileAsync = requireAsync();
    var customKeyword = requireKeyword();
    Ajv.prototype.addKeyword = customKeyword.add;
    Ajv.prototype.getKeyword = customKeyword.get;
    Ajv.prototype.removeKeyword = customKeyword.remove;
    Ajv.prototype.validateKeyword = customKeyword.validate;
    var errorClasses = requireError_classes();
    Ajv.ValidationError = errorClasses.Validation;
    Ajv.MissingRefError = errorClasses.MissingRef;
    Ajv.$dataMetaSchema = $dataMetaSchema;
    var META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
    var META_IGNORE_OPTIONS = ["removeAdditional", "useDefaults", "coerceTypes", "strictDefaults"];
    var META_SUPPORT_DATA = ["/properties"];
    function Ajv(opts) {
      if (!(this instanceof Ajv))
        return new Ajv(opts);
      opts = this._opts = util2.copy(opts) || {};
      setLogger(this);
      this._schemas = {};
      this._refs = {};
      this._fragments = {};
      this._formats = formats2(opts.format);
      this._cache = opts.cache || new Cache();
      this._loadingSchemas = {};
      this._compilations = [];
      this.RULES = rules2();
      this._getId = chooseGetId(opts);
      opts.loopRequired = opts.loopRequired || Infinity;
      if (opts.errorDataPath == "property")
        opts._errorDataPathProperty = true;
      if (opts.serialize === void 0)
        opts.serialize = stableStringify;
      this._metaOpts = getMetaSchemaOptions(this);
      if (opts.formats)
        addInitialFormats(this);
      if (opts.keywords)
        addInitialKeywords(this);
      addDefaultMetaSchema(this);
      if (typeof opts.meta == "object")
        this.addMetaSchema(opts.meta);
      if (opts.nullable)
        this.addKeyword("nullable", { metaSchema: { type: "boolean" } });
      addInitialSchemas(this);
    }
    function validate3(schemaKeyRef, data2) {
      var v;
      if (typeof schemaKeyRef == "string") {
        v = this.getSchema(schemaKeyRef);
        if (!v)
          throw new Error('no schema with key or ref "' + schemaKeyRef + '"');
      } else {
        var schemaObj = this._addSchema(schemaKeyRef);
        v = schemaObj.validate || this._compile(schemaObj);
      }
      var valid = v(data2);
      if (v.$async !== true)
        this.errors = v.errors;
      return valid;
    }
    function compile(schema, _meta) {
      var schemaObj = this._addSchema(schema, void 0, _meta);
      return schemaObj.validate || this._compile(schemaObj);
    }
    function addSchema(schema, key2, _skipValidation, _meta) {
      if (Array.isArray(schema)) {
        for (var i2 = 0; i2 < schema.length; i2++)
          this.addSchema(schema[i2], void 0, _skipValidation, _meta);
        return this;
      }
      var id = this._getId(schema);
      if (id !== void 0 && typeof id != "string")
        throw new Error("schema id must be string");
      key2 = resolve.normalizeId(key2 || id);
      checkUnique(this, key2);
      this._schemas[key2] = this._addSchema(schema, _skipValidation, _meta, true);
      return this;
    }
    function addMetaSchema(schema, key2, skipValidation) {
      this.addSchema(schema, key2, skipValidation, true);
      return this;
    }
    function validateSchema(schema, throwOrLogError) {
      var $schema2 = schema.$schema;
      if ($schema2 !== void 0 && typeof $schema2 != "string")
        throw new Error("$schema must be a string");
      $schema2 = $schema2 || this._opts.defaultMeta || defaultMeta(this);
      if (!$schema2) {
        this.logger.warn("meta-schema not available");
        this.errors = null;
        return true;
      }
      var valid = this.validate($schema2, schema);
      if (!valid && throwOrLogError) {
        var message = "schema is invalid: " + this.errorsText();
        if (this._opts.validateSchema == "log")
          this.logger.error(message);
        else
          throw new Error(message);
      }
      return valid;
    }
    function defaultMeta(self2) {
      var meta = self2._opts.meta;
      self2._opts.defaultMeta = typeof meta == "object" ? self2._getId(meta) || meta : self2.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0;
      return self2._opts.defaultMeta;
    }
    function getSchema(keyRef) {
      var schemaObj = _getSchemaObj(this, keyRef);
      switch (typeof schemaObj) {
        case "object":
          return schemaObj.validate || this._compile(schemaObj);
        case "string":
          return this.getSchema(schemaObj);
        case "undefined":
          return _getSchemaFragment(this, keyRef);
      }
    }
    function _getSchemaFragment(self2, ref2) {
      var res = resolve.schema.call(self2, { schema: {} }, ref2);
      if (res) {
        var schema = res.schema, root = res.root, baseId = res.baseId;
        var v = compileSchema.call(self2, schema, root, void 0, baseId);
        self2._fragments[ref2] = new SchemaObject({
          ref: ref2,
          fragment: true,
          schema,
          root,
          baseId,
          validate: v
        });
        return v;
      }
    }
    function _getSchemaObj(self2, keyRef) {
      keyRef = resolve.normalizeId(keyRef);
      return self2._schemas[keyRef] || self2._refs[keyRef] || self2._fragments[keyRef];
    }
    function removeSchema(schemaKeyRef) {
      if (schemaKeyRef instanceof RegExp) {
        _removeAllSchemas(this, this._schemas, schemaKeyRef);
        _removeAllSchemas(this, this._refs, schemaKeyRef);
        return this;
      }
      switch (typeof schemaKeyRef) {
        case "undefined":
          _removeAllSchemas(this, this._schemas);
          _removeAllSchemas(this, this._refs);
          this._cache.clear();
          return this;
        case "string":
          var schemaObj = _getSchemaObj(this, schemaKeyRef);
          if (schemaObj)
            this._cache.del(schemaObj.cacheKey);
          delete this._schemas[schemaKeyRef];
          delete this._refs[schemaKeyRef];
          return this;
        case "object":
          var serialize = this._opts.serialize;
          var cacheKey = serialize ? serialize(schemaKeyRef) : schemaKeyRef;
          this._cache.del(cacheKey);
          var id = this._getId(schemaKeyRef);
          if (id) {
            id = resolve.normalizeId(id);
            delete this._schemas[id];
            delete this._refs[id];
          }
      }
      return this;
    }
    function _removeAllSchemas(self2, schemas, regex) {
      for (var keyRef in schemas) {
        var schemaObj = schemas[keyRef];
        if (!schemaObj.meta && (!regex || regex.test(keyRef))) {
          self2._cache.del(schemaObj.cacheKey);
          delete schemas[keyRef];
        }
      }
    }
    function _addSchema(schema, skipValidation, meta, shouldAddSchema) {
      if (typeof schema != "object" && typeof schema != "boolean")
        throw new Error("schema should be object or boolean");
      var serialize = this._opts.serialize;
      var cacheKey = serialize ? serialize(schema) : schema;
      var cached = this._cache.get(cacheKey);
      if (cached)
        return cached;
      shouldAddSchema = shouldAddSchema || this._opts.addUsedSchema !== false;
      var id = resolve.normalizeId(this._getId(schema));
      if (id && shouldAddSchema)
        checkUnique(this, id);
      var willValidate = this._opts.validateSchema !== false && !skipValidation;
      var recursiveMeta;
      if (willValidate && !(recursiveMeta = id && id == resolve.normalizeId(schema.$schema)))
        this.validateSchema(schema, true);
      var localRefs = resolve.ids.call(this, schema);
      var schemaObj = new SchemaObject({
        id,
        schema,
        localRefs,
        cacheKey,
        meta
      });
      if (id[0] != "#" && shouldAddSchema)
        this._refs[id] = schemaObj;
      this._cache.put(cacheKey, schemaObj);
      if (willValidate && recursiveMeta)
        this.validateSchema(schema, true);
      return schemaObj;
    }
    function _compile(schemaObj, root) {
      if (schemaObj.compiling) {
        schemaObj.validate = callValidate;
        callValidate.schema = schemaObj.schema;
        callValidate.errors = null;
        callValidate.root = root ? root : callValidate;
        if (schemaObj.schema.$async === true)
          callValidate.$async = true;
        return callValidate;
      }
      schemaObj.compiling = true;
      var currentOpts;
      if (schemaObj.meta) {
        currentOpts = this._opts;
        this._opts = this._metaOpts;
      }
      var v;
      try {
        v = compileSchema.call(this, schemaObj.schema, root, schemaObj.localRefs);
      } catch (e) {
        delete schemaObj.validate;
        throw e;
      } finally {
        schemaObj.compiling = false;
        if (schemaObj.meta)
          this._opts = currentOpts;
      }
      schemaObj.validate = v;
      schemaObj.refs = v.refs;
      schemaObj.refVal = v.refVal;
      schemaObj.root = v.root;
      return v;
      function callValidate() {
        var _validate = schemaObj.validate;
        var result2 = _validate.apply(this, arguments);
        callValidate.errors = _validate.errors;
        return result2;
      }
    }
    function chooseGetId(opts) {
      switch (opts.schemaId) {
        case "auto":
          return _get$IdOrId;
        case "id":
          return _getId;
        default:
          return _get$Id;
      }
    }
    function _getId(schema) {
      if (schema.$id)
        this.logger.warn("schema $id ignored", schema.$id);
      return schema.id;
    }
    function _get$Id(schema) {
      if (schema.id)
        this.logger.warn("schema id ignored", schema.id);
      return schema.$id;
    }
    function _get$IdOrId(schema) {
      if (schema.$id && schema.id && schema.$id != schema.id)
        throw new Error("schema $id is different from id");
      return schema.$id || schema.id;
    }
    function errorsText(errors2, options) {
      errors2 = errors2 || this.errors;
      if (!errors2)
        return "No errors";
      options = options || {};
      var separator = options.separator === void 0 ? ", " : options.separator;
      var dataVar = options.dataVar === void 0 ? "data" : options.dataVar;
      var text = "";
      for (var i2 = 0; i2 < errors2.length; i2++) {
        var e = errors2[i2];
        if (e)
          text += dataVar + e.dataPath + " " + e.message + separator;
      }
      return text.slice(0, -separator.length);
    }
    function addFormat(name, format2) {
      if (typeof format2 == "string")
        format2 = new RegExp(format2);
      this._formats[name] = format2;
      return this;
    }
    function addDefaultMetaSchema(self2) {
      var $dataSchema;
      if (self2._opts.$data) {
        $dataSchema = require$$12$1;
        self2.addMetaSchema($dataSchema, $dataSchema.$id, true);
      }
      if (self2._opts.meta === false)
        return;
      var metaSchema = require$$13$1;
      if (self2._opts.$data)
        metaSchema = $dataMetaSchema(metaSchema, META_SUPPORT_DATA);
      self2.addMetaSchema(metaSchema, META_SCHEMA_ID, true);
      self2._refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
    }
    function addInitialSchemas(self2) {
      var optsSchemas = self2._opts.schemas;
      if (!optsSchemas)
        return;
      if (Array.isArray(optsSchemas))
        self2.addSchema(optsSchemas);
      else
        for (var key2 in optsSchemas)
          self2.addSchema(optsSchemas[key2], key2);
    }
    function addInitialFormats(self2) {
      for (var name in self2._opts.formats) {
        var format2 = self2._opts.formats[name];
        self2.addFormat(name, format2);
      }
    }
    function addInitialKeywords(self2) {
      for (var name in self2._opts.keywords) {
        var keyword2 = self2._opts.keywords[name];
        self2.addKeyword(name, keyword2);
      }
    }
    function checkUnique(self2, id) {
      if (self2._schemas[id] || self2._refs[id])
        throw new Error('schema with key or id "' + id + '" already exists');
    }
    function getMetaSchemaOptions(self2) {
      var metaOpts = util2.copy(self2._opts);
      for (var i2 = 0; i2 < META_IGNORE_OPTIONS.length; i2++)
        delete metaOpts[META_IGNORE_OPTIONS[i2]];
      return metaOpts;
    }
    function setLogger(self2) {
      var logger = self2._opts.logger;
      if (logger === false) {
        self2.logger = { log: noop, warn: noop, error: noop };
      } else {
        if (logger === void 0)
          logger = console;
        if (!(typeof logger == "object" && logger.log && logger.warn && logger.error))
          throw new Error("logger must implement log, warn and error methods");
        self2.logger = logger;
      }
    }
    function noop() {
    }
    return ajv;
  }
  var error;
  var hasRequiredError;
  function requireError() {
    if (hasRequiredError)
      return error;
    hasRequiredError = 1;
    function HARError(errors2) {
      var message = "validation failed";
      this.name = "HARError";
      this.message = message;
      this.errors = errors2;
      if (typeof Error.captureStackTrace === "function") {
        Error.captureStackTrace(this, this.constructor);
      } else {
        this.stack = new Error(message).stack;
      }
    }
    HARError.prototype = Error.prototype;
    error = HARError;
    return error;
  }
  const $id$i = "afterRequest.json#";
  const $schema$i = "http://json-schema.org/draft-06/schema#";
  const type$g = "object";
  const optional$4 = true;
  const required$f = [
    "lastAccess",
    "eTag",
    "hitCount"
  ];
  const properties$i = {
    expires: {
      type: "string",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))?"
    },
    lastAccess: {
      type: "string",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))?"
    },
    eTag: {
      type: "string"
    },
    hitCount: {
      type: "integer"
    },
    comment: {
      type: "string"
    }
  };
  const require$$0 = {
    $id: $id$i,
    $schema: $schema$i,
    type: type$g,
    optional: optional$4,
    required: required$f,
    properties: properties$i
  };
  const $id$h = "beforeRequest.json#";
  const $schema$h = "http://json-schema.org/draft-06/schema#";
  const type$f = "object";
  const optional$3 = true;
  const required$e = [
    "lastAccess",
    "eTag",
    "hitCount"
  ];
  const properties$h = {
    expires: {
      type: "string",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))?"
    },
    lastAccess: {
      type: "string",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))?"
    },
    eTag: {
      type: "string"
    },
    hitCount: {
      type: "integer"
    },
    comment: {
      type: "string"
    }
  };
  const require$$1 = {
    $id: $id$h,
    $schema: $schema$h,
    type: type$f,
    optional: optional$3,
    required: required$e,
    properties: properties$h
  };
  const $id$g = "browser.json#";
  const $schema$g = "http://json-schema.org/draft-06/schema#";
  const type$e = "object";
  const required$d = [
    "name",
    "version"
  ];
  const properties$g = {
    name: {
      type: "string"
    },
    version: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$2 = {
    $id: $id$g,
    $schema: $schema$g,
    type: type$e,
    required: required$d,
    properties: properties$g
  };
  const $id$f = "cache.json#";
  const $schema$f = "http://json-schema.org/draft-06/schema#";
  const properties$f = {
    beforeRequest: {
      oneOf: [
        {
          type: "null"
        },
        {
          $ref: "beforeRequest.json#"
        }
      ]
    },
    afterRequest: {
      oneOf: [
        {
          type: "null"
        },
        {
          $ref: "afterRequest.json#"
        }
      ]
    },
    comment: {
      type: "string"
    }
  };
  const require$$3$1 = {
    $id: $id$f,
    $schema: $schema$f,
    properties: properties$f
  };
  const $id$e = "content.json#";
  const $schema$e = "http://json-schema.org/draft-06/schema#";
  const type$d = "object";
  const required$c = [
    "size",
    "mimeType"
  ];
  const properties$e = {
    size: {
      type: "integer"
    },
    compression: {
      type: "integer"
    },
    mimeType: {
      type: "string"
    },
    text: {
      type: "string"
    },
    encoding: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$4 = {
    $id: $id$e,
    $schema: $schema$e,
    type: type$d,
    required: required$c,
    properties: properties$e
  };
  const $id$d = "cookie.json#";
  const $schema$d = "http://json-schema.org/draft-06/schema#";
  const type$c = "object";
  const required$b = [
    "name",
    "value"
  ];
  const properties$d = {
    name: {
      type: "string"
    },
    value: {
      type: "string"
    },
    path: {
      type: "string"
    },
    domain: {
      type: "string"
    },
    expires: {
      type: [
        "string",
        "null"
      ],
      format: "date-time"
    },
    httpOnly: {
      type: "boolean"
    },
    secure: {
      type: "boolean"
    },
    comment: {
      type: "string"
    }
  };
  const require$$5 = {
    $id: $id$d,
    $schema: $schema$d,
    type: type$c,
    required: required$b,
    properties: properties$d
  };
  const $id$c = "creator.json#";
  const $schema$c = "http://json-schema.org/draft-06/schema#";
  const type$b = "object";
  const required$a = [
    "name",
    "version"
  ];
  const properties$c = {
    name: {
      type: "string"
    },
    version: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$6 = {
    $id: $id$c,
    $schema: $schema$c,
    type: type$b,
    required: required$a,
    properties: properties$c
  };
  const $id$b = "entry.json#";
  const $schema$b = "http://json-schema.org/draft-06/schema#";
  const type$a = "object";
  const optional$2 = true;
  const required$9 = [
    "startedDateTime",
    "time",
    "request",
    "response",
    "cache",
    "timings"
  ];
  const properties$b = {
    pageref: {
      type: "string"
    },
    startedDateTime: {
      type: "string",
      format: "date-time",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))"
    },
    time: {
      type: "number",
      min: 0
    },
    request: {
      $ref: "request.json#"
    },
    response: {
      $ref: "response.json#"
    },
    cache: {
      $ref: "cache.json#"
    },
    timings: {
      $ref: "timings.json#"
    },
    serverIPAddress: {
      type: "string",
      oneOf: [
        {
          format: "ipv4"
        },
        {
          format: "ipv6"
        }
      ]
    },
    connection: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$7 = {
    $id: $id$b,
    $schema: $schema$b,
    type: type$a,
    optional: optional$2,
    required: required$9,
    properties: properties$b
  };
  const $id$a = "har.json#";
  const $schema$a = "http://json-schema.org/draft-06/schema#";
  const type$9 = "object";
  const required$8 = [
    "log"
  ];
  const properties$a = {
    log: {
      $ref: "log.json#"
    }
  };
  const require$$8 = {
    $id: $id$a,
    $schema: $schema$a,
    type: type$9,
    required: required$8,
    properties: properties$a
  };
  const $id$9 = "header.json#";
  const $schema$9 = "http://json-schema.org/draft-06/schema#";
  const type$8 = "object";
  const required$7 = [
    "name",
    "value"
  ];
  const properties$9 = {
    name: {
      type: "string"
    },
    value: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$9 = {
    $id: $id$9,
    $schema: $schema$9,
    type: type$8,
    required: required$7,
    properties: properties$9
  };
  const $id$8 = "log.json#";
  const $schema$8 = "http://json-schema.org/draft-06/schema#";
  const type$7 = "object";
  const required$6 = [
    "version",
    "creator",
    "entries"
  ];
  const properties$8 = {
    version: {
      type: "string"
    },
    creator: {
      $ref: "creator.json#"
    },
    browser: {
      $ref: "browser.json#"
    },
    pages: {
      type: "array",
      items: {
        $ref: "page.json#"
      }
    },
    entries: {
      type: "array",
      items: {
        $ref: "entry.json#"
      }
    },
    comment: {
      type: "string"
    }
  };
  const require$$10 = {
    $id: $id$8,
    $schema: $schema$8,
    type: type$7,
    required: required$6,
    properties: properties$8
  };
  const $id$7 = "page.json#";
  const $schema$7 = "http://json-schema.org/draft-06/schema#";
  const type$6 = "object";
  const optional$1 = true;
  const required$5 = [
    "startedDateTime",
    "id",
    "title",
    "pageTimings"
  ];
  const properties$7 = {
    startedDateTime: {
      type: "string",
      format: "date-time",
      pattern: "^(\\d{4})(-)?(\\d\\d)(-)?(\\d\\d)(T)?(\\d\\d)(:)?(\\d\\d)(:)?(\\d\\d)(\\.\\d+)?(Z|([+-])(\\d\\d)(:)?(\\d\\d))"
    },
    id: {
      type: "string",
      unique: true
    },
    title: {
      type: "string"
    },
    pageTimings: {
      $ref: "pageTimings.json#"
    },
    comment: {
      type: "string"
    }
  };
  const require$$11 = {
    $id: $id$7,
    $schema: $schema$7,
    type: type$6,
    optional: optional$1,
    required: required$5,
    properties: properties$7
  };
  const $id$6 = "pageTimings.json#";
  const $schema$6 = "http://json-schema.org/draft-06/schema#";
  const type$5 = "object";
  const properties$6 = {
    onContentLoad: {
      type: "number",
      min: -1
    },
    onLoad: {
      type: "number",
      min: -1
    },
    comment: {
      type: "string"
    }
  };
  const require$$12 = {
    $id: $id$6,
    $schema: $schema$6,
    type: type$5,
    properties: properties$6
  };
  const $id$5 = "postData.json#";
  const $schema$5 = "http://json-schema.org/draft-06/schema#";
  const type$4 = "object";
  const optional = true;
  const required$4 = [
    "mimeType"
  ];
  const properties$5 = {
    mimeType: {
      type: "string"
    },
    text: {
      type: "string"
    },
    params: {
      type: "array",
      required: [
        "name"
      ],
      properties: {
        name: {
          type: "string"
        },
        value: {
          type: "string"
        },
        fileName: {
          type: "string"
        },
        contentType: {
          type: "string"
        },
        comment: {
          type: "string"
        }
      }
    },
    comment: {
      type: "string"
    }
  };
  const require$$13 = {
    $id: $id$5,
    $schema: $schema$5,
    type: type$4,
    optional,
    required: required$4,
    properties: properties$5
  };
  const $id$4 = "query.json#";
  const $schema$4 = "http://json-schema.org/draft-06/schema#";
  const type$3 = "object";
  const required$3 = [
    "name",
    "value"
  ];
  const properties$4 = {
    name: {
      type: "string"
    },
    value: {
      type: "string"
    },
    comment: {
      type: "string"
    }
  };
  const require$$14 = {
    $id: $id$4,
    $schema: $schema$4,
    type: type$3,
    required: required$3,
    properties: properties$4
  };
  const $id$3 = "request.json#";
  const $schema$3 = "http://json-schema.org/draft-06/schema#";
  const type$2 = "object";
  const required$2 = [
    "method",
    "url",
    "httpVersion",
    "cookies",
    "headers",
    "queryString",
    "headersSize",
    "bodySize"
  ];
  const properties$3 = {
    method: {
      type: "string"
    },
    url: {
      type: "string",
      format: "uri"
    },
    httpVersion: {
      type: "string"
    },
    cookies: {
      type: "array",
      items: {
        $ref: "cookie.json#"
      }
    },
    headers: {
      type: "array",
      items: {
        $ref: "header.json#"
      }
    },
    queryString: {
      type: "array",
      items: {
        $ref: "query.json#"
      }
    },
    postData: {
      $ref: "postData.json#"
    },
    headersSize: {
      type: "integer"
    },
    bodySize: {
      type: "integer"
    },
    comment: {
      type: "string"
    }
  };
  const require$$15 = {
    $id: $id$3,
    $schema: $schema$3,
    type: type$2,
    required: required$2,
    properties: properties$3
  };
  const $id$2 = "response.json#";
  const $schema$2 = "http://json-schema.org/draft-06/schema#";
  const type$1 = "object";
  const required$1 = [
    "status",
    "statusText",
    "httpVersion",
    "cookies",
    "headers",
    "content",
    "redirectURL",
    "headersSize",
    "bodySize"
  ];
  const properties$2 = {
    status: {
      type: "integer"
    },
    statusText: {
      type: "string"
    },
    httpVersion: {
      type: "string"
    },
    cookies: {
      type: "array",
      items: {
        $ref: "cookie.json#"
      }
    },
    headers: {
      type: "array",
      items: {
        $ref: "header.json#"
      }
    },
    content: {
      $ref: "content.json#"
    },
    redirectURL: {
      type: "string"
    },
    headersSize: {
      type: "integer"
    },
    bodySize: {
      type: "integer"
    },
    comment: {
      type: "string"
    }
  };
  const require$$16 = {
    $id: $id$2,
    $schema: $schema$2,
    type: type$1,
    required: required$1,
    properties: properties$2
  };
  const $id$1 = "timings.json#";
  const $schema$1 = "http://json-schema.org/draft-06/schema#";
  const required = [
    "send",
    "wait",
    "receive"
  ];
  const properties$1 = {
    dns: {
      type: "number",
      min: -1
    },
    connect: {
      type: "number",
      min: -1
    },
    blocked: {
      type: "number",
      min: -1
    },
    send: {
      type: "number",
      min: -1
    },
    wait: {
      type: "number",
      min: -1
    },
    receive: {
      type: "number",
      min: -1
    },
    ssl: {
      type: "number",
      min: -1
    },
    comment: {
      type: "string"
    }
  };
  const require$$17 = {
    $id: $id$1,
    $schema: $schema$1,
    required,
    properties: properties$1
  };
  var lib;
  var hasRequiredLib;
  function requireLib() {
    if (hasRequiredLib)
      return lib;
    hasRequiredLib = 1;
    lib = {
      afterRequest: require$$0,
      beforeRequest: require$$1,
      browser: require$$2,
      cache: require$$3$1,
      content: require$$4,
      cookie: require$$5,
      creator: require$$6,
      entry: require$$7,
      har: require$$8,
      header: require$$9,
      log: require$$10,
      page: require$$11,
      pageTimings: require$$12,
      postData: require$$13,
      query: require$$14,
      request: require$$15,
      response: require$$16,
      timings: require$$17
    };
    return lib;
  }
  const $schema = "http://json-schema.org/draft-06/schema#";
  const $id = "http://json-schema.org/draft-06/schema#";
  const title = "Core schema meta-schema";
  const definitions = {
    schemaArray: {
      type: "array",
      minItems: 1,
      items: {
        $ref: "#"
      }
    },
    nonNegativeInteger: {
      type: "integer",
      minimum: 0
    },
    nonNegativeIntegerDefault0: {
      allOf: [
        {
          $ref: "#/definitions/nonNegativeInteger"
        },
        {
          "default": 0
        }
      ]
    },
    simpleTypes: {
      "enum": [
        "array",
        "boolean",
        "integer",
        "null",
        "number",
        "object",
        "string"
      ]
    },
    stringArray: {
      type: "array",
      items: {
        type: "string"
      },
      uniqueItems: true,
      "default": []
    }
  };
  const type = [
    "object",
    "boolean"
  ];
  const properties = {
    $id: {
      type: "string",
      format: "uri-reference"
    },
    $schema: {
      type: "string",
      format: "uri"
    },
    $ref: {
      type: "string",
      format: "uri-reference"
    },
    title: {
      type: "string"
    },
    description: {
      type: "string"
    },
    "default": {},
    examples: {
      type: "array",
      items: {}
    },
    multipleOf: {
      type: "number",
      exclusiveMinimum: 0
    },
    maximum: {
      type: "number"
    },
    exclusiveMaximum: {
      type: "number"
    },
    minimum: {
      type: "number"
    },
    exclusiveMinimum: {
      type: "number"
    },
    maxLength: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minLength: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    pattern: {
      type: "string",
      format: "regex"
    },
    additionalItems: {
      $ref: "#"
    },
    items: {
      anyOf: [
        {
          $ref: "#"
        },
        {
          $ref: "#/definitions/schemaArray"
        }
      ],
      "default": {}
    },
    maxItems: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minItems: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    uniqueItems: {
      type: "boolean",
      "default": false
    },
    contains: {
      $ref: "#"
    },
    maxProperties: {
      $ref: "#/definitions/nonNegativeInteger"
    },
    minProperties: {
      $ref: "#/definitions/nonNegativeIntegerDefault0"
    },
    required: {
      $ref: "#/definitions/stringArray"
    },
    additionalProperties: {
      $ref: "#"
    },
    definitions: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      "default": {}
    },
    properties: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      "default": {}
    },
    patternProperties: {
      type: "object",
      additionalProperties: {
        $ref: "#"
      },
      "default": {}
    },
    dependencies: {
      type: "object",
      additionalProperties: {
        anyOf: [
          {
            $ref: "#"
          },
          {
            $ref: "#/definitions/stringArray"
          }
        ]
      }
    },
    propertyNames: {
      $ref: "#"
    },
    "const": {},
    "enum": {
      type: "array",
      minItems: 1,
      uniqueItems: true
    },
    type: {
      anyOf: [
        {
          $ref: "#/definitions/simpleTypes"
        },
        {
          type: "array",
          items: {
            $ref: "#/definitions/simpleTypes"
          },
          minItems: 1,
          uniqueItems: true
        }
      ]
    },
    format: {
      type: "string"
    },
    allOf: {
      $ref: "#/definitions/schemaArray"
    },
    anyOf: {
      $ref: "#/definitions/schemaArray"
    },
    oneOf: {
      $ref: "#/definitions/schemaArray"
    },
    not: {
      $ref: "#"
    }
  };
  const require$$3 = {
    $schema,
    $id,
    title,
    definitions,
    type,
    properties,
    "default": {}
  };
  var hasRequiredPromise;
  function requirePromise() {
    if (hasRequiredPromise)
      return promise;
    hasRequiredPromise = 1;
    var Ajv = requireAjv();
    var HARError = requireError();
    var schemas = requireLib();
    var ajv2;
    function createAjvInstance() {
      var ajv3 = new Ajv({
        allErrors: true
      });
      ajv3.addMetaSchema(require$$3);
      ajv3.addSchema(schemas);
      return ajv3;
    }
    function validate3(name, data2) {
      data2 = data2 || {};
      ajv2 = ajv2 || createAjvInstance();
      var validate4 = ajv2.getSchema(name + ".json");
      return new Promise(function(resolve, reject) {
        var valid = validate4(data2);
        !valid ? reject(new HARError(validate4.errors)) : resolve(data2);
      });
    }
    promise.afterRequest = function(data2) {
      return validate3("afterRequest", data2);
    };
    promise.beforeRequest = function(data2) {
      return validate3("beforeRequest", data2);
    };
    promise.browser = function(data2) {
      return validate3("browser", data2);
    };
    promise.cache = function(data2) {
      return validate3("cache", data2);
    };
    promise.content = function(data2) {
      return validate3("content", data2);
    };
    promise.cookie = function(data2) {
      return validate3("cookie", data2);
    };
    promise.creator = function(data2) {
      return validate3("creator", data2);
    };
    promise.entry = function(data2) {
      return validate3("entry", data2);
    };
    promise.har = function(data2) {
      return validate3("har", data2);
    };
    promise.header = function(data2) {
      return validate3("header", data2);
    };
    promise.log = function(data2) {
      return validate3("log", data2);
    };
    promise.page = function(data2) {
      return validate3("page", data2);
    };
    promise.pageTimings = function(data2) {
      return validate3("pageTimings", data2);
    };
    promise.postData = function(data2) {
      return validate3("postData", data2);
    };
    promise.query = function(data2) {
      return validate3("query", data2);
    };
    promise.request = function(data2) {
      return validate3("request", data2);
    };
    promise.response = function(data2) {
      return validate3("response", data2);
    };
    promise.timings = function(data2) {
      return validate3("timings", data2);
    };
    return promise;
  }
  var hasRequiredHar;
  function requireHar() {
    if (hasRequiredHar)
      return har;
    hasRequiredHar = 1;
    var fs = require$$0$2;
    var qs = require$$0$2;
    var validate3 = requirePromise();
    var extend3 = extend$1;
    function Har(request2) {
      this.request = request2;
    }
    Har.prototype.reducer = function(obj, pair) {
      if (obj[pair.name] === void 0) {
        obj[pair.name] = pair.value;
        return obj;
      }
      var arr = [
        obj[pair.name],
        pair.value
      ];
      obj[pair.name] = arr;
      return obj;
    };
    Har.prototype.prep = function(data2) {
      data2.queryObj = {};
      data2.headersObj = {};
      data2.postData.jsonObj = false;
      data2.postData.paramsObj = false;
      if (data2.queryString && data2.queryString.length) {
        data2.queryObj = data2.queryString.reduce(this.reducer, {});
      }
      if (data2.headers && data2.headers.length) {
        data2.headersObj = data2.headers.reduceRight(function(headers, header) {
          headers[header.name] = header.value;
          return headers;
        }, {});
      }
      if (data2.cookies && data2.cookies.length) {
        var cookies2 = data2.cookies.map(function(cookie2) {
          return cookie2.name + "=" + cookie2.value;
        });
        if (cookies2.length) {
          data2.headersObj.cookie = cookies2.join("; ");
        }
      }
      function some(arr) {
        return arr.some(function(type2) {
          return data2.postData.mimeType.indexOf(type2) === 0;
        });
      }
      if (some([
        "multipart/mixed",
        "multipart/related",
        "multipart/form-data",
        "multipart/alternative"
      ])) {
        data2.postData.mimeType = "multipart/form-data";
      } else if (some([
        "application/x-www-form-urlencoded"
      ])) {
        if (!data2.postData.params) {
          data2.postData.text = "";
        } else {
          data2.postData.paramsObj = data2.postData.params.reduce(this.reducer, {});
          data2.postData.text = qs.stringify(data2.postData.paramsObj);
        }
      } else if (some([
        "text/json",
        "text/x-json",
        "application/json",
        "application/x-json"
      ])) {
        data2.postData.mimeType = "application/json";
        if (data2.postData.text) {
          try {
            data2.postData.jsonObj = JSON.parse(data2.postData.text);
          } catch (e) {
            this.request.debug(e);
            data2.postData.mimeType = "text/plain";
          }
        }
      }
      return data2;
    };
    Har.prototype.options = function(options) {
      if (!options.har) {
        return options;
      }
      var har2 = {};
      extend3(har2, options.har);
      if (har2.log && har2.log.entries) {
        har2 = har2.log.entries[0];
      }
      har2.url = har2.url || options.url || options.uri || options.baseUrl || "/";
      har2.httpVersion = har2.httpVersion || "HTTP/1.1";
      har2.queryString = har2.queryString || [];
      har2.headers = har2.headers || [];
      har2.cookies = har2.cookies || [];
      har2.postData = har2.postData || {};
      har2.postData.mimeType = har2.postData.mimeType || "application/octet-stream";
      har2.bodySize = 0;
      har2.headersSize = 0;
      har2.postData.size = 0;
      if (!validate3.request(har2)) {
        return options;
      }
      var req = this.prep(har2);
      if (req.url) {
        options.url = req.url;
      }
      if (req.method) {
        options.method = req.method;
      }
      if (Object.keys(req.queryObj).length) {
        options.qs = req.queryObj;
      }
      if (Object.keys(req.headersObj).length) {
        options.headers = req.headersObj;
      }
      function test(type2) {
        return req.postData.mimeType.indexOf(type2) === 0;
      }
      if (test("application/x-www-form-urlencoded")) {
        options.form = req.postData.paramsObj;
      } else if (test("application/json")) {
        if (req.postData.jsonObj) {
          options.body = req.postData.jsonObj;
          options.json = true;
        }
      } else if (test("multipart/form-data")) {
        options.formData = {};
        req.postData.params.forEach(function(param) {
          var attachment = {};
          if (!param.fileName && !param.contentType) {
            options.formData[param.name] = param.value;
            return;
          }
          if (param.fileName && !param.value) {
            attachment.value = fs.createReadStream(param.fileName);
          } else if (param.value) {
            attachment.value = param.value;
          }
          if (param.fileName) {
            attachment.options = {
              filename: param.fileName,
              contentType: param.contentType ? param.contentType : null
            };
          }
          options.formData[param.name] = attachment;
        });
      } else {
        if (req.postData.text) {
          options.body = req.postData.text;
        }
      }
      return options;
    };
    har.Har = Har;
    return har;
  }
  var auth = {};
  var rngBrowser = { exports: {} };
  var hasRequiredRngBrowser;
  function requireRngBrowser() {
    if (hasRequiredRngBrowser)
      return rngBrowser.exports;
    hasRequiredRngBrowser = 1;
    var getRandomValues = typeof crypto != "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != "undefined" && typeof window.msCrypto.getRandomValues == "function" && msCrypto.getRandomValues.bind(msCrypto);
    if (getRandomValues) {
      var rnds8 = new Uint8Array(16);
      rngBrowser.exports = function whatwgRNG() {
        getRandomValues(rnds8);
        return rnds8;
      };
    } else {
      var rnds = new Array(16);
      rngBrowser.exports = function mathRNG() {
        for (var i2 = 0, r; i2 < 16; i2++) {
          if ((i2 & 3) === 0)
            r = Math.random() * 4294967296;
          rnds[i2] = r >>> ((i2 & 3) << 3) & 255;
        }
        return rnds;
      };
    }
    return rngBrowser.exports;
  }
  var bytesToUuid_1;
  var hasRequiredBytesToUuid;
  function requireBytesToUuid() {
    if (hasRequiredBytesToUuid)
      return bytesToUuid_1;
    hasRequiredBytesToUuid = 1;
    var byteToHex = [];
    for (var i2 = 0; i2 < 256; ++i2) {
      byteToHex[i2] = (i2 + 256).toString(16).substr(1);
    }
    function bytesToUuid(buf, offset) {
      var i3 = offset || 0;
      var bth = byteToHex;
      return [
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]],
        "-",
        bth[buf[i3++]],
        bth[buf[i3++]],
        "-",
        bth[buf[i3++]],
        bth[buf[i3++]],
        "-",
        bth[buf[i3++]],
        bth[buf[i3++]],
        "-",
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]],
        bth[buf[i3++]]
      ].join("");
    }
    bytesToUuid_1 = bytesToUuid;
    return bytesToUuid_1;
  }
  var v4_1;
  var hasRequiredV4;
  function requireV4() {
    if (hasRequiredV4)
      return v4_1;
    hasRequiredV4 = 1;
    var rng = requireRngBrowser();
    var bytesToUuid = requireBytesToUuid();
    function v4(options, buf, offset) {
      var i2 = buf && offset || 0;
      if (typeof options == "string") {
        buf = options === "binary" ? new Array(16) : null;
        options = null;
      }
      options = options || {};
      var rnds = options.random || (options.rng || rng)();
      rnds[6] = rnds[6] & 15 | 64;
      rnds[8] = rnds[8] & 63 | 128;
      if (buf) {
        for (var ii = 0; ii < 16; ++ii) {
          buf[i2 + ii] = rnds[ii];
        }
      }
      return buf || bytesToUuid(rnds);
    }
    v4_1 = v4;
    return v4_1;
  }
  var hasRequiredAuth;
  function requireAuth() {
    if (hasRequiredAuth)
      return auth;
    hasRequiredAuth = 1;
    var caseless2 = requireCaseless();
    var uuid = requireV4();
    var helpers2 = helpers$1;
    var md52 = helpers2.md5;
    var toBase642 = helpers2.toBase64;
    function Auth(request2) {
      this.request = request2;
      this.hasAuth = false;
      this.sentAuth = false;
      this.bearerToken = null;
      this.user = null;
      this.pass = null;
    }
    Auth.prototype.basic = function(user, pass, sendImmediately) {
      var self2 = this;
      if (typeof user !== "string" || pass !== void 0 && typeof pass !== "string") {
        self2.request.emit("error", new Error("auth() received invalid user or password"));
      }
      self2.user = user;
      self2.pass = pass;
      self2.hasAuth = true;
      var header = user + ":" + (pass || "");
      if (sendImmediately || typeof sendImmediately === "undefined") {
        var authHeader = "Basic " + toBase642(header);
        self2.sentAuth = true;
        return authHeader;
      }
    };
    Auth.prototype.bearer = function(bearer, sendImmediately) {
      var self2 = this;
      self2.bearerToken = bearer;
      self2.hasAuth = true;
      if (sendImmediately || typeof sendImmediately === "undefined") {
        if (typeof bearer === "function") {
          bearer = bearer();
        }
        var authHeader = "Bearer " + (bearer || "");
        self2.sentAuth = true;
        return authHeader;
      }
    };
    Auth.prototype.digest = function(method, path, authHeader) {
      var self2 = this;
      var challenge = {};
      var re = /([a-z0-9_-]+)=(?:"([^"]+)"|([a-z0-9_-]+))/gi;
      while (true) {
        var match = re.exec(authHeader);
        if (!match) {
          break;
        }
        challenge[match[1]] = match[2] || match[3];
      }
      var ha1Compute = function(algorithm, user, realm, pass, nonce, cnonce2) {
        var ha12 = md52(user + ":" + realm + ":" + pass);
        if (algorithm && algorithm.toLowerCase() === "md5-sess") {
          return md52(ha12 + ":" + nonce + ":" + cnonce2);
        } else {
          return ha12;
        }
      };
      var qop = /(^|,)\s*auth\s*($|,)/.test(challenge.qop) && "auth";
      var nc = qop && "00000001";
      var cnonce = qop && uuid().replace(/-/g, "");
      var ha1 = ha1Compute(challenge.algorithm, self2.user, challenge.realm, self2.pass, challenge.nonce, cnonce);
      var ha2 = md52(method + ":" + path);
      var digestResponse = qop ? md52(ha1 + ":" + challenge.nonce + ":" + nc + ":" + cnonce + ":" + qop + ":" + ha2) : md52(ha1 + ":" + challenge.nonce + ":" + ha2);
      var authValues = {
        username: self2.user,
        realm: challenge.realm,
        nonce: challenge.nonce,
        uri: path,
        qop,
        response: digestResponse,
        nc,
        cnonce,
        algorithm: challenge.algorithm,
        opaque: challenge.opaque
      };
      authHeader = [];
      for (var k in authValues) {
        if (authValues[k]) {
          if (k === "qop" || k === "nc" || k === "algorithm") {
            authHeader.push(k + "=" + authValues[k]);
          } else {
            authHeader.push(k + '="' + authValues[k] + '"');
          }
        }
      }
      authHeader = "Digest " + authHeader.join(", ");
      self2.sentAuth = true;
      return authHeader;
    };
    Auth.prototype.onRequest = function(user, pass, sendImmediately, bearer) {
      var self2 = this;
      var request2 = self2.request;
      var authHeader;
      if (bearer === void 0 && user === void 0) {
        self2.request.emit("error", new Error("no auth mechanism defined"));
      } else if (bearer !== void 0) {
        authHeader = self2.bearer(bearer, sendImmediately);
      } else {
        authHeader = self2.basic(user, pass, sendImmediately);
      }
      if (authHeader) {
        request2.setHeader("authorization", authHeader);
      }
    };
    Auth.prototype.onResponse = function(response) {
      var self2 = this;
      var request2 = self2.request;
      if (!self2.hasAuth || self2.sentAuth) {
        return null;
      }
      var c2 = caseless2(response.headers);
      var authHeader = c2.get("www-authenticate");
      var authVerb = authHeader && authHeader.split(" ")[0].toLowerCase();
      request2.debug("reauth", authVerb);
      switch (authVerb) {
        case "basic":
          return self2.basic(self2.user, self2.pass, true);
        case "bearer":
          return self2.bearer(self2.bearerToken, true);
        case "digest":
          return self2.digest(request2.method, request2.path, authHeader);
      }
    };
    auth.Auth = Auth;
    return auth;
  }
  var oauth = {};
  var oauthSign = {};
  var hasRequiredOauthSign;
  function requireOauthSign() {
    if (hasRequiredOauthSign)
      return oauthSign;
    hasRequiredOauthSign = 1;
    var crypto2 = require$$0$2;
    function sha(key2, body, algorithm) {
      return crypto2.createHmac(algorithm, key2).update(body).digest("base64");
    }
    function rsa(key2, body) {
      return crypto2.createSign("RSA-SHA1").update(body).sign(key2, "base64");
    }
    function rfc3986(str) {
      return encodeURIComponent(str).replace(/!/g, "%21").replace(/\*/g, "%2A").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/'/g, "%27");
    }
    function map2(obj) {
      var key2, val, arr = [];
      for (key2 in obj) {
        val = obj[key2];
        if (Array.isArray(val))
          for (var i2 = 0; i2 < val.length; i2++)
            arr.push([key2, val[i2]]);
        else if (typeof val === "object")
          for (var prop in val)
            arr.push([key2 + "[" + prop + "]", val[prop]]);
        else
          arr.push([key2, val]);
      }
      return arr;
    }
    function compare(a2, b2) {
      return a2 > b2 ? 1 : a2 < b2 ? -1 : 0;
    }
    function generateBase(httpMethod, base_uri, params) {
      var normalized = map2(params).map(function(p) {
        return [rfc3986(p[0]), rfc3986(p[1] || "")];
      }).sort(function(a2, b2) {
        return compare(a2[0], b2[0]) || compare(a2[1], b2[1]);
      }).map(function(p) {
        return p.join("=");
      }).join("&");
      var base2 = [
        rfc3986(httpMethod ? httpMethod.toUpperCase() : "GET"),
        rfc3986(base_uri),
        rfc3986(normalized)
      ].join("&");
      return base2;
    }
    function hmacsign(httpMethod, base_uri, params, consumer_secret, token_secret) {
      var base2 = generateBase(httpMethod, base_uri, params);
      var key2 = [
        consumer_secret || "",
        token_secret || ""
      ].map(rfc3986).join("&");
      return sha(key2, base2, "sha1");
    }
    function hmacsign256(httpMethod, base_uri, params, consumer_secret, token_secret) {
      var base2 = generateBase(httpMethod, base_uri, params);
      var key2 = [
        consumer_secret || "",
        token_secret || ""
      ].map(rfc3986).join("&");
      return sha(key2, base2, "sha256");
    }
    function rsasign(httpMethod, base_uri, params, private_key, token_secret) {
      var base2 = generateBase(httpMethod, base_uri, params);
      var key2 = private_key || "";
      return rsa(key2, base2);
    }
    function plaintext(consumer_secret, token_secret) {
      var key2 = [
        consumer_secret || "",
        token_secret || ""
      ].map(rfc3986).join("&");
      return key2;
    }
    function sign(signMethod, httpMethod, base_uri, params, consumer_secret, token_secret) {
      var method;
      var skipArgs = 1;
      switch (signMethod) {
        case "RSA-SHA1":
          method = rsasign;
          break;
        case "HMAC-SHA1":
          method = hmacsign;
          break;
        case "HMAC-SHA256":
          method = hmacsign256;
          break;
        case "PLAINTEXT":
          method = plaintext;
          skipArgs = 4;
          break;
        default:
          throw new Error("Signature method not supported: " + signMethod);
      }
      return method.apply(null, [].slice.call(arguments, skipArgs));
    }
    oauthSign.hmacsign = hmacsign;
    oauthSign.hmacsign256 = hmacsign256;
    oauthSign.rsasign = rsasign;
    oauthSign.plaintext = plaintext;
    oauthSign.sign = sign;
    oauthSign.rfc3986 = rfc3986;
    oauthSign.generateBase = generateBase;
    return oauthSign;
  }
  var hasRequiredOauth;
  function requireOauth() {
    if (hasRequiredOauth)
      return oauth;
    hasRequiredOauth = 1;
    var url = require$$0$2;
    var qs = requireLib$1();
    var caseless2 = requireCaseless();
    var uuid = requireV4();
    var oauth$1 = requireOauthSign();
    var crypto2 = require$$0$2;
    var Buffer2 = safeBufferExports.Buffer;
    function OAuth(request2) {
      this.request = request2;
      this.params = null;
    }
    OAuth.prototype.buildParams = function(_oauth, uri, method, query, form, qsLib) {
      var oa = {};
      for (var i2 in _oauth) {
        oa["oauth_" + i2] = _oauth[i2];
      }
      if (!oa.oauth_version) {
        oa.oauth_version = "1.0";
      }
      if (!oa.oauth_timestamp) {
        oa.oauth_timestamp = Math.floor(Date.now() / 1e3).toString();
      }
      if (!oa.oauth_nonce) {
        oa.oauth_nonce = uuid().replace(/-/g, "");
      }
      if (!oa.oauth_signature_method) {
        oa.oauth_signature_method = "HMAC-SHA1";
      }
      var consumer_secret_or_private_key = oa.oauth_consumer_secret || oa.oauth_private_key;
      delete oa.oauth_consumer_secret;
      delete oa.oauth_private_key;
      var token_secret = oa.oauth_token_secret;
      delete oa.oauth_token_secret;
      var realm = oa.oauth_realm;
      delete oa.oauth_realm;
      delete oa.oauth_transport_method;
      var baseurl = uri.protocol + "//" + uri.host + uri.pathname;
      var params = qsLib.parse([].concat(query, form, qsLib.stringify(oa)).join("&"));
      oa.oauth_signature = oauth$1.sign(
        oa.oauth_signature_method,
        method,
        baseurl,
        params,
        consumer_secret_or_private_key,
        // eslint-disable-line camelcase
        token_secret
        // eslint-disable-line camelcase
      );
      if (realm) {
        oa.realm = realm;
      }
      return oa;
    };
    OAuth.prototype.buildBodyHash = function(_oauth, body) {
      if (["HMAC-SHA1", "RSA-SHA1"].indexOf(_oauth.signature_method || "HMAC-SHA1") < 0) {
        this.request.emit("error", new Error("oauth: " + _oauth.signature_method + " signature_method not supported with body_hash signing."));
      }
      var shasum = crypto2.createHash("sha1");
      shasum.update(body || "");
      var sha12 = shasum.digest("hex");
      return Buffer2.from(sha12, "hex").toString("base64");
    };
    OAuth.prototype.concatParams = function(oa, sep, wrap) {
      wrap = wrap || "";
      var params = Object.keys(oa).filter(function(i2) {
        return i2 !== "realm" && i2 !== "oauth_signature";
      }).sort();
      if (oa.realm) {
        params.splice(0, 0, "realm");
      }
      params.push("oauth_signature");
      return params.map(function(i2) {
        return i2 + "=" + wrap + oauth$1.rfc3986(oa[i2]) + wrap;
      }).join(sep);
    };
    OAuth.prototype.onRequest = function(_oauth) {
      var self2 = this;
      self2.params = _oauth;
      var uri = self2.request.uri || {};
      var method = self2.request.method || "";
      var headers = caseless2(self2.request.headers);
      var body = self2.request.body || "";
      var qsLib = self2.request.qsLib || qs;
      var form;
      var query;
      var contentType = headers.get("content-type") || "";
      var formContentType = "application/x-www-form-urlencoded";
      var transport = _oauth.transport_method || "header";
      if (contentType.slice(0, formContentType.length) === formContentType) {
        contentType = formContentType;
        form = body;
      }
      if (uri.query) {
        query = uri.query;
      }
      if (transport === "body" && (method !== "POST" || contentType !== formContentType)) {
        self2.request.emit("error", new Error("oauth: transport_method of body requires POST and content-type " + formContentType));
      }
      if (!form && typeof _oauth.body_hash === "boolean") {
        _oauth.body_hash = self2.buildBodyHash(_oauth, self2.request.body.toString());
      }
      var oa = self2.buildParams(_oauth, uri, method, query, form, qsLib);
      switch (transport) {
        case "header":
          self2.request.setHeader("Authorization", "OAuth " + self2.concatParams(oa, ",", '"'));
          break;
        case "query":
          var href = self2.request.uri.href += (query ? "&" : "?") + self2.concatParams(oa, "&");
          self2.request.uri = url.parse(href);
          self2.request.path = self2.request.uri.path;
          break;
        case "body":
          self2.request.body = (form ? form + "&" : "") + self2.concatParams(oa, "&");
          break;
        default:
          self2.request.emit("error", new Error("oauth: transport_method invalid"));
      }
    };
    oauth.OAuth = OAuth;
    return oauth;
  }
  var hawk = {};
  var hasRequiredHawk;
  function requireHawk() {
    if (hasRequiredHawk)
      return hawk;
    hasRequiredHawk = 1;
    (function(exports) {
      var crypto2 = require$$0$2;
      function randomString(size) {
        var bits = (size + 1) * 6;
        var buffer = crypto2.randomBytes(Math.ceil(bits / 8));
        var string = buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
        return string.slice(0, size);
      }
      function calculatePayloadHash(payload, algorithm, contentType) {
        var hash = crypto2.createHash(algorithm);
        hash.update("hawk.1.payload\n");
        hash.update((contentType ? contentType.split(";")[0].trim().toLowerCase() : "") + "\n");
        hash.update(payload || "");
        hash.update("\n");
        return hash.digest("base64");
      }
      exports.calculateMac = function(credentials, opts) {
        var normalized = "hawk.1.header\n" + opts.ts + "\n" + opts.nonce + "\n" + (opts.method || "").toUpperCase() + "\n" + opts.resource + "\n" + opts.host.toLowerCase() + "\n" + opts.port + "\n" + (opts.hash || "") + "\n";
        if (opts.ext) {
          normalized = normalized + opts.ext.replace("\\", "\\\\").replace("\n", "\\n");
        }
        normalized = normalized + "\n";
        if (opts.app) {
          normalized = normalized + opts.app + "\n" + (opts.dlg || "") + "\n";
        }
        var hmac2 = crypto2.createHmac(credentials.algorithm, credentials.key).update(normalized);
        var digest = hmac2.digest("base64");
        return digest;
      };
      exports.header = function(uri, method, opts) {
        var timestamp = opts.timestamp || Math.floor((Date.now() + (opts.localtimeOffsetMsec || 0)) / 1e3);
        var credentials = opts.credentials;
        if (!credentials || !credentials.id || !credentials.key || !credentials.algorithm) {
          return "";
        }
        if (["sha1", "sha256"].indexOf(credentials.algorithm) === -1) {
          return "";
        }
        var artifacts = {
          ts: timestamp,
          nonce: opts.nonce || randomString(6),
          method,
          resource: uri.pathname + (uri.search || ""),
          host: uri.hostname,
          port: uri.port || (uri.protocol === "http:" ? 80 : 443),
          hash: opts.hash,
          ext: opts.ext,
          app: opts.app,
          dlg: opts.dlg
        };
        if (!artifacts.hash && (opts.payload || opts.payload === "")) {
          artifacts.hash = calculatePayloadHash(opts.payload, credentials.algorithm, opts.contentType);
        }
        var mac = exports.calculateMac(credentials, artifacts);
        var hasExt = artifacts.ext !== null && artifacts.ext !== void 0 && artifacts.ext !== "";
        var header = 'Hawk id="' + credentials.id + '", ts="' + artifacts.ts + '", nonce="' + artifacts.nonce + (artifacts.hash ? '", hash="' + artifacts.hash : "") + (hasExt ? '", ext="' + artifacts.ext.replace(/\\/g, "\\\\").replace(/"/g, '\\"') : "") + '", mac="' + mac + '"';
        if (artifacts.app) {
          header = header + ', app="' + artifacts.app + (artifacts.dlg ? '", dlg="' + artifacts.dlg : "") + '"';
        }
        return header;
      };
    })(hawk);
    return hawk;
  }
  var multipart = {};
  var delayed_stream;
  var hasRequiredDelayed_stream;
  function requireDelayed_stream() {
    if (hasRequiredDelayed_stream)
      return delayed_stream;
    hasRequiredDelayed_stream = 1;
    var Stream = require$$0$2.Stream;
    var util2 = require$$0$2;
    delayed_stream = DelayedStream;
    function DelayedStream() {
      this.source = null;
      this.dataSize = 0;
      this.maxDataSize = 1024 * 1024;
      this.pauseStream = true;
      this._maxDataSizeExceeded = false;
      this._released = false;
      this._bufferedEvents = [];
    }
    util2.inherits(DelayedStream, Stream);
    DelayedStream.create = function(source, options) {
      var delayedStream = new this();
      options = options || {};
      for (var option in options) {
        delayedStream[option] = options[option];
      }
      delayedStream.source = source;
      var realEmit = source.emit;
      source.emit = function() {
        delayedStream._handleEmit(arguments);
        return realEmit.apply(source, arguments);
      };
      source.on("error", function() {
      });
      if (delayedStream.pauseStream) {
        source.pause();
      }
      return delayedStream;
    };
    Object.defineProperty(DelayedStream.prototype, "readable", {
      configurable: true,
      enumerable: true,
      get: function() {
        return this.source.readable;
      }
    });
    DelayedStream.prototype.setEncoding = function() {
      return this.source.setEncoding.apply(this.source, arguments);
    };
    DelayedStream.prototype.resume = function() {
      if (!this._released) {
        this.release();
      }
      this.source.resume();
    };
    DelayedStream.prototype.pause = function() {
      this.source.pause();
    };
    DelayedStream.prototype.release = function() {
      this._released = true;
      this._bufferedEvents.forEach((function(args) {
        this.emit.apply(this, args);
      }).bind(this));
      this._bufferedEvents = [];
    };
    DelayedStream.prototype.pipe = function() {
      var r = Stream.prototype.pipe.apply(this, arguments);
      this.resume();
      return r;
    };
    DelayedStream.prototype._handleEmit = function(args) {
      if (this._released) {
        this.emit.apply(this, args);
        return;
      }
      if (args[0] === "data") {
        this.dataSize += args[1].length;
        this._checkIfMaxDataSizeExceeded();
      }
      this._bufferedEvents.push(args);
    };
    DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
      if (this._maxDataSizeExceeded) {
        return;
      }
      if (this.dataSize <= this.maxDataSize) {
        return;
      }
      this._maxDataSizeExceeded = true;
      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
      this.emit("error", new Error(message));
    };
    return delayed_stream;
  }
  var combined_stream;
  var hasRequiredCombined_stream;
  function requireCombined_stream() {
    if (hasRequiredCombined_stream)
      return combined_stream;
    hasRequiredCombined_stream = 1;
    var util2 = require$$0$2;
    var Stream = require$$0$2.Stream;
    var DelayedStream = requireDelayed_stream();
    combined_stream = CombinedStream;
    function CombinedStream() {
      this.writable = false;
      this.readable = true;
      this.dataSize = 0;
      this.maxDataSize = 2 * 1024 * 1024;
      this.pauseStreams = true;
      this._released = false;
      this._streams = [];
      this._currentStream = null;
      this._insideLoop = false;
      this._pendingNext = false;
    }
    util2.inherits(CombinedStream, Stream);
    CombinedStream.create = function(options) {
      var combinedStream = new this();
      options = options || {};
      for (var option in options) {
        combinedStream[option] = options[option];
      }
      return combinedStream;
    };
    CombinedStream.isStreamLike = function(stream) {
      return typeof stream !== "function" && typeof stream !== "string" && typeof stream !== "boolean" && typeof stream !== "number" && !Buffer.isBuffer(stream);
    };
    CombinedStream.prototype.append = function(stream) {
      var isStreamLike = CombinedStream.isStreamLike(stream);
      if (isStreamLike) {
        if (!(stream instanceof DelayedStream)) {
          var newStream = DelayedStream.create(stream, {
            maxDataSize: Infinity,
            pauseStream: this.pauseStreams
          });
          stream.on("data", this._checkDataSize.bind(this));
          stream = newStream;
        }
        this._handleErrors(stream);
        if (this.pauseStreams) {
          stream.pause();
        }
      }
      this._streams.push(stream);
      return this;
    };
    CombinedStream.prototype.pipe = function(dest, options) {
      Stream.prototype.pipe.call(this, dest, options);
      this.resume();
      return dest;
    };
    CombinedStream.prototype._getNext = function() {
      this._currentStream = null;
      if (this._insideLoop) {
        this._pendingNext = true;
        return;
      }
      this._insideLoop = true;
      try {
        do {
          this._pendingNext = false;
          this._realGetNext();
        } while (this._pendingNext);
      } finally {
        this._insideLoop = false;
      }
    };
    CombinedStream.prototype._realGetNext = function() {
      var stream = this._streams.shift();
      if (typeof stream == "undefined") {
        this.end();
        return;
      }
      if (typeof stream !== "function") {
        this._pipeNext(stream);
        return;
      }
      var getStream = stream;
      getStream((function(stream2) {
        var isStreamLike = CombinedStream.isStreamLike(stream2);
        if (isStreamLike) {
          stream2.on("data", this._checkDataSize.bind(this));
          this._handleErrors(stream2);
        }
        this._pipeNext(stream2);
      }).bind(this));
    };
    CombinedStream.prototype._pipeNext = function(stream) {
      this._currentStream = stream;
      var isStreamLike = CombinedStream.isStreamLike(stream);
      if (isStreamLike) {
        stream.on("end", this._getNext.bind(this));
        stream.pipe(this, { end: false });
        return;
      }
      var value = stream;
      this.write(value);
      this._getNext();
    };
    CombinedStream.prototype._handleErrors = function(stream) {
      var self2 = this;
      stream.on("error", function(err) {
        self2._emitError(err);
      });
    };
    CombinedStream.prototype.write = function(data2) {
      this.emit("data", data2);
    };
    CombinedStream.prototype.pause = function() {
      if (!this.pauseStreams) {
        return;
      }
      if (this.pauseStreams && this._currentStream && typeof this._currentStream.pause == "function")
        this._currentStream.pause();
      this.emit("pause");
    };
    CombinedStream.prototype.resume = function() {
      if (!this._released) {
        this._released = true;
        this.writable = true;
        this._getNext();
      }
      if (this.pauseStreams && this._currentStream && typeof this._currentStream.resume == "function")
        this._currentStream.resume();
      this.emit("resume");
    };
    CombinedStream.prototype.end = function() {
      this._reset();
      this.emit("end");
    };
    CombinedStream.prototype.destroy = function() {
      this._reset();
      this.emit("close");
    };
    CombinedStream.prototype._reset = function() {
      this.writable = false;
      this._streams = [];
      this._currentStream = null;
    };
    CombinedStream.prototype._checkDataSize = function() {
      this._updateDataSize();
      if (this.dataSize <= this.maxDataSize) {
        return;
      }
      var message = "DelayedStream#maxDataSize of " + this.maxDataSize + " bytes exceeded.";
      this._emitError(new Error(message));
    };
    CombinedStream.prototype._updateDataSize = function() {
      this.dataSize = 0;
      var self2 = this;
      this._streams.forEach(function(stream) {
        if (!stream.dataSize) {
          return;
        }
        self2.dataSize += stream.dataSize;
      });
      if (this._currentStream && this._currentStream.dataSize) {
        this.dataSize += this._currentStream.dataSize;
      }
    };
    CombinedStream.prototype._emitError = function(err) {
      this._reset();
      this.emit("error", err);
    };
    return combined_stream;
  }
  var hasRequiredMultipart;
  function requireMultipart() {
    if (hasRequiredMultipart)
      return multipart;
    hasRequiredMultipart = 1;
    var uuid = requireV4();
    var CombinedStream = requireCombined_stream();
    var isstream2 = requireIsstream();
    var Buffer2 = safeBufferExports.Buffer;
    function Multipart(request2) {
      this.request = request2;
      this.boundary = uuid();
      this.chunked = false;
      this.body = null;
    }
    Multipart.prototype.isChunked = function(options) {
      var self2 = this;
      var chunked = false;
      var parts = options.data || options;
      if (!parts.forEach) {
        self2.request.emit("error", new Error("Argument error, options.multipart."));
      }
      if (options.chunked !== void 0) {
        chunked = options.chunked;
      }
      if (self2.request.getHeader("transfer-encoding") === "chunked") {
        chunked = true;
      }
      if (!chunked) {
        parts.forEach(function(part) {
          if (typeof part.body === "undefined") {
            self2.request.emit("error", new Error("Body attribute missing in multipart."));
          }
          if (isstream2(part.body)) {
            chunked = true;
          }
        });
      }
      return chunked;
    };
    Multipart.prototype.setHeaders = function(chunked) {
      var self2 = this;
      if (chunked && !self2.request.hasHeader("transfer-encoding")) {
        self2.request.setHeader("transfer-encoding", "chunked");
      }
      var header = self2.request.getHeader("content-type");
      if (!header || header.indexOf("multipart") === -1) {
        self2.request.setHeader("content-type", "multipart/related; boundary=" + self2.boundary);
      } else {
        if (header.indexOf("boundary") !== -1) {
          self2.boundary = header.replace(/.*boundary=([^\s;]+).*/, "$1");
        } else {
          self2.request.setHeader("content-type", header + "; boundary=" + self2.boundary);
        }
      }
    };
    Multipart.prototype.build = function(parts, chunked) {
      var self2 = this;
      var body = chunked ? new CombinedStream() : [];
      function add(part) {
        if (typeof part === "number") {
          part = part.toString();
        }
        return chunked ? body.append(part) : body.push(Buffer2.from(part));
      }
      if (self2.request.preambleCRLF) {
        add("\r\n");
      }
      parts.forEach(function(part) {
        var preamble = "--" + self2.boundary + "\r\n";
        Object.keys(part).forEach(function(key2) {
          if (key2 === "body") {
            return;
          }
          preamble += key2 + ": " + part[key2] + "\r\n";
        });
        preamble += "\r\n";
        add(preamble);
        add(part.body);
        add("\r\n");
      });
      add("--" + self2.boundary + "--");
      if (self2.request.postambleCRLF) {
        add("\r\n");
      }
      return body;
    };
    Multipart.prototype.onRequest = function(options) {
      var self2 = this;
      var chunked = self2.isChunked(options);
      var parts = options.data || options;
      self2.setHeaders(chunked);
      self2.chunked = chunked;
      self2.body = self2.build(parts, chunked);
    };
    multipart.Multipart = Multipart;
    return multipart;
  }
  var redirect = {};
  var hasRequiredRedirect;
  function requireRedirect() {
    if (hasRequiredRedirect)
      return redirect;
    hasRequiredRedirect = 1;
    var url = require$$0$2;
    var isUrl = /^https?:/;
    function Redirect(request2) {
      this.request = request2;
      this.followRedirect = true;
      this.followRedirects = true;
      this.followAllRedirects = false;
      this.followOriginalHttpMethod = false;
      this.allowRedirect = function() {
        return true;
      };
      this.maxRedirects = 10;
      this.redirects = [];
      this.redirectsFollowed = 0;
      this.removeRefererHeader = false;
    }
    Redirect.prototype.onRequest = function(options) {
      var self2 = this;
      if (options.maxRedirects !== void 0) {
        self2.maxRedirects = options.maxRedirects;
      }
      if (typeof options.followRedirect === "function") {
        self2.allowRedirect = options.followRedirect;
      }
      if (options.followRedirect !== void 0) {
        self2.followRedirects = !!options.followRedirect;
      }
      if (options.followAllRedirects !== void 0) {
        self2.followAllRedirects = options.followAllRedirects;
      }
      if (self2.followRedirects || self2.followAllRedirects) {
        self2.redirects = self2.redirects || [];
      }
      if (options.removeRefererHeader !== void 0) {
        self2.removeRefererHeader = options.removeRefererHeader;
      }
      if (options.followOriginalHttpMethod !== void 0) {
        self2.followOriginalHttpMethod = options.followOriginalHttpMethod;
      }
    };
    Redirect.prototype.redirectTo = function(response) {
      var self2 = this;
      var request2 = self2.request;
      var redirectTo = null;
      if (response.statusCode >= 300 && response.statusCode < 400 && response.caseless.has("location")) {
        var location = response.caseless.get("location");
        request2.debug("redirect", location);
        if (self2.followAllRedirects) {
          redirectTo = location;
        } else if (self2.followRedirects) {
          switch (request2.method) {
            case "PATCH":
            case "PUT":
            case "POST":
            case "DELETE":
              break;
            default:
              redirectTo = location;
              break;
          }
        }
      } else if (response.statusCode === 401) {
        var authHeader = request2._auth.onResponse(response);
        if (authHeader) {
          request2.setHeader("authorization", authHeader);
          redirectTo = request2.uri;
        }
      }
      return redirectTo;
    };
    Redirect.prototype.onResponse = function(response) {
      var self2 = this;
      var request2 = self2.request;
      var redirectTo = self2.redirectTo(response);
      if (!redirectTo || !self2.allowRedirect.call(request2, response)) {
        return false;
      }
      request2.debug("redirect to", redirectTo);
      if (response.resume) {
        response.resume();
      }
      if (self2.redirectsFollowed >= self2.maxRedirects) {
        request2.emit("error", new Error("Exceeded maxRedirects. Probably stuck in a redirect loop " + request2.uri.href));
        return false;
      }
      self2.redirectsFollowed += 1;
      if (!isUrl.test(redirectTo)) {
        redirectTo = url.resolve(request2.uri.href, redirectTo);
      }
      var uriPrev = request2.uri;
      request2.uri = url.parse(redirectTo);
      if (request2.uri.protocol !== uriPrev.protocol) {
        delete request2.agent;
      }
      self2.redirects.push({ statusCode: response.statusCode, redirectUri: redirectTo });
      if (self2.followAllRedirects && request2.method !== "HEAD" && response.statusCode !== 401 && response.statusCode !== 307) {
        request2.method = self2.followOriginalHttpMethod ? request2.method : "GET";
      }
      delete request2.src;
      delete request2.req;
      delete request2._started;
      if (response.statusCode !== 401 && response.statusCode !== 307) {
        delete request2.body;
        delete request2._form;
        if (request2.headers) {
          request2.removeHeader("host");
          request2.removeHeader("content-type");
          request2.removeHeader("content-length");
          if (request2.uri.hostname !== request2.originalHost.split(":")[0]) {
            request2.removeHeader("authorization");
          }
        }
      }
      if (!self2.removeRefererHeader) {
        request2.setHeader("referer", uriPrev.href);
      }
      request2.emit("redirect");
      request2.init();
      return true;
    };
    redirect.Redirect = Redirect;
    return redirect;
  }
  var tunnel = {};
  var tunnelAgent = {};
  var hasRequiredTunnelAgent;
  function requireTunnelAgent() {
    if (hasRequiredTunnelAgent)
      return tunnelAgent;
    hasRequiredTunnelAgent = 1;
    var tls = require$$0$2, http = require$$0$2, https = require$$0$2, events = require$$0$2, assert = require$$0$2, util2 = require$$0$2, Buffer2 = safeBufferExports.Buffer;
    tunnelAgent.httpOverHttp = httpOverHttp;
    tunnelAgent.httpsOverHttp = httpsOverHttp;
    tunnelAgent.httpOverHttps = httpOverHttps;
    tunnelAgent.httpsOverHttps = httpsOverHttps;
    function httpOverHttp(options) {
      var agent = new TunnelingAgent(options);
      agent.request = http.request;
      return agent;
    }
    function httpsOverHttp(options) {
      var agent = new TunnelingAgent(options);
      agent.request = http.request;
      agent.createSocket = createSecureSocket;
      agent.defaultPort = 443;
      return agent;
    }
    function httpOverHttps(options) {
      var agent = new TunnelingAgent(options);
      agent.request = https.request;
      return agent;
    }
    function httpsOverHttps(options) {
      var agent = new TunnelingAgent(options);
      agent.request = https.request;
      agent.createSocket = createSecureSocket;
      agent.defaultPort = 443;
      return agent;
    }
    function TunnelingAgent(options) {
      var self2 = this;
      self2.options = options || {};
      self2.proxyOptions = self2.options.proxy || {};
      self2.maxSockets = self2.options.maxSockets || http.Agent.defaultMaxSockets;
      self2.requests = [];
      self2.sockets = [];
      self2.on("free", function onFree(socket, host, port) {
        for (var i2 = 0, len = self2.requests.length; i2 < len; ++i2) {
          var pending = self2.requests[i2];
          if (pending.host === host && pending.port === port) {
            self2.requests.splice(i2, 1);
            pending.request.onSocket(socket);
            return;
          }
        }
        socket.destroy();
        self2.removeSocket(socket);
      });
    }
    util2.inherits(TunnelingAgent, events.EventEmitter);
    TunnelingAgent.prototype.addRequest = function addRequest(req, options) {
      var self2 = this;
      if (typeof options === "string") {
        options = {
          host: options,
          port: arguments[2],
          path: arguments[3]
        };
      }
      if (self2.sockets.length >= this.maxSockets) {
        self2.requests.push({ host: options.host, port: options.port, request: req });
        return;
      }
      self2.createConnection({ host: options.host, port: options.port, request: req });
    };
    TunnelingAgent.prototype.createConnection = function createConnection(pending) {
      var self2 = this;
      self2.createSocket(pending, function(socket) {
        socket.on("free", onFree);
        socket.on("close", onCloseOrRemove);
        socket.on("agentRemove", onCloseOrRemove);
        pending.request.onSocket(socket);
        function onFree() {
          self2.emit("free", socket, pending.host, pending.port);
        }
        function onCloseOrRemove(err) {
          self2.removeSocket(socket);
          socket.removeListener("free", onFree);
          socket.removeListener("close", onCloseOrRemove);
          socket.removeListener("agentRemove", onCloseOrRemove);
        }
      });
    };
    TunnelingAgent.prototype.createSocket = function createSocket(options, cb) {
      var self2 = this;
      var placeholder = {};
      self2.sockets.push(placeholder);
      var connectOptions = mergeOptions(
        {},
        self2.proxyOptions,
        {
          method: "CONNECT",
          path: options.host + ":" + options.port,
          agent: false
        }
      );
      if (connectOptions.proxyAuth) {
        connectOptions.headers = connectOptions.headers || {};
        connectOptions.headers["Proxy-Authorization"] = "Basic " + Buffer2.from(connectOptions.proxyAuth).toString("base64");
      }
      debug("making CONNECT request");
      var connectReq = self2.request(connectOptions);
      connectReq.useChunkedEncodingByDefault = false;
      connectReq.once("response", onResponse);
      connectReq.once("upgrade", onUpgrade);
      connectReq.once("connect", onConnect);
      connectReq.once("error", onError);
      connectReq.end();
      function onResponse(res) {
        res.upgrade = true;
      }
      function onUpgrade(res, socket, head) {
        process.nextTick(function() {
          onConnect(res, socket, head);
        });
      }
      function onConnect(res, socket, head) {
        connectReq.removeAllListeners();
        socket.removeAllListeners();
        if (res.statusCode === 200) {
          assert.equal(head.length, 0);
          debug("tunneling connection has established");
          self2.sockets[self2.sockets.indexOf(placeholder)] = socket;
          cb(socket);
        } else {
          debug("tunneling socket could not be established, statusCode=%d", res.statusCode);
          var error2 = new Error("tunneling socket could not be established, statusCode=" + res.statusCode);
          error2.code = "ECONNRESET";
          options.request.emit("error", error2);
          self2.removeSocket(placeholder);
        }
      }
      function onError(cause) {
        connectReq.removeAllListeners();
        debug("tunneling socket could not be established, cause=%s\n", cause.message, cause.stack);
        var error2 = new Error("tunneling socket could not be established, cause=" + cause.message);
        error2.code = "ECONNRESET";
        options.request.emit("error", error2);
        self2.removeSocket(placeholder);
      }
    };
    TunnelingAgent.prototype.removeSocket = function removeSocket(socket) {
      var pos = this.sockets.indexOf(socket);
      if (pos === -1)
        return;
      this.sockets.splice(pos, 1);
      var pending = this.requests.shift();
      if (pending) {
        this.createConnection(pending);
      }
    };
    function createSecureSocket(options, cb) {
      var self2 = this;
      TunnelingAgent.prototype.createSocket.call(self2, options, function(socket) {
        var secureSocket = tls.connect(0, mergeOptions(
          {},
          self2.options,
          {
            servername: options.host,
            socket
          }
        ));
        self2.sockets[self2.sockets.indexOf(socket)] = secureSocket;
        cb(secureSocket);
      });
    }
    function mergeOptions(target) {
      for (var i2 = 1, len = arguments.length; i2 < len; ++i2) {
        var overrides = arguments[i2];
        if (typeof overrides === "object") {
          var keys = Object.keys(overrides);
          for (var j2 = 0, keyLen = keys.length; j2 < keyLen; ++j2) {
            var k = keys[j2];
            if (overrides[k] !== void 0) {
              target[k] = overrides[k];
            }
          }
        }
      }
      return target;
    }
    var debug;
    if ({}.NODE_DEBUG && /\btunnel\b/.test({}.NODE_DEBUG)) {
      debug = function() {
        var args = Array.prototype.slice.call(arguments);
        if (typeof args[0] === "string") {
          args[0] = "TUNNEL: " + args[0];
        } else {
          args.unshift("TUNNEL:");
        }
        console.error.apply(console, args);
      };
    } else {
      debug = function() {
      };
    }
    tunnelAgent.debug = debug;
    return tunnelAgent;
  }
  var hasRequiredTunnel;
  function requireTunnel() {
    if (hasRequiredTunnel)
      return tunnel;
    hasRequiredTunnel = 1;
    var url = require$$0$2;
    var tunnel$1 = requireTunnelAgent();
    var defaultProxyHeaderWhiteList = [
      "accept",
      "accept-charset",
      "accept-encoding",
      "accept-language",
      "accept-ranges",
      "cache-control",
      "content-encoding",
      "content-language",
      "content-location",
      "content-md5",
      "content-range",
      "content-type",
      "connection",
      "date",
      "expect",
      "max-forwards",
      "pragma",
      "referer",
      "te",
      "user-agent",
      "via"
    ];
    var defaultProxyHeaderExclusiveList = [
      "proxy-authorization"
    ];
    function constructProxyHost(uriObject) {
      var port = uriObject.port;
      var protocol = uriObject.protocol;
      var proxyHost = uriObject.hostname + ":";
      if (port) {
        proxyHost += port;
      } else if (protocol === "https:") {
        proxyHost += "443";
      } else {
        proxyHost += "80";
      }
      return proxyHost;
    }
    function constructProxyHeaderWhiteList(headers, proxyHeaderWhiteList) {
      var whiteList = proxyHeaderWhiteList.reduce(function(set, header) {
        set[header.toLowerCase()] = true;
        return set;
      }, {});
      return Object.keys(headers).filter(function(header) {
        return whiteList[header.toLowerCase()];
      }).reduce(function(set, header) {
        set[header] = headers[header];
        return set;
      }, {});
    }
    function constructTunnelOptions(request2, proxyHeaders) {
      var proxy = request2.proxy;
      var tunnelOptions = {
        proxy: {
          host: proxy.hostname,
          port: +proxy.port,
          proxyAuth: proxy.auth,
          headers: proxyHeaders
        },
        headers: request2.headers,
        ca: request2.ca,
        cert: request2.cert,
        key: request2.key,
        passphrase: request2.passphrase,
        pfx: request2.pfx,
        ciphers: request2.ciphers,
        rejectUnauthorized: request2.rejectUnauthorized,
        secureOptions: request2.secureOptions,
        secureProtocol: request2.secureProtocol
      };
      return tunnelOptions;
    }
    function constructTunnelFnName(uri, proxy) {
      var uriProtocol = uri.protocol === "https:" ? "https" : "http";
      var proxyProtocol = proxy.protocol === "https:" ? "Https" : "Http";
      return [uriProtocol, proxyProtocol].join("Over");
    }
    function getTunnelFn(request2) {
      var uri = request2.uri;
      var proxy = request2.proxy;
      var tunnelFnName = constructTunnelFnName(uri, proxy);
      return tunnel$1[tunnelFnName];
    }
    function Tunnel(request2) {
      this.request = request2;
      this.proxyHeaderWhiteList = defaultProxyHeaderWhiteList;
      this.proxyHeaderExclusiveList = [];
      if (typeof request2.tunnel !== "undefined") {
        this.tunnelOverride = request2.tunnel;
      }
    }
    Tunnel.prototype.isEnabled = function() {
      var self2 = this;
      var request2 = self2.request;
      if (typeof self2.tunnelOverride !== "undefined") {
        return self2.tunnelOverride;
      }
      if (request2.uri.protocol === "https:") {
        return true;
      }
      return false;
    };
    Tunnel.prototype.setup = function(options) {
      var self2 = this;
      var request2 = self2.request;
      options = options || {};
      if (typeof request2.proxy === "string") {
        request2.proxy = url.parse(request2.proxy);
      }
      if (!request2.proxy || !request2.tunnel) {
        return false;
      }
      if (options.proxyHeaderWhiteList) {
        self2.proxyHeaderWhiteList = options.proxyHeaderWhiteList;
      }
      if (options.proxyHeaderExclusiveList) {
        self2.proxyHeaderExclusiveList = options.proxyHeaderExclusiveList;
      }
      var proxyHeaderExclusiveList = self2.proxyHeaderExclusiveList.concat(defaultProxyHeaderExclusiveList);
      var proxyHeaderWhiteList = self2.proxyHeaderWhiteList.concat(proxyHeaderExclusiveList);
      var proxyHeaders = constructProxyHeaderWhiteList(request2.headers, proxyHeaderWhiteList);
      proxyHeaders.host = constructProxyHost(request2.uri);
      proxyHeaderExclusiveList.forEach(request2.removeHeader, request2);
      var tunnelFn = getTunnelFn(request2);
      var tunnelOptions = constructTunnelOptions(request2, proxyHeaders);
      request2.agent = tunnelFn(tunnelOptions);
      return true;
    };
    Tunnel.defaultProxyHeaderWhiteList = defaultProxyHeaderWhiteList;
    Tunnel.defaultProxyHeaderExclusiveList = defaultProxyHeaderExclusiveList;
    tunnel.Tunnel = Tunnel;
    return tunnel;
  }
  var performanceNow = { exports: {} };
  var hasRequiredPerformanceNow;
  function requirePerformanceNow() {
    if (hasRequiredPerformanceNow)
      return performanceNow.exports;
    hasRequiredPerformanceNow = 1;
    (function() {
      var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;
      if (typeof performance !== "undefined" && performance !== null && performance.now) {
        performanceNow.exports = function() {
          return performance.now();
        };
      } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
        performanceNow.exports = function() {
          return (getNanoSeconds() - nodeLoadTime) / 1e6;
        };
        hrtime = process.hrtime;
        getNanoSeconds = function() {
          var hr;
          hr = hrtime();
          return hr[0] * 1e9 + hr[1];
        };
        moduleLoadTime = getNanoSeconds();
        upTime = process.uptime() * 1e9;
        nodeLoadTime = moduleLoadTime - upTime;
      } else if (Date.now) {
        performanceNow.exports = function() {
          return Date.now() - loadTime;
        };
        loadTime = Date.now();
      } else {
        performanceNow.exports = function() {
          return (/* @__PURE__ */ new Date()).getTime() - loadTime;
        };
        loadTime = (/* @__PURE__ */ new Date()).getTime();
      }
    }).call(commonjsGlobal);
    return performanceNow.exports;
  }
  var request$2;
  var hasRequiredRequest;
  function requireRequest() {
    if (hasRequiredRequest)
      return request$2;
    hasRequiredRequest = 1;
    var http = require$$0$2;
    var https = require$$0$2;
    var url = require$$0$2;
    var util2 = require$$0$2;
    var stream = require$$0$2;
    var zlib = require$$0$2;
    var aws2 = requireAwsSign2();
    var aws42 = requireAws4();
    var httpSignature = requireLib$2();
    var mime = requireMimeTypes();
    var caseless2 = requireCaseless();
    var ForeverAgent = requireForeverAgent();
    var FormData = requireBrowser();
    var extend3 = extend$1;
    var isstream2 = requireIsstream();
    var isTypedArray = requireIsTypedarray().strict;
    var helpers2 = helpers$1;
    var cookies2 = cookies$1;
    var getProxyFromURI = requireGetProxyFromURI();
    var Querystring = requireQuerystring().Querystring;
    var Har = requireHar().Har;
    var Auth = requireAuth().Auth;
    var OAuth = requireOauth().OAuth;
    var hawk2 = requireHawk();
    var Multipart = requireMultipart().Multipart;
    var Redirect = requireRedirect().Redirect;
    var Tunnel = requireTunnel().Tunnel;
    var now = requirePerformanceNow();
    var Buffer2 = safeBufferExports.Buffer;
    var safeStringify2 = helpers2.safeStringify;
    var isReadStream2 = helpers2.isReadStream;
    var toBase642 = helpers2.toBase64;
    var defer2 = helpers2.defer;
    var copy2 = helpers2.copy;
    var version2 = helpers2.version;
    var globalCookieJar = cookies2.jar();
    var globalPool = {};
    function filterForNonReserved(reserved, options) {
      var object = {};
      for (var i2 in options) {
        var notReserved = reserved.indexOf(i2) === -1;
        if (notReserved) {
          object[i2] = options[i2];
        }
      }
      return object;
    }
    function filterOutReservedFunctions(reserved, options) {
      var object = {};
      for (var i2 in options) {
        var isReserved = !(reserved.indexOf(i2) === -1);
        var isFunction = typeof options[i2] === "function";
        if (!(isReserved && isFunction)) {
          object[i2] = options[i2];
        }
      }
      return object;
    }
    function requestToJSON() {
      var self2 = this;
      return {
        uri: self2.uri,
        method: self2.method,
        headers: self2.headers
      };
    }
    function responseToJSON() {
      var self2 = this;
      return {
        statusCode: self2.statusCode,
        body: self2.body,
        headers: self2.headers,
        request: requestToJSON.call(self2.request)
      };
    }
    function Request(options) {
      var self2 = this;
      if (options.har) {
        self2._har = new Har(self2);
        options = self2._har.options(options);
      }
      stream.Stream.call(self2);
      var reserved = Object.keys(Request.prototype);
      var nonReserved = filterForNonReserved(reserved, options);
      extend3(self2, nonReserved);
      options = filterOutReservedFunctions(reserved, options);
      self2.readable = true;
      self2.writable = true;
      if (options.method) {
        self2.explicitMethod = true;
      }
      self2._qs = new Querystring(self2);
      self2._auth = new Auth(self2);
      self2._oauth = new OAuth(self2);
      self2._multipart = new Multipart(self2);
      self2._redirect = new Redirect(self2);
      self2._tunnel = new Tunnel(self2);
      self2.init(options);
    }
    util2.inherits(Request, stream.Stream);
    Request.debug = {}.NODE_DEBUG && /\brequest\b/.test({}.NODE_DEBUG);
    function debug() {
      if (Request.debug) {
        console.error("REQUEST %s", util2.format.apply(util2, arguments));
      }
    }
    Request.prototype.debug = debug;
    Request.prototype.init = function(options) {
      var self2 = this;
      if (!options) {
        options = {};
      }
      self2.headers = self2.headers ? copy2(self2.headers) : {};
      for (var headerName in self2.headers) {
        if (typeof self2.headers[headerName] === "undefined") {
          delete self2.headers[headerName];
        }
      }
      caseless2.httpify(self2, self2.headers);
      if (!self2.method) {
        self2.method = options.method || "GET";
      }
      if (!self2.localAddress) {
        self2.localAddress = options.localAddress;
      }
      self2._qs.init(options);
      debug(options);
      if (!self2.pool && self2.pool !== false) {
        self2.pool = globalPool;
      }
      self2.dests = self2.dests || [];
      self2.__isRequestRequest = true;
      if (!self2._callback && self2.callback) {
        self2._callback = self2.callback;
        self2.callback = function() {
          if (self2._callbackCalled) {
            return;
          }
          self2._callbackCalled = true;
          self2._callback.apply(self2, arguments);
        };
        self2.on("error", self2.callback.bind());
        self2.on("complete", self2.callback.bind(self2, null));
      }
      if (!self2.uri && self2.url) {
        self2.uri = self2.url;
        delete self2.url;
      }
      if (self2.baseUrl) {
        if (typeof self2.baseUrl !== "string") {
          return self2.emit("error", new Error("options.baseUrl must be a string"));
        }
        if (typeof self2.uri !== "string") {
          return self2.emit("error", new Error("options.uri must be a string when using options.baseUrl"));
        }
        if (self2.uri.indexOf("//") === 0 || self2.uri.indexOf("://") !== -1) {
          return self2.emit("error", new Error("options.uri must be a path when using options.baseUrl"));
        }
        var baseUrlEndsWithSlash = self2.baseUrl.lastIndexOf("/") === self2.baseUrl.length - 1;
        var uriStartsWithSlash = self2.uri.indexOf("/") === 0;
        if (baseUrlEndsWithSlash && uriStartsWithSlash) {
          self2.uri = self2.baseUrl + self2.uri.slice(1);
        } else if (baseUrlEndsWithSlash || uriStartsWithSlash) {
          self2.uri = self2.baseUrl + self2.uri;
        } else if (self2.uri === "") {
          self2.uri = self2.baseUrl;
        } else {
          self2.uri = self2.baseUrl + "/" + self2.uri;
        }
        delete self2.baseUrl;
      }
      if (!self2.uri) {
        return self2.emit("error", new Error("options.uri is a required argument"));
      }
      if (typeof self2.uri === "string") {
        self2.uri = url.parse(self2.uri);
      }
      if (!self2.uri.href) {
        self2.uri.href = url.format(self2.uri);
      }
      if (self2.uri.protocol === "unix:") {
        return self2.emit("error", new Error("`unix://` URL scheme is no longer supported. Please use the format `http://unix:SOCKET:PATH`"));
      }
      if (self2.uri.host === "unix") {
        self2.enableUnixSocket();
      }
      if (self2.strictSSL === false) {
        self2.rejectUnauthorized = false;
      }
      if (!self2.uri.pathname) {
        self2.uri.pathname = "/";
      }
      if (!(self2.uri.host || self2.uri.hostname && self2.uri.port) && !self2.uri.isUnix) {
        var faultyUri = url.format(self2.uri);
        var message = 'Invalid URI "' + faultyUri + '"';
        if (Object.keys(options).length === 0) {
          message += ". This can be caused by a crappy redirection.";
        }
        self2.abort();
        return self2.emit("error", new Error(message));
      }
      if (!self2.hasOwnProperty("proxy")) {
        self2.proxy = getProxyFromURI(self2.uri);
      }
      self2.tunnel = self2._tunnel.isEnabled();
      if (self2.proxy) {
        self2._tunnel.setup(options);
      }
      self2._redirect.onRequest(options);
      self2.setHost = false;
      if (!self2.hasHeader("host")) {
        var hostHeaderName = self2.originalHostHeaderName || "host";
        self2.setHeader(hostHeaderName, self2.uri.host);
        if (self2.uri.port) {
          if (self2.uri.port === "80" && self2.uri.protocol === "http:" || self2.uri.port === "443" && self2.uri.protocol === "https:") {
            self2.setHeader(hostHeaderName, self2.uri.hostname);
          }
        }
        self2.setHost = true;
      }
      self2.jar(self2._jar || options.jar);
      if (!self2.uri.port) {
        if (self2.uri.protocol === "http:") {
          self2.uri.port = 80;
        } else if (self2.uri.protocol === "https:") {
          self2.uri.port = 443;
        }
      }
      if (self2.proxy && !self2.tunnel) {
        self2.port = self2.proxy.port;
        self2.host = self2.proxy.hostname;
      } else {
        self2.port = self2.uri.port;
        self2.host = self2.uri.hostname;
      }
      if (options.form) {
        self2.form(options.form);
      }
      if (options.formData) {
        var formData = options.formData;
        var requestForm = self2.form();
        var appendFormValue = function(key2, value) {
          if (value && value.hasOwnProperty("value") && value.hasOwnProperty("options")) {
            requestForm.append(key2, value.value, value.options);
          } else {
            requestForm.append(key2, value);
          }
        };
        for (var formKey in formData) {
          if (formData.hasOwnProperty(formKey)) {
            var formValue = formData[formKey];
            if (formValue instanceof Array) {
              for (var j2 = 0; j2 < formValue.length; j2++) {
                appendFormValue(formKey, formValue[j2]);
              }
            } else {
              appendFormValue(formKey, formValue);
            }
          }
        }
      }
      if (options.qs) {
        self2.qs(options.qs);
      }
      if (self2.uri.path) {
        self2.path = self2.uri.path;
      } else {
        self2.path = self2.uri.pathname + (self2.uri.search || "");
      }
      if (self2.path.length === 0) {
        self2.path = "/";
      }
      if (options.aws) {
        self2.aws(options.aws);
      }
      if (options.hawk) {
        self2.hawk(options.hawk);
      }
      if (options.httpSignature) {
        self2.httpSignature(options.httpSignature);
      }
      if (options.auth) {
        if (Object.prototype.hasOwnProperty.call(options.auth, "username")) {
          options.auth.user = options.auth.username;
        }
        if (Object.prototype.hasOwnProperty.call(options.auth, "password")) {
          options.auth.pass = options.auth.password;
        }
        self2.auth(
          options.auth.user,
          options.auth.pass,
          options.auth.sendImmediately,
          options.auth.bearer
        );
      }
      if (self2.gzip && !self2.hasHeader("accept-encoding")) {
        self2.setHeader("accept-encoding", "gzip, deflate");
      }
      if (self2.uri.auth && !self2.hasHeader("authorization")) {
        var uriAuthPieces = self2.uri.auth.split(":").map(function(item) {
          return self2._qs.unescape(item);
        });
        self2.auth(uriAuthPieces[0], uriAuthPieces.slice(1).join(":"), true);
      }
      if (!self2.tunnel && self2.proxy && self2.proxy.auth && !self2.hasHeader("proxy-authorization")) {
        var proxyAuthPieces = self2.proxy.auth.split(":").map(function(item) {
          return self2._qs.unescape(item);
        });
        var authHeader = "Basic " + toBase642(proxyAuthPieces.join(":"));
        self2.setHeader("proxy-authorization", authHeader);
      }
      if (self2.proxy && !self2.tunnel) {
        self2.path = self2.uri.protocol + "//" + self2.uri.host + self2.path;
      }
      if (options.json) {
        self2.json(options.json);
      }
      if (options.multipart) {
        self2.multipart(options.multipart);
      }
      if (options.time) {
        self2.timing = true;
        self2.elapsedTime = self2.elapsedTime || 0;
      }
      function setContentLength() {
        if (isTypedArray(self2.body)) {
          self2.body = Buffer2.from(self2.body);
        }
        if (!self2.hasHeader("content-length")) {
          var length;
          if (typeof self2.body === "string") {
            length = Buffer2.byteLength(self2.body);
          } else if (Array.isArray(self2.body)) {
            length = self2.body.reduce(function(a2, b2) {
              return a2 + b2.length;
            }, 0);
          } else {
            length = self2.body.length;
          }
          if (length) {
            self2.setHeader("content-length", length);
          } else {
            self2.emit("error", new Error("Argument error, options.body."));
          }
        }
      }
      if (self2.body && !isstream2(self2.body)) {
        setContentLength();
      }
      if (options.oauth) {
        self2.oauth(options.oauth);
      } else if (self2._oauth.params && self2.hasHeader("authorization")) {
        self2.oauth(self2._oauth.params);
      }
      var protocol = self2.proxy && !self2.tunnel ? self2.proxy.protocol : self2.uri.protocol;
      var defaultModules = { "http:": http, "https:": https };
      var httpModules = self2.httpModules || {};
      self2.httpModule = httpModules[protocol] || defaultModules[protocol];
      if (!self2.httpModule) {
        return self2.emit("error", new Error("Invalid protocol: " + protocol));
      }
      if (options.ca) {
        self2.ca = options.ca;
      }
      if (!self2.agent) {
        if (options.agentOptions) {
          self2.agentOptions = options.agentOptions;
        }
        if (options.agentClass) {
          self2.agentClass = options.agentClass;
        } else if (options.forever) {
          var v = version2();
          if (v.major === 0 && v.minor <= 10) {
            self2.agentClass = protocol === "http:" ? ForeverAgent : ForeverAgent.SSL;
          } else {
            self2.agentClass = self2.httpModule.Agent;
            self2.agentOptions = self2.agentOptions || {};
            self2.agentOptions.keepAlive = true;
          }
        } else {
          self2.agentClass = self2.httpModule.Agent;
        }
      }
      if (self2.pool === false) {
        self2.agent = false;
      } else {
        self2.agent = self2.agent || self2.getNewAgent();
      }
      self2.on("pipe", function(src) {
        if (self2.ntick && self2._started) {
          self2.emit("error", new Error("You cannot pipe to this stream after the outbound request has started."));
        }
        self2.src = src;
        if (isReadStream2(src)) {
          if (!self2.hasHeader("content-type")) {
            self2.setHeader("content-type", mime.lookup(src.path));
          }
        } else {
          if (src.headers) {
            for (var i2 in src.headers) {
              if (!self2.hasHeader(i2)) {
                self2.setHeader(i2, src.headers[i2]);
              }
            }
          }
          if (self2._json && !self2.hasHeader("content-type")) {
            self2.setHeader("content-type", "application/json");
          }
          if (src.method && !self2.explicitMethod) {
            self2.method = src.method;
          }
        }
      });
      defer2(function() {
        if (self2._aborted) {
          return;
        }
        var end = function() {
          if (self2._form) {
            if (!self2._auth.hasAuth) {
              self2._form.pipe(self2);
            } else if (self2._auth.hasAuth && self2._auth.sentAuth) {
              self2._form.pipe(self2);
            }
          }
          if (self2._multipart && self2._multipart.chunked) {
            self2._multipart.body.pipe(self2);
          }
          if (self2.body) {
            if (isstream2(self2.body)) {
              self2.body.pipe(self2);
            } else {
              setContentLength();
              if (Array.isArray(self2.body)) {
                self2.body.forEach(function(part) {
                  self2.write(part);
                });
              } else {
                self2.write(self2.body);
              }
              self2.end();
            }
          } else if (self2.requestBodyStream) {
            console.warn("options.requestBodyStream is deprecated, please pass the request object to stream.pipe.");
            self2.requestBodyStream.pipe(self2);
          } else if (!self2.src) {
            if (self2._auth.hasAuth && !self2._auth.sentAuth) {
              self2.end();
              return;
            }
            if (self2.method !== "GET" && typeof self2.method !== "undefined") {
              self2.setHeader("content-length", 0);
            }
            self2.end();
          }
        };
        if (self2._form && !self2.hasHeader("content-length")) {
          self2.setHeader(self2._form.getHeaders(), true);
          self2._form.getLength(function(err, length) {
            if (!err && !isNaN(length)) {
              self2.setHeader("content-length", length);
            }
            end();
          });
        } else {
          end();
        }
        self2.ntick = true;
      });
    };
    Request.prototype.getNewAgent = function() {
      var self2 = this;
      var Agent = self2.agentClass;
      var options = {};
      if (self2.agentOptions) {
        for (var i2 in self2.agentOptions) {
          options[i2] = self2.agentOptions[i2];
        }
      }
      if (self2.ca) {
        options.ca = self2.ca;
      }
      if (self2.ciphers) {
        options.ciphers = self2.ciphers;
      }
      if (self2.secureProtocol) {
        options.secureProtocol = self2.secureProtocol;
      }
      if (self2.secureOptions) {
        options.secureOptions = self2.secureOptions;
      }
      if (typeof self2.rejectUnauthorized !== "undefined") {
        options.rejectUnauthorized = self2.rejectUnauthorized;
      }
      if (self2.cert && self2.key) {
        options.key = self2.key;
        options.cert = self2.cert;
      }
      if (self2.pfx) {
        options.pfx = self2.pfx;
      }
      if (self2.passphrase) {
        options.passphrase = self2.passphrase;
      }
      var poolKey = "";
      if (Agent !== self2.httpModule.Agent) {
        poolKey += Agent.name;
      }
      var proxy = self2.proxy;
      if (typeof proxy === "string") {
        proxy = url.parse(proxy);
      }
      var isHttps = proxy && proxy.protocol === "https:" || this.uri.protocol === "https:";
      if (isHttps) {
        if (options.ca) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.ca;
        }
        if (typeof options.rejectUnauthorized !== "undefined") {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.rejectUnauthorized;
        }
        if (options.cert) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.cert.toString("ascii") + options.key.toString("ascii");
        }
        if (options.pfx) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.pfx.toString("ascii");
        }
        if (options.ciphers) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.ciphers;
        }
        if (options.secureProtocol) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.secureProtocol;
        }
        if (options.secureOptions) {
          if (poolKey) {
            poolKey += ":";
          }
          poolKey += options.secureOptions;
        }
      }
      if (self2.pool === globalPool && !poolKey && Object.keys(options).length === 0 && self2.httpModule.globalAgent) {
        return self2.httpModule.globalAgent;
      }
      poolKey = self2.uri.protocol + poolKey;
      if (!self2.pool[poolKey]) {
        self2.pool[poolKey] = new Agent(options);
        if (self2.pool.maxSockets) {
          self2.pool[poolKey].maxSockets = self2.pool.maxSockets;
        }
      }
      return self2.pool[poolKey];
    };
    Request.prototype.start = function() {
      var self2 = this;
      if (self2.timing) {
        var startTime = (/* @__PURE__ */ new Date()).getTime();
        var startTimeNow = now();
      }
      if (self2._aborted) {
        return;
      }
      self2._started = true;
      self2.method = self2.method || "GET";
      self2.href = self2.uri.href;
      if (self2.src && self2.src.stat && self2.src.stat.size && !self2.hasHeader("content-length")) {
        self2.setHeader("content-length", self2.src.stat.size);
      }
      if (self2._aws) {
        self2.aws(self2._aws, true);
      }
      var reqOptions = copy2(self2);
      delete reqOptions.auth;
      debug("make request", self2.uri.href);
      delete reqOptions.timeout;
      try {
        self2.req = self2.httpModule.request(reqOptions);
      } catch (err) {
        self2.emit("error", err);
        return;
      }
      if (self2.timing) {
        self2.startTime = startTime;
        self2.startTimeNow = startTimeNow;
        self2.timings = {};
      }
      var timeout;
      if (self2.timeout && !self2.timeoutTimer) {
        if (self2.timeout < 0) {
          timeout = 0;
        } else if (typeof self2.timeout === "number" && isFinite(self2.timeout)) {
          timeout = self2.timeout;
        }
      }
      self2.req.on("response", self2.onRequestResponse.bind(self2));
      self2.req.on("error", self2.onRequestError.bind(self2));
      self2.req.on("drain", function() {
        self2.emit("drain");
      });
      self2.req.on("socket", function(socket) {
        var isConnecting = socket._connecting || socket.connecting;
        if (self2.timing) {
          self2.timings.socket = now() - self2.startTimeNow;
          if (isConnecting) {
            var onLookupTiming = function() {
              self2.timings.lookup = now() - self2.startTimeNow;
            };
            var onConnectTiming = function() {
              self2.timings.connect = now() - self2.startTimeNow;
            };
            socket.once("lookup", onLookupTiming);
            socket.once("connect", onConnectTiming);
            self2.req.once("error", function() {
              socket.removeListener("lookup", onLookupTiming);
              socket.removeListener("connect", onConnectTiming);
            });
          }
        }
        var setReqTimeout = function() {
          self2.req.setTimeout(timeout, function() {
            if (self2.req) {
              self2.abort();
              var e = new Error("ESOCKETTIMEDOUT");
              e.code = "ESOCKETTIMEDOUT";
              e.connect = false;
              self2.emit("error", e);
            }
          });
        };
        if (timeout !== void 0) {
          if (isConnecting) {
            var onReqSockConnect = function() {
              socket.removeListener("connect", onReqSockConnect);
              self2.clearTimeout();
              setReqTimeout();
            };
            socket.on("connect", onReqSockConnect);
            self2.req.on("error", function(err) {
              socket.removeListener("connect", onReqSockConnect);
            });
            self2.timeoutTimer = setTimeout(function() {
              socket.removeListener("connect", onReqSockConnect);
              self2.abort();
              var e = new Error("ETIMEDOUT");
              e.code = "ETIMEDOUT";
              e.connect = true;
              self2.emit("error", e);
            }, timeout);
          } else {
            setReqTimeout();
          }
        }
        self2.emit("socket", socket);
      });
      self2.emit("request", self2.req);
    };
    Request.prototype.onRequestError = function(error2) {
      var self2 = this;
      if (self2._aborted) {
        return;
      }
      if (self2.req && self2.req._reusedSocket && error2.code === "ECONNRESET" && self2.agent.addRequestNoreuse) {
        self2.agent = { addRequest: self2.agent.addRequestNoreuse.bind(self2.agent) };
        self2.start();
        self2.req.end();
        return;
      }
      self2.clearTimeout();
      self2.emit("error", error2);
    };
    Request.prototype.onRequestResponse = function(response) {
      var self2 = this;
      if (self2.timing) {
        self2.timings.response = now() - self2.startTimeNow;
      }
      debug("onRequestResponse", self2.uri.href, response.statusCode, response.headers);
      response.on("end", function() {
        if (self2.timing) {
          self2.timings.end = now() - self2.startTimeNow;
          response.timingStart = self2.startTime;
          if (!self2.timings.socket) {
            self2.timings.socket = 0;
          }
          if (!self2.timings.lookup) {
            self2.timings.lookup = self2.timings.socket;
          }
          if (!self2.timings.connect) {
            self2.timings.connect = self2.timings.lookup;
          }
          if (!self2.timings.response) {
            self2.timings.response = self2.timings.connect;
          }
          debug("elapsed time", self2.timings.end);
          self2.elapsedTime += Math.round(self2.timings.end);
          response.elapsedTime = self2.elapsedTime;
          response.timings = self2.timings;
          response.timingPhases = {
            wait: self2.timings.socket,
            dns: self2.timings.lookup - self2.timings.socket,
            tcp: self2.timings.connect - self2.timings.lookup,
            firstByte: self2.timings.response - self2.timings.connect,
            download: self2.timings.end - self2.timings.response,
            total: self2.timings.end
          };
        }
        debug("response end", self2.uri.href, response.statusCode, response.headers);
      });
      if (self2._aborted) {
        debug("aborted", self2.uri.href);
        response.resume();
        return;
      }
      self2.response = response;
      response.request = self2;
      response.toJSON = responseToJSON;
      if (self2.httpModule === https && self2.strictSSL && (!response.hasOwnProperty("socket") || !response.socket.authorized)) {
        debug("strict ssl error", self2.uri.href);
        var sslErr = response.hasOwnProperty("socket") ? response.socket.authorizationError : self2.uri.href + " does not support SSL";
        self2.emit("error", new Error("SSL Error: " + sslErr));
        return;
      }
      self2.originalHost = self2.getHeader("host");
      if (!self2.originalHostHeaderName) {
        self2.originalHostHeaderName = self2.hasHeader("host");
      }
      if (self2.setHost) {
        self2.removeHeader("host");
      }
      self2.clearTimeout();
      var targetCookieJar = self2._jar && self2._jar.setCookie ? self2._jar : globalCookieJar;
      var addCookie = function(cookie2) {
        try {
          targetCookieJar.setCookie(cookie2, self2.uri.href, { ignoreError: true });
        } catch (e) {
          self2.emit("error", e);
        }
      };
      response.caseless = caseless2(response.headers);
      if (response.caseless.has("set-cookie") && !self2._disableCookies) {
        var headerName = response.caseless.has("set-cookie");
        if (Array.isArray(response.headers[headerName])) {
          response.headers[headerName].forEach(addCookie);
        } else {
          addCookie(response.headers[headerName]);
        }
      }
      if (self2._redirect.onResponse(response)) {
        return;
      } else {
        response.on("close", function() {
          if (!self2._ended) {
            self2.response.emit("end");
          }
        });
        response.once("end", function() {
          self2._ended = true;
        });
        var noBody = function(code) {
          return self2.method === "HEAD" || // Informational
          code >= 100 && code < 200 || // No Content
          code === 204 || // Not Modified
          code === 304;
        };
        var responseContent;
        if (self2.gzip && !noBody(response.statusCode)) {
          var contentEncoding = response.headers["content-encoding"] || "identity";
          contentEncoding = contentEncoding.trim().toLowerCase();
          var zlibOptions = {
            flush: zlib.Z_SYNC_FLUSH,
            finishFlush: zlib.Z_SYNC_FLUSH
          };
          if (contentEncoding === "gzip") {
            responseContent = zlib.createGunzip(zlibOptions);
            response.pipe(responseContent);
          } else if (contentEncoding === "deflate") {
            responseContent = zlib.createInflate(zlibOptions);
            response.pipe(responseContent);
          } else {
            if (contentEncoding !== "identity") {
              debug("ignoring unrecognized Content-Encoding " + contentEncoding);
            }
            responseContent = response;
          }
        } else {
          responseContent = response;
        }
        if (self2.encoding) {
          if (self2.dests.length !== 0) {
            console.error("Ignoring encoding parameter as this stream is being piped to another stream which makes the encoding option invalid.");
          } else {
            responseContent.setEncoding(self2.encoding);
          }
        }
        if (self2._paused) {
          responseContent.pause();
        }
        self2.responseContent = responseContent;
        self2.emit("response", response);
        self2.dests.forEach(function(dest) {
          self2.pipeDest(dest);
        });
        responseContent.on("data", function(chunk) {
          if (self2.timing && !self2.responseStarted) {
            self2.responseStartTime = (/* @__PURE__ */ new Date()).getTime();
            response.responseStartTime = self2.responseStartTime;
          }
          self2._destdata = true;
          self2.emit("data", chunk);
        });
        responseContent.once("end", function(chunk) {
          self2.emit("end", chunk);
        });
        responseContent.on("error", function(error2) {
          self2.emit("error", error2);
        });
        responseContent.on("close", function() {
          self2.emit("close");
        });
        if (self2.callback) {
          self2.readResponseBody(response);
        } else {
          self2.on("end", function() {
            if (self2._aborted) {
              debug("aborted", self2.uri.href);
              return;
            }
            self2.emit("complete", response);
          });
        }
      }
      debug("finish init function", self2.uri.href);
    };
    Request.prototype.readResponseBody = function(response) {
      var self2 = this;
      debug("reading response's body");
      var buffers = [];
      var bufferLength = 0;
      var strings = [];
      self2.on("data", function(chunk) {
        if (!Buffer2.isBuffer(chunk)) {
          strings.push(chunk);
        } else if (chunk.length) {
          bufferLength += chunk.length;
          buffers.push(chunk);
        }
      });
      self2.on("end", function() {
        debug("end event", self2.uri.href);
        if (self2._aborted) {
          debug("aborted", self2.uri.href);
          buffers = [];
          bufferLength = 0;
          return;
        }
        if (bufferLength) {
          debug("has body", self2.uri.href, bufferLength);
          response.body = Buffer2.concat(buffers, bufferLength);
          if (self2.encoding !== null) {
            response.body = response.body.toString(self2.encoding);
          }
          buffers = [];
          bufferLength = 0;
        } else if (strings.length) {
          if (self2.encoding === "utf8" && strings[0].length > 0 && strings[0][0] === "\uFEFF") {
            strings[0] = strings[0].substring(1);
          }
          response.body = strings.join("");
        }
        if (self2._json) {
          try {
            response.body = JSON.parse(response.body, self2._jsonReviver);
          } catch (e) {
            debug("invalid JSON received", self2.uri.href);
          }
        }
        debug("emitting complete", self2.uri.href);
        if (typeof response.body === "undefined" && !self2._json) {
          response.body = self2.encoding === null ? Buffer2.alloc(0) : "";
        }
        self2.emit("complete", response, response.body);
      });
    };
    Request.prototype.abort = function() {
      var self2 = this;
      self2._aborted = true;
      if (self2.req) {
        self2.req.abort();
      } else if (self2.response) {
        self2.response.destroy();
      }
      self2.clearTimeout();
      self2.emit("abort");
    };
    Request.prototype.pipeDest = function(dest) {
      var self2 = this;
      var response = self2.response;
      if (dest.headers && !dest.headersSent) {
        if (response.caseless.has("content-type")) {
          var ctname = response.caseless.has("content-type");
          if (dest.setHeader) {
            dest.setHeader(ctname, response.headers[ctname]);
          } else {
            dest.headers[ctname] = response.headers[ctname];
          }
        }
        if (response.caseless.has("content-length")) {
          var clname = response.caseless.has("content-length");
          if (dest.setHeader) {
            dest.setHeader(clname, response.headers[clname]);
          } else {
            dest.headers[clname] = response.headers[clname];
          }
        }
      }
      if (dest.setHeader && !dest.headersSent) {
        for (var i2 in response.headers) {
          if (!self2.gzip || i2 !== "content-encoding") {
            dest.setHeader(i2, response.headers[i2]);
          }
        }
        dest.statusCode = response.statusCode;
      }
      if (self2.pipefilter) {
        self2.pipefilter(response, dest);
      }
    };
    Request.prototype.qs = function(q2, clobber) {
      var self2 = this;
      var base2;
      if (!clobber && self2.uri.query) {
        base2 = self2._qs.parse(self2.uri.query);
      } else {
        base2 = {};
      }
      for (var i2 in q2) {
        base2[i2] = q2[i2];
      }
      var qs = self2._qs.stringify(base2);
      if (qs === "") {
        return self2;
      }
      self2.uri = url.parse(self2.uri.href.split("?")[0] + "?" + qs);
      self2.url = self2.uri;
      self2.path = self2.uri.path;
      if (self2.uri.host === "unix") {
        self2.enableUnixSocket();
      }
      return self2;
    };
    Request.prototype.form = function(form) {
      var self2 = this;
      if (form) {
        if (!/^application\/x-www-form-urlencoded\b/.test(self2.getHeader("content-type"))) {
          self2.setHeader("content-type", "application/x-www-form-urlencoded");
        }
        self2.body = typeof form === "string" ? self2._qs.rfc3986(form.toString("utf8")) : self2._qs.stringify(form).toString("utf8");
        return self2;
      }
      self2._form = new FormData();
      self2._form.on("error", function(err) {
        err.message = "form-data: " + err.message;
        self2.emit("error", err);
        self2.abort();
      });
      return self2._form;
    };
    Request.prototype.multipart = function(multipart2) {
      var self2 = this;
      self2._multipart.onRequest(multipart2);
      if (!self2._multipart.chunked) {
        self2.body = self2._multipart.body;
      }
      return self2;
    };
    Request.prototype.json = function(val) {
      var self2 = this;
      if (!self2.hasHeader("accept")) {
        self2.setHeader("accept", "application/json");
      }
      if (typeof self2.jsonReplacer === "function") {
        self2._jsonReplacer = self2.jsonReplacer;
      }
      self2._json = true;
      if (typeof val === "boolean") {
        if (self2.body !== void 0) {
          if (!/^application\/x-www-form-urlencoded\b/.test(self2.getHeader("content-type"))) {
            self2.body = safeStringify2(self2.body, self2._jsonReplacer);
          } else {
            self2.body = self2._qs.rfc3986(self2.body);
          }
          if (!self2.hasHeader("content-type")) {
            self2.setHeader("content-type", "application/json");
          }
        }
      } else {
        self2.body = safeStringify2(val, self2._jsonReplacer);
        if (!self2.hasHeader("content-type")) {
          self2.setHeader("content-type", "application/json");
        }
      }
      if (typeof self2.jsonReviver === "function") {
        self2._jsonReviver = self2.jsonReviver;
      }
      return self2;
    };
    Request.prototype.getHeader = function(name, headers) {
      var self2 = this;
      var result2, re, match;
      if (!headers) {
        headers = self2.headers;
      }
      Object.keys(headers).forEach(function(key2) {
        if (key2.length !== name.length) {
          return;
        }
        re = new RegExp(name, "i");
        match = key2.match(re);
        if (match) {
          result2 = headers[key2];
        }
      });
      return result2;
    };
    Request.prototype.enableUnixSocket = function() {
      var unixParts = this.uri.path.split(":");
      var host = unixParts[0];
      var path = unixParts[1];
      this.socketPath = host;
      this.uri.pathname = path;
      this.uri.path = path;
      this.uri.host = host;
      this.uri.hostname = host;
      this.uri.isUnix = true;
    };
    Request.prototype.auth = function(user, pass, sendImmediately, bearer) {
      var self2 = this;
      self2._auth.onRequest(user, pass, sendImmediately, bearer);
      return self2;
    };
    Request.prototype.aws = function(opts, now2) {
      var self2 = this;
      if (!now2) {
        self2._aws = opts;
        return self2;
      }
      if (opts.sign_version === 4 || opts.sign_version === "4") {
        var options = {
          host: self2.uri.host,
          path: self2.uri.path,
          method: self2.method,
          headers: self2.headers,
          body: self2.body
        };
        if (opts.service) {
          options.service = opts.service;
        }
        var signRes = aws42.sign(options, {
          accessKeyId: opts.key,
          secretAccessKey: opts.secret,
          sessionToken: opts.session
        });
        self2.setHeader("authorization", signRes.headers.Authorization);
        self2.setHeader("x-amz-date", signRes.headers["X-Amz-Date"]);
        if (signRes.headers["X-Amz-Security-Token"]) {
          self2.setHeader("x-amz-security-token", signRes.headers["X-Amz-Security-Token"]);
        }
      } else {
        var date = /* @__PURE__ */ new Date();
        self2.setHeader("date", date.toUTCString());
        var auth2 = {
          key: opts.key,
          secret: opts.secret,
          verb: self2.method.toUpperCase(),
          date,
          contentType: self2.getHeader("content-type") || "",
          md5: self2.getHeader("content-md5") || "",
          amazonHeaders: aws2.canonicalizeHeaders(self2.headers)
        };
        var path = self2.uri.path;
        if (opts.bucket && path) {
          auth2.resource = "/" + opts.bucket + path;
        } else if (opts.bucket && !path) {
          auth2.resource = "/" + opts.bucket;
        } else if (!opts.bucket && path) {
          auth2.resource = path;
        } else if (!opts.bucket && !path) {
          auth2.resource = "/";
        }
        auth2.resource = aws2.canonicalizeResource(auth2.resource);
        self2.setHeader("authorization", aws2.authorization(auth2));
      }
      return self2;
    };
    Request.prototype.httpSignature = function(opts) {
      var self2 = this;
      httpSignature.signRequest({
        getHeader: function(header) {
          return self2.getHeader(header, self2.headers);
        },
        setHeader: function(header, value) {
          self2.setHeader(header, value);
        },
        method: self2.method,
        path: self2.path
      }, opts);
      debug("httpSignature authorization", self2.getHeader("authorization"));
      return self2;
    };
    Request.prototype.hawk = function(opts) {
      var self2 = this;
      self2.setHeader("Authorization", hawk2.header(self2.uri, self2.method, opts));
    };
    Request.prototype.oauth = function(_oauth) {
      var self2 = this;
      self2._oauth.onRequest(_oauth);
      return self2;
    };
    Request.prototype.jar = function(jar) {
      var self2 = this;
      var cookies3;
      if (self2._redirect.redirectsFollowed === 0) {
        self2.originalCookieHeader = self2.getHeader("cookie");
      }
      if (!jar) {
        cookies3 = false;
        self2._disableCookies = true;
      } else {
        var targetCookieJar = jar.getCookieString ? jar : globalCookieJar;
        var urihref = self2.uri.href;
        if (targetCookieJar) {
          cookies3 = targetCookieJar.getCookieString(urihref);
        }
      }
      if (cookies3 && cookies3.length) {
        if (self2.originalCookieHeader) {
          self2.setHeader("cookie", self2.originalCookieHeader + "; " + cookies3);
        } else {
          self2.setHeader("cookie", cookies3);
        }
      }
      self2._jar = jar;
      return self2;
    };
    Request.prototype.pipe = function(dest, opts) {
      var self2 = this;
      if (self2.response) {
        if (self2._destdata) {
          self2.emit("error", new Error("You cannot pipe after data has been emitted from the response."));
        } else if (self2._ended) {
          self2.emit("error", new Error("You cannot pipe after the response has been ended."));
        } else {
          stream.Stream.prototype.pipe.call(self2, dest, opts);
          self2.pipeDest(dest);
          return dest;
        }
      } else {
        self2.dests.push(dest);
        stream.Stream.prototype.pipe.call(self2, dest, opts);
        return dest;
      }
    };
    Request.prototype.write = function() {
      var self2 = this;
      if (self2._aborted) {
        return;
      }
      if (!self2._started) {
        self2.start();
      }
      if (self2.req) {
        return self2.req.write.apply(self2.req, arguments);
      }
    };
    Request.prototype.end = function(chunk) {
      var self2 = this;
      if (self2._aborted) {
        return;
      }
      if (chunk) {
        self2.write(chunk);
      }
      if (!self2._started) {
        self2.start();
      }
      if (self2.req) {
        self2.req.end();
      }
    };
    Request.prototype.pause = function() {
      var self2 = this;
      if (!self2.responseContent) {
        self2._paused = true;
      } else {
        self2.responseContent.pause.apply(self2.responseContent, arguments);
      }
    };
    Request.prototype.resume = function() {
      var self2 = this;
      if (!self2.responseContent) {
        self2._paused = false;
      } else {
        self2.responseContent.resume.apply(self2.responseContent, arguments);
      }
    };
    Request.prototype.destroy = function() {
      var self2 = this;
      this.clearTimeout();
      if (!self2._ended) {
        self2.end();
      } else if (self2.response) {
        self2.response.destroy();
      }
    };
    Request.prototype.clearTimeout = function() {
      if (this.timeoutTimer) {
        clearTimeout(this.timeoutTimer);
        this.timeoutTimer = null;
      }
    };
    Request.defaultProxyHeaderWhiteList = Tunnel.defaultProxyHeaderWhiteList.slice();
    Request.defaultProxyHeaderExclusiveList = Tunnel.defaultProxyHeaderExclusiveList.slice();
    Request.prototype.toJSON = requestToJSON;
    request$2 = Request;
    return request$2;
  }
  var extend2 = extend$1;
  var cookies = cookies$1;
  var helpers = helpers$1;
  var paramsHaveRequestBody = helpers.paramsHaveRequestBody;
  function initParams(uri, options, callback) {
    if (typeof options === "function") {
      callback = options;
    }
    var params = {};
    if (options !== null && typeof options === "object") {
      extend2(params, options, { uri });
    } else if (typeof uri === "string") {
      extend2(params, { uri });
    } else {
      extend2(params, uri);
    }
    params.callback = callback || params.callback;
    return params;
  }
  function request(uri, options, callback) {
    if (typeof uri === "undefined") {
      throw new Error("undefined is not a valid uri or options object.");
    }
    var params = initParams(uri, options, callback);
    if (params.method === "HEAD" && paramsHaveRequestBody(params)) {
      throw new Error("HTTP HEAD requests MUST NOT include a request body.");
    }
    return new request.Request(params);
  }
  function verbFunc(verb) {
    var method = verb.toUpperCase();
    return function(uri, options, callback) {
      var params = initParams(uri, options, callback);
      params.method = method;
      return request(params, params.callback);
    };
  }
  request.get = verbFunc("get");
  request.head = verbFunc("head");
  request.options = verbFunc("options");
  request.post = verbFunc("post");
  request.put = verbFunc("put");
  request.patch = verbFunc("patch");
  request.del = verbFunc("delete");
  request["delete"] = verbFunc("delete");
  request.jar = function(store2) {
    return cookies.jar(store2);
  };
  request.cookie = function(str) {
    return cookies.parse(str);
  };
  function wrapRequestMethod(method, options, requester, verb) {
    return function(uri, opts, callback) {
      var params = initParams(uri, opts, callback);
      var target = {};
      extend2(true, target, options, params);
      target.pool = params.pool || options.pool;
      if (verb) {
        target.method = verb.toUpperCase();
      }
      if (typeof requester === "function") {
        method = requester;
      }
      return method(target, target.callback);
    };
  }
  request.defaults = function(options, requester) {
    var self2 = this;
    options = options || {};
    if (typeof options === "function") {
      requester = options;
      options = {};
    }
    var defaults = wrapRequestMethod(self2, options, requester);
    var verbs = ["get", "head", "post", "put", "patch", "del", "delete"];
    verbs.forEach(function(verb) {
      defaults[verb] = wrapRequestMethod(self2[verb], options, requester, verb);
    });
    defaults.cookie = wrapRequestMethod(self2.cookie, options, requester);
    defaults.jar = self2.jar;
    defaults.defaults = self2.defaults;
    return defaults;
  };
  request.forever = function(agentOptions, optionsArg) {
    var options = {};
    if (optionsArg) {
      extend2(options, optionsArg);
    }
    if (agentOptions) {
      options.agentOptions = agentOptions;
    }
    options.forever = true;
    return request.defaults(options);
  };
  var request_1 = request;
  request.Request = requireRequest();
  request.initParams = initParams;
  Object.defineProperty(request, "debug", {
    enumerable: true,
    get: function() {
      return request.Request.debug;
    },
    set: function(debug) {
      request.Request.debug = debug;
    }
  });
  const request$1 = /* @__PURE__ */ getDefaultExportFromCjs(request_1);
  const getFile = (url, data2) => {
    return new Promise((resolve, reject) => {
      request$1(
        {
          url,
          method: "POST",
          json: true,
          headers: {
            "content-type": "application/json",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.5735.289 Safari/537.36",
            Referer: "https://music.163.com/"
          },
          form: data2
        },
        function(error2, response, body) {
          if (!error2 && response.statusCode == 200) {
            resolve(body);
          }
        }
      );
    });
  };
  var cryptoJs = { exports: {} };
  var core = { exports: {} };
  var hasRequiredCore;
  function requireCore() {
    if (hasRequiredCore)
      return core.exports;
    hasRequiredCore = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory();
        }
      })(commonjsGlobal, function() {
        var CryptoJS2 = CryptoJS2 || function(Math2, undefined$1) {
          var crypto2;
          if (typeof window !== "undefined" && window.crypto) {
            crypto2 = window.crypto;
          }
          if (typeof self !== "undefined" && self.crypto) {
            crypto2 = self.crypto;
          }
          if (typeof globalThis !== "undefined" && globalThis.crypto) {
            crypto2 = globalThis.crypto;
          }
          if (!crypto2 && typeof window !== "undefined" && window.msCrypto) {
            crypto2 = window.msCrypto;
          }
          if (!crypto2 && typeof commonjsGlobal !== "undefined" && commonjsGlobal.crypto) {
            crypto2 = commonjsGlobal.crypto;
          }
          if (!crypto2 && typeof commonjsRequire === "function") {
            try {
              crypto2 = require$$0$2;
            } catch (err) {
            }
          }
          var cryptoSecureRandomInt = function() {
            if (crypto2) {
              if (typeof crypto2.getRandomValues === "function") {
                try {
                  return crypto2.getRandomValues(new Uint32Array(1))[0];
                } catch (err) {
                }
              }
              if (typeof crypto2.randomBytes === "function") {
                try {
                  return crypto2.randomBytes(4).readInt32LE();
                } catch (err) {
                }
              }
            }
            throw new Error("Native crypto module could not be used to get secure random number.");
          };
          var create = Object.create || function() {
            function F() {
            }
            return function(obj) {
              var subtype;
              F.prototype = obj;
              subtype = new F();
              F.prototype = null;
              return subtype;
            };
          }();
          var C = {};
          var C_lib = C.lib = {};
          var Base = C_lib.Base = function() {
            return {
              /**
               * Creates a new object that inherits from this object.
               *
               * @param {Object} overrides Properties to copy into the new object.
               *
               * @return {Object} The new object.
               *
               * @static
               *
               * @example
               *
               *     var MyType = CryptoJS.lib.Base.extend({
               *         field: 'value',
               *
               *         method: function () {
               *         }
               *     });
               */
              extend: function(overrides) {
                var subtype = create(this);
                if (overrides) {
                  subtype.mixIn(overrides);
                }
                if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
                  subtype.init = function() {
                    subtype.$super.init.apply(this, arguments);
                  };
                }
                subtype.init.prototype = subtype;
                subtype.$super = this;
                return subtype;
              },
              /**
               * Extends this object and runs the init method.
               * Arguments to create() will be passed to init().
               *
               * @return {Object} The new object.
               *
               * @static
               *
               * @example
               *
               *     var instance = MyType.create();
               */
              create: function() {
                var instance = this.extend();
                instance.init.apply(instance, arguments);
                return instance;
              },
              /**
               * Initializes a newly created object.
               * Override this method to add some logic when your objects are created.
               *
               * @example
               *
               *     var MyType = CryptoJS.lib.Base.extend({
               *         init: function () {
               *             // ...
               *         }
               *     });
               */
              init: function() {
              },
              /**
               * Copies properties into this object.
               *
               * @param {Object} properties The properties to mix in.
               *
               * @example
               *
               *     MyType.mixIn({
               *         field: 'value'
               *     });
               */
              mixIn: function(properties2) {
                for (var propertyName in properties2) {
                  if (properties2.hasOwnProperty(propertyName)) {
                    this[propertyName] = properties2[propertyName];
                  }
                }
                if (properties2.hasOwnProperty("toString")) {
                  this.toString = properties2.toString;
                }
              },
              /**
               * Creates a copy of this object.
               *
               * @return {Object} The clone.
               *
               * @example
               *
               *     var clone = instance.clone();
               */
              clone: function() {
                return this.init.prototype.extend(this);
              }
            };
          }();
          var WordArray = C_lib.WordArray = Base.extend({
            /**
             * Initializes a newly created word array.
             *
             * @param {Array} words (Optional) An array of 32-bit words.
             * @param {number} sigBytes (Optional) The number of significant bytes in the words.
             *
             * @example
             *
             *     var wordArray = CryptoJS.lib.WordArray.create();
             *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
             *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
             */
            init: function(words, sigBytes) {
              words = this.words = words || [];
              if (sigBytes != undefined$1) {
                this.sigBytes = sigBytes;
              } else {
                this.sigBytes = words.length * 4;
              }
            },
            /**
             * Converts this word array to a string.
             *
             * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
             *
             * @return {string} The stringified word array.
             *
             * @example
             *
             *     var string = wordArray + '';
             *     var string = wordArray.toString();
             *     var string = wordArray.toString(CryptoJS.enc.Utf8);
             */
            toString: function(encoder) {
              return (encoder || Hex).stringify(this);
            },
            /**
             * Concatenates a word array to this word array.
             *
             * @param {WordArray} wordArray The word array to append.
             *
             * @return {WordArray} This word array.
             *
             * @example
             *
             *     wordArray1.concat(wordArray2);
             */
            concat: function(wordArray) {
              var thisWords = this.words;
              var thatWords = wordArray.words;
              var thisSigBytes = this.sigBytes;
              var thatSigBytes = wordArray.sigBytes;
              this.clamp();
              if (thisSigBytes % 4) {
                for (var i2 = 0; i2 < thatSigBytes; i2++) {
                  var thatByte = thatWords[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
                  thisWords[thisSigBytes + i2 >>> 2] |= thatByte << 24 - (thisSigBytes + i2) % 4 * 8;
                }
              } else {
                for (var j2 = 0; j2 < thatSigBytes; j2 += 4) {
                  thisWords[thisSigBytes + j2 >>> 2] = thatWords[j2 >>> 2];
                }
              }
              this.sigBytes += thatSigBytes;
              return this;
            },
            /**
             * Removes insignificant bits.
             *
             * @example
             *
             *     wordArray.clamp();
             */
            clamp: function() {
              var words = this.words;
              var sigBytes = this.sigBytes;
              words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
              words.length = Math2.ceil(sigBytes / 4);
            },
            /**
             * Creates a copy of this word array.
             *
             * @return {WordArray} The clone.
             *
             * @example
             *
             *     var clone = wordArray.clone();
             */
            clone: function() {
              var clone = Base.clone.call(this);
              clone.words = this.words.slice(0);
              return clone;
            },
            /**
             * Creates a word array filled with random bytes.
             *
             * @param {number} nBytes The number of random bytes to generate.
             *
             * @return {WordArray} The random word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.lib.WordArray.random(16);
             */
            random: function(nBytes) {
              var words = [];
              for (var i2 = 0; i2 < nBytes; i2 += 4) {
                words.push(cryptoSecureRandomInt());
              }
              return new WordArray.init(words, nBytes);
            }
          });
          var C_enc = C.enc = {};
          var Hex = C_enc.Hex = {
            /**
             * Converts a word array to a hex string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The hex string.
             *
             * @static
             *
             * @example
             *
             *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
             */
            stringify: function(wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var hexChars = [];
              for (var i2 = 0; i2 < sigBytes; i2++) {
                var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
                hexChars.push((bite >>> 4).toString(16));
                hexChars.push((bite & 15).toString(16));
              }
              return hexChars.join("");
            },
            /**
             * Converts a hex string to a word array.
             *
             * @param {string} hexStr The hex string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
             */
            parse: function(hexStr) {
              var hexStrLength = hexStr.length;
              var words = [];
              for (var i2 = 0; i2 < hexStrLength; i2 += 2) {
                words[i2 >>> 3] |= parseInt(hexStr.substr(i2, 2), 16) << 24 - i2 % 8 * 4;
              }
              return new WordArray.init(words, hexStrLength / 2);
            }
          };
          var Latin1 = C_enc.Latin1 = {
            /**
             * Converts a word array to a Latin1 string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The Latin1 string.
             *
             * @static
             *
             * @example
             *
             *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
             */
            stringify: function(wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var latin1Chars = [];
              for (var i2 = 0; i2 < sigBytes; i2++) {
                var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
                latin1Chars.push(String.fromCharCode(bite));
              }
              return latin1Chars.join("");
            },
            /**
             * Converts a Latin1 string to a word array.
             *
             * @param {string} latin1Str The Latin1 string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
             */
            parse: function(latin1Str) {
              var latin1StrLength = latin1Str.length;
              var words = [];
              for (var i2 = 0; i2 < latin1StrLength; i2++) {
                words[i2 >>> 2] |= (latin1Str.charCodeAt(i2) & 255) << 24 - i2 % 4 * 8;
              }
              return new WordArray.init(words, latin1StrLength);
            }
          };
          var Utf8 = C_enc.Utf8 = {
            /**
             * Converts a word array to a UTF-8 string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The UTF-8 string.
             *
             * @static
             *
             * @example
             *
             *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
             */
            stringify: function(wordArray) {
              try {
                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
              } catch (e) {
                throw new Error("Malformed UTF-8 data");
              }
            },
            /**
             * Converts a UTF-8 string to a word array.
             *
             * @param {string} utf8Str The UTF-8 string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
             */
            parse: function(utf8Str) {
              return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
            }
          };
          var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
            /**
             * Resets this block algorithm's data buffer to its initial state.
             *
             * @example
             *
             *     bufferedBlockAlgorithm.reset();
             */
            reset: function() {
              this._data = new WordArray.init();
              this._nDataBytes = 0;
            },
            /**
             * Adds new data to this block algorithm's buffer.
             *
             * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
             *
             * @example
             *
             *     bufferedBlockAlgorithm._append('data');
             *     bufferedBlockAlgorithm._append(wordArray);
             */
            _append: function(data2) {
              if (typeof data2 == "string") {
                data2 = Utf8.parse(data2);
              }
              this._data.concat(data2);
              this._nDataBytes += data2.sigBytes;
            },
            /**
             * Processes available data blocks.
             *
             * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
             *
             * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
             *
             * @return {WordArray} The processed data.
             *
             * @example
             *
             *     var processedData = bufferedBlockAlgorithm._process();
             *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
             */
            _process: function(doFlush) {
              var processedWords;
              var data2 = this._data;
              var dataWords = data2.words;
              var dataSigBytes = data2.sigBytes;
              var blockSize = this.blockSize;
              var blockSizeBytes = blockSize * 4;
              var nBlocksReady = dataSigBytes / blockSizeBytes;
              if (doFlush) {
                nBlocksReady = Math2.ceil(nBlocksReady);
              } else {
                nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
              }
              var nWordsReady = nBlocksReady * blockSize;
              var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
              if (nWordsReady) {
                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
                  this._doProcessBlock(dataWords, offset);
                }
                processedWords = dataWords.splice(0, nWordsReady);
                data2.sigBytes -= nBytesReady;
              }
              return new WordArray.init(processedWords, nBytesReady);
            },
            /**
             * Creates a copy of this object.
             *
             * @return {Object} The clone.
             *
             * @example
             *
             *     var clone = bufferedBlockAlgorithm.clone();
             */
            clone: function() {
              var clone = Base.clone.call(this);
              clone._data = this._data.clone();
              return clone;
            },
            _minBufferSize: 0
          });
          C_lib.Hasher = BufferedBlockAlgorithm.extend({
            /**
             * Configuration options.
             */
            cfg: Base.extend(),
            /**
             * Initializes a newly created hasher.
             *
             * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
             *
             * @example
             *
             *     var hasher = CryptoJS.algo.SHA256.create();
             */
            init: function(cfg) {
              this.cfg = this.cfg.extend(cfg);
              this.reset();
            },
            /**
             * Resets this hasher to its initial state.
             *
             * @example
             *
             *     hasher.reset();
             */
            reset: function() {
              BufferedBlockAlgorithm.reset.call(this);
              this._doReset();
            },
            /**
             * Updates this hasher with a message.
             *
             * @param {WordArray|string} messageUpdate The message to append.
             *
             * @return {Hasher} This hasher.
             *
             * @example
             *
             *     hasher.update('message');
             *     hasher.update(wordArray);
             */
            update: function(messageUpdate) {
              this._append(messageUpdate);
              this._process();
              return this;
            },
            /**
             * Finalizes the hash computation.
             * Note that the finalize operation is effectively a destructive, read-once operation.
             *
             * @param {WordArray|string} messageUpdate (Optional) A final message update.
             *
             * @return {WordArray} The hash.
             *
             * @example
             *
             *     var hash = hasher.finalize();
             *     var hash = hasher.finalize('message');
             *     var hash = hasher.finalize(wordArray);
             */
            finalize: function(messageUpdate) {
              if (messageUpdate) {
                this._append(messageUpdate);
              }
              var hash = this._doFinalize();
              return hash;
            },
            blockSize: 512 / 32,
            /**
             * Creates a shortcut function to a hasher's object interface.
             *
             * @param {Hasher} hasher The hasher to create a helper for.
             *
             * @return {Function} The shortcut function.
             *
             * @static
             *
             * @example
             *
             *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
             */
            _createHelper: function(hasher) {
              return function(message, cfg) {
                return new hasher.init(cfg).finalize(message);
              };
            },
            /**
             * Creates a shortcut function to the HMAC's object interface.
             *
             * @param {Hasher} hasher The hasher to use in this HMAC helper.
             *
             * @return {Function} The shortcut function.
             *
             * @static
             *
             * @example
             *
             *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
             */
            _createHmacHelper: function(hasher) {
              return function(message, key2) {
                return new C_algo.HMAC.init(hasher, key2).finalize(message);
              };
            }
          });
          var C_algo = C.algo = {};
          return C;
        }(Math);
        return CryptoJS2;
      });
    })(core);
    return core.exports;
  }
  var x64Core = { exports: {} };
  var hasRequiredX64Core;
  function requireX64Core() {
    if (hasRequiredX64Core)
      return x64Core.exports;
    hasRequiredX64Core = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function(undefined$1) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Base = C_lib.Base;
          var X32WordArray = C_lib.WordArray;
          var C_x64 = C.x64 = {};
          C_x64.Word = Base.extend({
            /**
             * Initializes a newly created 64-bit word.
             *
             * @param {number} high The high 32 bits.
             * @param {number} low The low 32 bits.
             *
             * @example
             *
             *     var x64Word = CryptoJS.x64.Word.create(0x00010203, 0x04050607);
             */
            init: function(high, low) {
              this.high = high;
              this.low = low;
            }
            /**
             * Bitwise NOTs this word.
             *
             * @return {X64Word} A new x64-Word object after negating.
             *
             * @example
             *
             *     var negated = x64Word.not();
             */
            // not: function () {
            // var high = ~this.high;
            // var low = ~this.low;
            // return X64Word.create(high, low);
            // },
            /**
             * Bitwise ANDs this word with the passed word.
             *
             * @param {X64Word} word The x64-Word to AND with this word.
             *
             * @return {X64Word} A new x64-Word object after ANDing.
             *
             * @example
             *
             *     var anded = x64Word.and(anotherX64Word);
             */
            // and: function (word) {
            // var high = this.high & word.high;
            // var low = this.low & word.low;
            // return X64Word.create(high, low);
            // },
            /**
             * Bitwise ORs this word with the passed word.
             *
             * @param {X64Word} word The x64-Word to OR with this word.
             *
             * @return {X64Word} A new x64-Word object after ORing.
             *
             * @example
             *
             *     var ored = x64Word.or(anotherX64Word);
             */
            // or: function (word) {
            // var high = this.high | word.high;
            // var low = this.low | word.low;
            // return X64Word.create(high, low);
            // },
            /**
             * Bitwise XORs this word with the passed word.
             *
             * @param {X64Word} word The x64-Word to XOR with this word.
             *
             * @return {X64Word} A new x64-Word object after XORing.
             *
             * @example
             *
             *     var xored = x64Word.xor(anotherX64Word);
             */
            // xor: function (word) {
            // var high = this.high ^ word.high;
            // var low = this.low ^ word.low;
            // return X64Word.create(high, low);
            // },
            /**
             * Shifts this word n bits to the left.
             *
             * @param {number} n The number of bits to shift.
             *
             * @return {X64Word} A new x64-Word object after shifting.
             *
             * @example
             *
             *     var shifted = x64Word.shiftL(25);
             */
            // shiftL: function (n) {
            // if (n < 32) {
            // var high = (this.high << n) | (this.low >>> (32 - n));
            // var low = this.low << n;
            // } else {
            // var high = this.low << (n - 32);
            // var low = 0;
            // }
            // return X64Word.create(high, low);
            // },
            /**
             * Shifts this word n bits to the right.
             *
             * @param {number} n The number of bits to shift.
             *
             * @return {X64Word} A new x64-Word object after shifting.
             *
             * @example
             *
             *     var shifted = x64Word.shiftR(7);
             */
            // shiftR: function (n) {
            // if (n < 32) {
            // var low = (this.low >>> n) | (this.high << (32 - n));
            // var high = this.high >>> n;
            // } else {
            // var low = this.high >>> (n - 32);
            // var high = 0;
            // }
            // return X64Word.create(high, low);
            // },
            /**
             * Rotates this word n bits to the left.
             *
             * @param {number} n The number of bits to rotate.
             *
             * @return {X64Word} A new x64-Word object after rotating.
             *
             * @example
             *
             *     var rotated = x64Word.rotL(25);
             */
            // rotL: function (n) {
            // return this.shiftL(n).or(this.shiftR(64 - n));
            // },
            /**
             * Rotates this word n bits to the right.
             *
             * @param {number} n The number of bits to rotate.
             *
             * @return {X64Word} A new x64-Word object after rotating.
             *
             * @example
             *
             *     var rotated = x64Word.rotR(7);
             */
            // rotR: function (n) {
            // return this.shiftR(n).or(this.shiftL(64 - n));
            // },
            /**
             * Adds this word with the passed word.
             *
             * @param {X64Word} word The x64-Word to add with this word.
             *
             * @return {X64Word} A new x64-Word object after adding.
             *
             * @example
             *
             *     var added = x64Word.add(anotherX64Word);
             */
            // add: function (word) {
            // var low = (this.low + word.low) | 0;
            // var carry = (low >>> 0) < (this.low >>> 0) ? 1 : 0;
            // var high = (this.high + word.high + carry) | 0;
            // return X64Word.create(high, low);
            // }
          });
          C_x64.WordArray = Base.extend({
            /**
             * Initializes a newly created word array.
             *
             * @param {Array} words (Optional) An array of CryptoJS.x64.Word objects.
             * @param {number} sigBytes (Optional) The number of significant bytes in the words.
             *
             * @example
             *
             *     var wordArray = CryptoJS.x64.WordArray.create();
             *
             *     var wordArray = CryptoJS.x64.WordArray.create([
             *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
             *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
             *     ]);
             *
             *     var wordArray = CryptoJS.x64.WordArray.create([
             *         CryptoJS.x64.Word.create(0x00010203, 0x04050607),
             *         CryptoJS.x64.Word.create(0x18191a1b, 0x1c1d1e1f)
             *     ], 10);
             */
            init: function(words, sigBytes) {
              words = this.words = words || [];
              if (sigBytes != undefined$1) {
                this.sigBytes = sigBytes;
              } else {
                this.sigBytes = words.length * 8;
              }
            },
            /**
             * Converts this 64-bit word array to a 32-bit word array.
             *
             * @return {CryptoJS.lib.WordArray} This word array's data as a 32-bit word array.
             *
             * @example
             *
             *     var x32WordArray = x64WordArray.toX32();
             */
            toX32: function() {
              var x64Words = this.words;
              var x64WordsLength = x64Words.length;
              var x32Words = [];
              for (var i2 = 0; i2 < x64WordsLength; i2++) {
                var x64Word = x64Words[i2];
                x32Words.push(x64Word.high);
                x32Words.push(x64Word.low);
              }
              return X32WordArray.create(x32Words, this.sigBytes);
            },
            /**
             * Creates a copy of this word array.
             *
             * @return {X64WordArray} The clone.
             *
             * @example
             *
             *     var clone = x64WordArray.clone();
             */
            clone: function() {
              var clone = Base.clone.call(this);
              var words = clone.words = this.words.slice(0);
              var wordsLength = words.length;
              for (var i2 = 0; i2 < wordsLength; i2++) {
                words[i2] = words[i2].clone();
              }
              return clone;
            }
          });
        })();
        return CryptoJS2;
      });
    })(x64Core);
    return x64Core.exports;
  }
  var libTypedarrays = { exports: {} };
  var hasRequiredLibTypedarrays;
  function requireLibTypedarrays() {
    if (hasRequiredLibTypedarrays)
      return libTypedarrays.exports;
    hasRequiredLibTypedarrays = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          if (typeof ArrayBuffer != "function") {
            return;
          }
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var superInit = WordArray.init;
          var subInit = WordArray.init = function(typedArray) {
            if (typedArray instanceof ArrayBuffer) {
              typedArray = new Uint8Array(typedArray);
            }
            if (typedArray instanceof Int8Array || typeof Uint8ClampedArray !== "undefined" && typedArray instanceof Uint8ClampedArray || typedArray instanceof Int16Array || typedArray instanceof Uint16Array || typedArray instanceof Int32Array || typedArray instanceof Uint32Array || typedArray instanceof Float32Array || typedArray instanceof Float64Array) {
              typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
            }
            if (typedArray instanceof Uint8Array) {
              var typedArrayByteLength = typedArray.byteLength;
              var words = [];
              for (var i2 = 0; i2 < typedArrayByteLength; i2++) {
                words[i2 >>> 2] |= typedArray[i2] << 24 - i2 % 4 * 8;
              }
              superInit.call(this, words, typedArrayByteLength);
            } else {
              superInit.apply(this, arguments);
            }
          };
          subInit.prototype = WordArray;
        })();
        return CryptoJS2.lib.WordArray;
      });
    })(libTypedarrays);
    return libTypedarrays.exports;
  }
  var encUtf16 = { exports: {} };
  var hasRequiredEncUtf16;
  function requireEncUtf16() {
    if (hasRequiredEncUtf16)
      return encUtf16.exports;
    hasRequiredEncUtf16 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var C_enc = C.enc;
          C_enc.Utf16 = C_enc.Utf16BE = {
            /**
             * Converts a word array to a UTF-16 BE string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The UTF-16 BE string.
             *
             * @static
             *
             * @example
             *
             *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
             */
            stringify: function(wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var utf16Chars = [];
              for (var i2 = 0; i2 < sigBytes; i2 += 2) {
                var codePoint = words[i2 >>> 2] >>> 16 - i2 % 4 * 8 & 65535;
                utf16Chars.push(String.fromCharCode(codePoint));
              }
              return utf16Chars.join("");
            },
            /**
             * Converts a UTF-16 BE string to a word array.
             *
             * @param {string} utf16Str The UTF-16 BE string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
             */
            parse: function(utf16Str) {
              var utf16StrLength = utf16Str.length;
              var words = [];
              for (var i2 = 0; i2 < utf16StrLength; i2++) {
                words[i2 >>> 1] |= utf16Str.charCodeAt(i2) << 16 - i2 % 2 * 16;
              }
              return WordArray.create(words, utf16StrLength * 2);
            }
          };
          C_enc.Utf16LE = {
            /**
             * Converts a word array to a UTF-16 LE string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The UTF-16 LE string.
             *
             * @static
             *
             * @example
             *
             *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
             */
            stringify: function(wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var utf16Chars = [];
              for (var i2 = 0; i2 < sigBytes; i2 += 2) {
                var codePoint = swapEndian(words[i2 >>> 2] >>> 16 - i2 % 4 * 8 & 65535);
                utf16Chars.push(String.fromCharCode(codePoint));
              }
              return utf16Chars.join("");
            },
            /**
             * Converts a UTF-16 LE string to a word array.
             *
             * @param {string} utf16Str The UTF-16 LE string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
             */
            parse: function(utf16Str) {
              var utf16StrLength = utf16Str.length;
              var words = [];
              for (var i2 = 0; i2 < utf16StrLength; i2++) {
                words[i2 >>> 1] |= swapEndian(utf16Str.charCodeAt(i2) << 16 - i2 % 2 * 16);
              }
              return WordArray.create(words, utf16StrLength * 2);
            }
          };
          function swapEndian(word) {
            return word << 8 & 4278255360 | word >>> 8 & 16711935;
          }
        })();
        return CryptoJS2.enc.Utf16;
      });
    })(encUtf16);
    return encUtf16.exports;
  }
  var encBase64 = { exports: {} };
  var hasRequiredEncBase64;
  function requireEncBase64() {
    if (hasRequiredEncBase64)
      return encBase64.exports;
    hasRequiredEncBase64 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var C_enc = C.enc;
          C_enc.Base64 = {
            /**
             * Converts a word array to a Base64 string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @return {string} The Base64 string.
             *
             * @static
             *
             * @example
             *
             *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
             */
            stringify: function(wordArray) {
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var map2 = this._map;
              wordArray.clamp();
              var base64Chars = [];
              for (var i2 = 0; i2 < sigBytes; i2 += 3) {
                var byte1 = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
                var byte2 = words[i2 + 1 >>> 2] >>> 24 - (i2 + 1) % 4 * 8 & 255;
                var byte3 = words[i2 + 2 >>> 2] >>> 24 - (i2 + 2) % 4 * 8 & 255;
                var triplet = byte1 << 16 | byte2 << 8 | byte3;
                for (var j2 = 0; j2 < 4 && i2 + j2 * 0.75 < sigBytes; j2++) {
                  base64Chars.push(map2.charAt(triplet >>> 6 * (3 - j2) & 63));
                }
              }
              var paddingChar = map2.charAt(64);
              if (paddingChar) {
                while (base64Chars.length % 4) {
                  base64Chars.push(paddingChar);
                }
              }
              return base64Chars.join("");
            },
            /**
             * Converts a Base64 string to a word array.
             *
             * @param {string} base64Str The Base64 string.
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
             */
            parse: function(base64Str) {
              var base64StrLength = base64Str.length;
              var map2 = this._map;
              var reverseMap = this._reverseMap;
              if (!reverseMap) {
                reverseMap = this._reverseMap = [];
                for (var j2 = 0; j2 < map2.length; j2++) {
                  reverseMap[map2.charCodeAt(j2)] = j2;
                }
              }
              var paddingChar = map2.charAt(64);
              if (paddingChar) {
                var paddingIndex = base64Str.indexOf(paddingChar);
                if (paddingIndex !== -1) {
                  base64StrLength = paddingIndex;
                }
              }
              return parseLoop(base64Str, base64StrLength, reverseMap);
            },
            _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
          };
          function parseLoop(base64Str, base64StrLength, reverseMap) {
            var words = [];
            var nBytes = 0;
            for (var i2 = 0; i2 < base64StrLength; i2++) {
              if (i2 % 4) {
                var bits1 = reverseMap[base64Str.charCodeAt(i2 - 1)] << i2 % 4 * 2;
                var bits2 = reverseMap[base64Str.charCodeAt(i2)] >>> 6 - i2 % 4 * 2;
                var bitsCombined = bits1 | bits2;
                words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
                nBytes++;
              }
            }
            return WordArray.create(words, nBytes);
          }
        })();
        return CryptoJS2.enc.Base64;
      });
    })(encBase64);
    return encBase64.exports;
  }
  var encBase64url = { exports: {} };
  var hasRequiredEncBase64url;
  function requireEncBase64url() {
    if (hasRequiredEncBase64url)
      return encBase64url.exports;
    hasRequiredEncBase64url = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var C_enc = C.enc;
          C_enc.Base64url = {
            /**
             * Converts a word array to a Base64url string.
             *
             * @param {WordArray} wordArray The word array.
             *
             * @param {boolean} urlSafe Whether to use url safe
             *
             * @return {string} The Base64url string.
             *
             * @static
             *
             * @example
             *
             *     var base64String = CryptoJS.enc.Base64url.stringify(wordArray);
             */
            stringify: function(wordArray, urlSafe) {
              if (urlSafe === void 0) {
                urlSafe = true;
              }
              var words = wordArray.words;
              var sigBytes = wordArray.sigBytes;
              var map2 = urlSafe ? this._safe_map : this._map;
              wordArray.clamp();
              var base64Chars = [];
              for (var i2 = 0; i2 < sigBytes; i2 += 3) {
                var byte1 = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
                var byte2 = words[i2 + 1 >>> 2] >>> 24 - (i2 + 1) % 4 * 8 & 255;
                var byte3 = words[i2 + 2 >>> 2] >>> 24 - (i2 + 2) % 4 * 8 & 255;
                var triplet = byte1 << 16 | byte2 << 8 | byte3;
                for (var j2 = 0; j2 < 4 && i2 + j2 * 0.75 < sigBytes; j2++) {
                  base64Chars.push(map2.charAt(triplet >>> 6 * (3 - j2) & 63));
                }
              }
              var paddingChar = map2.charAt(64);
              if (paddingChar) {
                while (base64Chars.length % 4) {
                  base64Chars.push(paddingChar);
                }
              }
              return base64Chars.join("");
            },
            /**
             * Converts a Base64url string to a word array.
             *
             * @param {string} base64Str The Base64url string.
             *
             * @param {boolean} urlSafe Whether to use url safe
             *
             * @return {WordArray} The word array.
             *
             * @static
             *
             * @example
             *
             *     var wordArray = CryptoJS.enc.Base64url.parse(base64String);
             */
            parse: function(base64Str, urlSafe) {
              if (urlSafe === void 0) {
                urlSafe = true;
              }
              var base64StrLength = base64Str.length;
              var map2 = urlSafe ? this._safe_map : this._map;
              var reverseMap = this._reverseMap;
              if (!reverseMap) {
                reverseMap = this._reverseMap = [];
                for (var j2 = 0; j2 < map2.length; j2++) {
                  reverseMap[map2.charCodeAt(j2)] = j2;
                }
              }
              var paddingChar = map2.charAt(64);
              if (paddingChar) {
                var paddingIndex = base64Str.indexOf(paddingChar);
                if (paddingIndex !== -1) {
                  base64StrLength = paddingIndex;
                }
              }
              return parseLoop(base64Str, base64StrLength, reverseMap);
            },
            _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
            _safe_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
          };
          function parseLoop(base64Str, base64StrLength, reverseMap) {
            var words = [];
            var nBytes = 0;
            for (var i2 = 0; i2 < base64StrLength; i2++) {
              if (i2 % 4) {
                var bits1 = reverseMap[base64Str.charCodeAt(i2 - 1)] << i2 % 4 * 2;
                var bits2 = reverseMap[base64Str.charCodeAt(i2)] >>> 6 - i2 % 4 * 2;
                var bitsCombined = bits1 | bits2;
                words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
                nBytes++;
              }
            }
            return WordArray.create(words, nBytes);
          }
        })();
        return CryptoJS2.enc.Base64url;
      });
    })(encBase64url);
    return encBase64url.exports;
  }
  var md5 = { exports: {} };
  var hasRequiredMd5;
  function requireMd5() {
    if (hasRequiredMd5)
      return md5.exports;
    hasRequiredMd5 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function(Math2) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var Hasher = C_lib.Hasher;
          var C_algo = C.algo;
          var T = [];
          (function() {
            for (var i2 = 0; i2 < 64; i2++) {
              T[i2] = Math2.abs(Math2.sin(i2 + 1)) * 4294967296 | 0;
            }
          })();
          var MD5 = C_algo.MD5 = Hasher.extend({
            _doReset: function() {
              this._hash = new WordArray.init([
                1732584193,
                4023233417,
                2562383102,
                271733878
              ]);
            },
            _doProcessBlock: function(M, offset) {
              for (var i2 = 0; i2 < 16; i2++) {
                var offset_i = offset + i2;
                var M_offset_i = M[offset_i];
                M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
              }
              var H = this._hash.words;
              var M_offset_0 = M[offset + 0];
              var M_offset_1 = M[offset + 1];
              var M_offset_2 = M[offset + 2];
              var M_offset_3 = M[offset + 3];
              var M_offset_4 = M[offset + 4];
              var M_offset_5 = M[offset + 5];
              var M_offset_6 = M[offset + 6];
              var M_offset_7 = M[offset + 7];
              var M_offset_8 = M[offset + 8];
              var M_offset_9 = M[offset + 9];
              var M_offset_10 = M[offset + 10];
              var M_offset_11 = M[offset + 11];
              var M_offset_12 = M[offset + 12];
              var M_offset_13 = M[offset + 13];
              var M_offset_14 = M[offset + 14];
              var M_offset_15 = M[offset + 15];
              var a2 = H[0];
              var b2 = H[1];
              var c2 = H[2];
              var d2 = H[3];
              a2 = FF(a2, b2, c2, d2, M_offset_0, 7, T[0]);
              d2 = FF(d2, a2, b2, c2, M_offset_1, 12, T[1]);
              c2 = FF(c2, d2, a2, b2, M_offset_2, 17, T[2]);
              b2 = FF(b2, c2, d2, a2, M_offset_3, 22, T[3]);
              a2 = FF(a2, b2, c2, d2, M_offset_4, 7, T[4]);
              d2 = FF(d2, a2, b2, c2, M_offset_5, 12, T[5]);
              c2 = FF(c2, d2, a2, b2, M_offset_6, 17, T[6]);
              b2 = FF(b2, c2, d2, a2, M_offset_7, 22, T[7]);
              a2 = FF(a2, b2, c2, d2, M_offset_8, 7, T[8]);
              d2 = FF(d2, a2, b2, c2, M_offset_9, 12, T[9]);
              c2 = FF(c2, d2, a2, b2, M_offset_10, 17, T[10]);
              b2 = FF(b2, c2, d2, a2, M_offset_11, 22, T[11]);
              a2 = FF(a2, b2, c2, d2, M_offset_12, 7, T[12]);
              d2 = FF(d2, a2, b2, c2, M_offset_13, 12, T[13]);
              c2 = FF(c2, d2, a2, b2, M_offset_14, 17, T[14]);
              b2 = FF(b2, c2, d2, a2, M_offset_15, 22, T[15]);
              a2 = GG(a2, b2, c2, d2, M_offset_1, 5, T[16]);
              d2 = GG(d2, a2, b2, c2, M_offset_6, 9, T[17]);
              c2 = GG(c2, d2, a2, b2, M_offset_11, 14, T[18]);
              b2 = GG(b2, c2, d2, a2, M_offset_0, 20, T[19]);
              a2 = GG(a2, b2, c2, d2, M_offset_5, 5, T[20]);
              d2 = GG(d2, a2, b2, c2, M_offset_10, 9, T[21]);
              c2 = GG(c2, d2, a2, b2, M_offset_15, 14, T[22]);
              b2 = GG(b2, c2, d2, a2, M_offset_4, 20, T[23]);
              a2 = GG(a2, b2, c2, d2, M_offset_9, 5, T[24]);
              d2 = GG(d2, a2, b2, c2, M_offset_14, 9, T[25]);
              c2 = GG(c2, d2, a2, b2, M_offset_3, 14, T[26]);
              b2 = GG(b2, c2, d2, a2, M_offset_8, 20, T[27]);
              a2 = GG(a2, b2, c2, d2, M_offset_13, 5, T[28]);
              d2 = GG(d2, a2, b2, c2, M_offset_2, 9, T[29]);
              c2 = GG(c2, d2, a2, b2, M_offset_7, 14, T[30]);
              b2 = GG(b2, c2, d2, a2, M_offset_12, 20, T[31]);
              a2 = HH(a2, b2, c2, d2, M_offset_5, 4, T[32]);
              d2 = HH(d2, a2, b2, c2, M_offset_8, 11, T[33]);
              c2 = HH(c2, d2, a2, b2, M_offset_11, 16, T[34]);
              b2 = HH(b2, c2, d2, a2, M_offset_14, 23, T[35]);
              a2 = HH(a2, b2, c2, d2, M_offset_1, 4, T[36]);
              d2 = HH(d2, a2, b2, c2, M_offset_4, 11, T[37]);
              c2 = HH(c2, d2, a2, b2, M_offset_7, 16, T[38]);
              b2 = HH(b2, c2, d2, a2, M_offset_10, 23, T[39]);
              a2 = HH(a2, b2, c2, d2, M_offset_13, 4, T[40]);
              d2 = HH(d2, a2, b2, c2, M_offset_0, 11, T[41]);
              c2 = HH(c2, d2, a2, b2, M_offset_3, 16, T[42]);
              b2 = HH(b2, c2, d2, a2, M_offset_6, 23, T[43]);
              a2 = HH(a2, b2, c2, d2, M_offset_9, 4, T[44]);
              d2 = HH(d2, a2, b2, c2, M_offset_12, 11, T[45]);
              c2 = HH(c2, d2, a2, b2, M_offset_15, 16, T[46]);
              b2 = HH(b2, c2, d2, a2, M_offset_2, 23, T[47]);
              a2 = II(a2, b2, c2, d2, M_offset_0, 6, T[48]);
              d2 = II(d2, a2, b2, c2, M_offset_7, 10, T[49]);
              c2 = II(c2, d2, a2, b2, M_offset_14, 15, T[50]);
              b2 = II(b2, c2, d2, a2, M_offset_5, 21, T[51]);
              a2 = II(a2, b2, c2, d2, M_offset_12, 6, T[52]);
              d2 = II(d2, a2, b2, c2, M_offset_3, 10, T[53]);
              c2 = II(c2, d2, a2, b2, M_offset_10, 15, T[54]);
              b2 = II(b2, c2, d2, a2, M_offset_1, 21, T[55]);
              a2 = II(a2, b2, c2, d2, M_offset_8, 6, T[56]);
              d2 = II(d2, a2, b2, c2, M_offset_15, 10, T[57]);
              c2 = II(c2, d2, a2, b2, M_offset_6, 15, T[58]);
              b2 = II(b2, c2, d2, a2, M_offset_13, 21, T[59]);
              a2 = II(a2, b2, c2, d2, M_offset_4, 6, T[60]);
              d2 = II(d2, a2, b2, c2, M_offset_11, 10, T[61]);
              c2 = II(c2, d2, a2, b2, M_offset_2, 15, T[62]);
              b2 = II(b2, c2, d2, a2, M_offset_9, 21, T[63]);
              H[0] = H[0] + a2 | 0;
              H[1] = H[1] + b2 | 0;
              H[2] = H[2] + c2 | 0;
              H[3] = H[3] + d2 | 0;
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              var nBitsTotal = this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
              var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
              var nBitsTotalL = nBitsTotal;
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
              data2.sigBytes = (dataWords.length + 1) * 4;
              this._process();
              var hash = this._hash;
              var H = hash.words;
              for (var i2 = 0; i2 < 4; i2++) {
                var H_i = H[i2];
                H[i2] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
              }
              return hash;
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              clone._hash = this._hash.clone();
              return clone;
            }
          });
          function FF(a2, b2, c2, d2, x, s, t) {
            var n = a2 + (b2 & c2 | ~b2 & d2) + x + t;
            return (n << s | n >>> 32 - s) + b2;
          }
          function GG(a2, b2, c2, d2, x, s, t) {
            var n = a2 + (b2 & d2 | c2 & ~d2) + x + t;
            return (n << s | n >>> 32 - s) + b2;
          }
          function HH(a2, b2, c2, d2, x, s, t) {
            var n = a2 + (b2 ^ c2 ^ d2) + x + t;
            return (n << s | n >>> 32 - s) + b2;
          }
          function II(a2, b2, c2, d2, x, s, t) {
            var n = a2 + (c2 ^ (b2 | ~d2)) + x + t;
            return (n << s | n >>> 32 - s) + b2;
          }
          C.MD5 = Hasher._createHelper(MD5);
          C.HmacMD5 = Hasher._createHmacHelper(MD5);
        })(Math);
        return CryptoJS2.MD5;
      });
    })(md5);
    return md5.exports;
  }
  var sha1 = { exports: {} };
  var hasRequiredSha1;
  function requireSha1() {
    if (hasRequiredSha1)
      return sha1.exports;
    hasRequiredSha1 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var Hasher = C_lib.Hasher;
          var C_algo = C.algo;
          var W = [];
          var SHA1 = C_algo.SHA1 = Hasher.extend({
            _doReset: function() {
              this._hash = new WordArray.init([
                1732584193,
                4023233417,
                2562383102,
                271733878,
                3285377520
              ]);
            },
            _doProcessBlock: function(M, offset) {
              var H = this._hash.words;
              var a2 = H[0];
              var b2 = H[1];
              var c2 = H[2];
              var d2 = H[3];
              var e = H[4];
              for (var i2 = 0; i2 < 80; i2++) {
                if (i2 < 16) {
                  W[i2] = M[offset + i2] | 0;
                } else {
                  var n = W[i2 - 3] ^ W[i2 - 8] ^ W[i2 - 14] ^ W[i2 - 16];
                  W[i2] = n << 1 | n >>> 31;
                }
                var t = (a2 << 5 | a2 >>> 27) + e + W[i2];
                if (i2 < 20) {
                  t += (b2 & c2 | ~b2 & d2) + 1518500249;
                } else if (i2 < 40) {
                  t += (b2 ^ c2 ^ d2) + 1859775393;
                } else if (i2 < 60) {
                  t += (b2 & c2 | b2 & d2 | c2 & d2) - 1894007588;
                } else {
                  t += (b2 ^ c2 ^ d2) - 899497514;
                }
                e = d2;
                d2 = c2;
                c2 = b2 << 30 | b2 >>> 2;
                b2 = a2;
                a2 = t;
              }
              H[0] = H[0] + a2 | 0;
              H[1] = H[1] + b2 | 0;
              H[2] = H[2] + c2 | 0;
              H[3] = H[3] + d2 | 0;
              H[4] = H[4] + e | 0;
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              var nBitsTotal = this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
              data2.sigBytes = dataWords.length * 4;
              this._process();
              return this._hash;
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              clone._hash = this._hash.clone();
              return clone;
            }
          });
          C.SHA1 = Hasher._createHelper(SHA1);
          C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
        })();
        return CryptoJS2.SHA1;
      });
    })(sha1);
    return sha1.exports;
  }
  var sha256 = { exports: {} };
  var hasRequiredSha256;
  function requireSha256() {
    if (hasRequiredSha256)
      return sha256.exports;
    hasRequiredSha256 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function(Math2) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var Hasher = C_lib.Hasher;
          var C_algo = C.algo;
          var H = [];
          var K = [];
          (function() {
            function isPrime(n2) {
              var sqrtN = Math2.sqrt(n2);
              for (var factor = 2; factor <= sqrtN; factor++) {
                if (!(n2 % factor)) {
                  return false;
                }
              }
              return true;
            }
            function getFractionalBits(n2) {
              return (n2 - (n2 | 0)) * 4294967296 | 0;
            }
            var n = 2;
            var nPrime = 0;
            while (nPrime < 64) {
              if (isPrime(n)) {
                if (nPrime < 8) {
                  H[nPrime] = getFractionalBits(Math2.pow(n, 1 / 2));
                }
                K[nPrime] = getFractionalBits(Math2.pow(n, 1 / 3));
                nPrime++;
              }
              n++;
            }
          })();
          var W = [];
          var SHA256 = C_algo.SHA256 = Hasher.extend({
            _doReset: function() {
              this._hash = new WordArray.init(H.slice(0));
            },
            _doProcessBlock: function(M, offset) {
              var H2 = this._hash.words;
              var a2 = H2[0];
              var b2 = H2[1];
              var c2 = H2[2];
              var d2 = H2[3];
              var e = H2[4];
              var f = H2[5];
              var g = H2[6];
              var h = H2[7];
              for (var i2 = 0; i2 < 64; i2++) {
                if (i2 < 16) {
                  W[i2] = M[offset + i2] | 0;
                } else {
                  var gamma0x = W[i2 - 15];
                  var gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
                  var gamma1x = W[i2 - 2];
                  var gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
                  W[i2] = gamma0 + W[i2 - 7] + gamma1 + W[i2 - 16];
                }
                var ch = e & f ^ ~e & g;
                var maj = a2 & b2 ^ a2 & c2 ^ b2 & c2;
                var sigma0 = (a2 << 30 | a2 >>> 2) ^ (a2 << 19 | a2 >>> 13) ^ (a2 << 10 | a2 >>> 22);
                var sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
                var t1 = h + sigma1 + ch + K[i2] + W[i2];
                var t2 = sigma0 + maj;
                h = g;
                g = f;
                f = e;
                e = d2 + t1 | 0;
                d2 = c2;
                c2 = b2;
                b2 = a2;
                a2 = t1 + t2 | 0;
              }
              H2[0] = H2[0] + a2 | 0;
              H2[1] = H2[1] + b2 | 0;
              H2[2] = H2[2] + c2 | 0;
              H2[3] = H2[3] + d2 | 0;
              H2[4] = H2[4] + e | 0;
              H2[5] = H2[5] + f | 0;
              H2[6] = H2[6] + g | 0;
              H2[7] = H2[7] + h | 0;
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              var nBitsTotal = this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math2.floor(nBitsTotal / 4294967296);
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
              data2.sigBytes = dataWords.length * 4;
              this._process();
              return this._hash;
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              clone._hash = this._hash.clone();
              return clone;
            }
          });
          C.SHA256 = Hasher._createHelper(SHA256);
          C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
        })(Math);
        return CryptoJS2.SHA256;
      });
    })(sha256);
    return sha256.exports;
  }
  var sha224 = { exports: {} };
  var hasRequiredSha224;
  function requireSha224() {
    if (hasRequiredSha224)
      return sha224.exports;
    hasRequiredSha224 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireSha256());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var C_algo = C.algo;
          var SHA256 = C_algo.SHA256;
          var SHA224 = C_algo.SHA224 = SHA256.extend({
            _doReset: function() {
              this._hash = new WordArray.init([
                3238371032,
                914150663,
                812702999,
                4144912697,
                4290775857,
                1750603025,
                1694076839,
                3204075428
              ]);
            },
            _doFinalize: function() {
              var hash = SHA256._doFinalize.call(this);
              hash.sigBytes -= 4;
              return hash;
            }
          });
          C.SHA224 = SHA256._createHelper(SHA224);
          C.HmacSHA224 = SHA256._createHmacHelper(SHA224);
        })();
        return CryptoJS2.SHA224;
      });
    })(sha224);
    return sha224.exports;
  }
  var sha512 = { exports: {} };
  var hasRequiredSha512;
  function requireSha512() {
    if (hasRequiredSha512)
      return sha512.exports;
    hasRequiredSha512 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireX64Core());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Hasher = C_lib.Hasher;
          var C_x64 = C.x64;
          var X64Word = C_x64.Word;
          var X64WordArray = C_x64.WordArray;
          var C_algo = C.algo;
          function X64Word_create() {
            return X64Word.create.apply(X64Word, arguments);
          }
          var K = [
            X64Word_create(1116352408, 3609767458),
            X64Word_create(1899447441, 602891725),
            X64Word_create(3049323471, 3964484399),
            X64Word_create(3921009573, 2173295548),
            X64Word_create(961987163, 4081628472),
            X64Word_create(1508970993, 3053834265),
            X64Word_create(2453635748, 2937671579),
            X64Word_create(2870763221, 3664609560),
            X64Word_create(3624381080, 2734883394),
            X64Word_create(310598401, 1164996542),
            X64Word_create(607225278, 1323610764),
            X64Word_create(1426881987, 3590304994),
            X64Word_create(1925078388, 4068182383),
            X64Word_create(2162078206, 991336113),
            X64Word_create(2614888103, 633803317),
            X64Word_create(3248222580, 3479774868),
            X64Word_create(3835390401, 2666613458),
            X64Word_create(4022224774, 944711139),
            X64Word_create(264347078, 2341262773),
            X64Word_create(604807628, 2007800933),
            X64Word_create(770255983, 1495990901),
            X64Word_create(1249150122, 1856431235),
            X64Word_create(1555081692, 3175218132),
            X64Word_create(1996064986, 2198950837),
            X64Word_create(2554220882, 3999719339),
            X64Word_create(2821834349, 766784016),
            X64Word_create(2952996808, 2566594879),
            X64Word_create(3210313671, 3203337956),
            X64Word_create(3336571891, 1034457026),
            X64Word_create(3584528711, 2466948901),
            X64Word_create(113926993, 3758326383),
            X64Word_create(338241895, 168717936),
            X64Word_create(666307205, 1188179964),
            X64Word_create(773529912, 1546045734),
            X64Word_create(1294757372, 1522805485),
            X64Word_create(1396182291, 2643833823),
            X64Word_create(1695183700, 2343527390),
            X64Word_create(1986661051, 1014477480),
            X64Word_create(2177026350, 1206759142),
            X64Word_create(2456956037, 344077627),
            X64Word_create(2730485921, 1290863460),
            X64Word_create(2820302411, 3158454273),
            X64Word_create(3259730800, 3505952657),
            X64Word_create(3345764771, 106217008),
            X64Word_create(3516065817, 3606008344),
            X64Word_create(3600352804, 1432725776),
            X64Word_create(4094571909, 1467031594),
            X64Word_create(275423344, 851169720),
            X64Word_create(430227734, 3100823752),
            X64Word_create(506948616, 1363258195),
            X64Word_create(659060556, 3750685593),
            X64Word_create(883997877, 3785050280),
            X64Word_create(958139571, 3318307427),
            X64Word_create(1322822218, 3812723403),
            X64Word_create(1537002063, 2003034995),
            X64Word_create(1747873779, 3602036899),
            X64Word_create(1955562222, 1575990012),
            X64Word_create(2024104815, 1125592928),
            X64Word_create(2227730452, 2716904306),
            X64Word_create(2361852424, 442776044),
            X64Word_create(2428436474, 593698344),
            X64Word_create(2756734187, 3733110249),
            X64Word_create(3204031479, 2999351573),
            X64Word_create(3329325298, 3815920427),
            X64Word_create(3391569614, 3928383900),
            X64Word_create(3515267271, 566280711),
            X64Word_create(3940187606, 3454069534),
            X64Word_create(4118630271, 4000239992),
            X64Word_create(116418474, 1914138554),
            X64Word_create(174292421, 2731055270),
            X64Word_create(289380356, 3203993006),
            X64Word_create(460393269, 320620315),
            X64Word_create(685471733, 587496836),
            X64Word_create(852142971, 1086792851),
            X64Word_create(1017036298, 365543100),
            X64Word_create(1126000580, 2618297676),
            X64Word_create(1288033470, 3409855158),
            X64Word_create(1501505948, 4234509866),
            X64Word_create(1607167915, 987167468),
            X64Word_create(1816402316, 1246189591)
          ];
          var W = [];
          (function() {
            for (var i2 = 0; i2 < 80; i2++) {
              W[i2] = X64Word_create();
            }
          })();
          var SHA512 = C_algo.SHA512 = Hasher.extend({
            _doReset: function() {
              this._hash = new X64WordArray.init([
                new X64Word.init(1779033703, 4089235720),
                new X64Word.init(3144134277, 2227873595),
                new X64Word.init(1013904242, 4271175723),
                new X64Word.init(2773480762, 1595750129),
                new X64Word.init(1359893119, 2917565137),
                new X64Word.init(2600822924, 725511199),
                new X64Word.init(528734635, 4215389547),
                new X64Word.init(1541459225, 327033209)
              ]);
            },
            _doProcessBlock: function(M, offset) {
              var H = this._hash.words;
              var H0 = H[0];
              var H1 = H[1];
              var H2 = H[2];
              var H3 = H[3];
              var H4 = H[4];
              var H5 = H[5];
              var H6 = H[6];
              var H7 = H[7];
              var H0h = H0.high;
              var H0l = H0.low;
              var H1h = H1.high;
              var H1l = H1.low;
              var H2h = H2.high;
              var H2l = H2.low;
              var H3h = H3.high;
              var H3l = H3.low;
              var H4h = H4.high;
              var H4l = H4.low;
              var H5h = H5.high;
              var H5l = H5.low;
              var H6h = H6.high;
              var H6l = H6.low;
              var H7h = H7.high;
              var H7l = H7.low;
              var ah = H0h;
              var al = H0l;
              var bh = H1h;
              var bl = H1l;
              var ch = H2h;
              var cl = H2l;
              var dh = H3h;
              var dl = H3l;
              var eh = H4h;
              var el = H4l;
              var fh = H5h;
              var fl = H5l;
              var gh = H6h;
              var gl = H6l;
              var hh = H7h;
              var hl = H7l;
              for (var i2 = 0; i2 < 80; i2++) {
                var Wil;
                var Wih;
                var Wi = W[i2];
                if (i2 < 16) {
                  Wih = Wi.high = M[offset + i2 * 2] | 0;
                  Wil = Wi.low = M[offset + i2 * 2 + 1] | 0;
                } else {
                  var gamma0x = W[i2 - 15];
                  var gamma0xh = gamma0x.high;
                  var gamma0xl = gamma0x.low;
                  var gamma0h = (gamma0xh >>> 1 | gamma0xl << 31) ^ (gamma0xh >>> 8 | gamma0xl << 24) ^ gamma0xh >>> 7;
                  var gamma0l = (gamma0xl >>> 1 | gamma0xh << 31) ^ (gamma0xl >>> 8 | gamma0xh << 24) ^ (gamma0xl >>> 7 | gamma0xh << 25);
                  var gamma1x = W[i2 - 2];
                  var gamma1xh = gamma1x.high;
                  var gamma1xl = gamma1x.low;
                  var gamma1h = (gamma1xh >>> 19 | gamma1xl << 13) ^ (gamma1xh << 3 | gamma1xl >>> 29) ^ gamma1xh >>> 6;
                  var gamma1l = (gamma1xl >>> 19 | gamma1xh << 13) ^ (gamma1xl << 3 | gamma1xh >>> 29) ^ (gamma1xl >>> 6 | gamma1xh << 26);
                  var Wi7 = W[i2 - 7];
                  var Wi7h = Wi7.high;
                  var Wi7l = Wi7.low;
                  var Wi16 = W[i2 - 16];
                  var Wi16h = Wi16.high;
                  var Wi16l = Wi16.low;
                  Wil = gamma0l + Wi7l;
                  Wih = gamma0h + Wi7h + (Wil >>> 0 < gamma0l >>> 0 ? 1 : 0);
                  Wil = Wil + gamma1l;
                  Wih = Wih + gamma1h + (Wil >>> 0 < gamma1l >>> 0 ? 1 : 0);
                  Wil = Wil + Wi16l;
                  Wih = Wih + Wi16h + (Wil >>> 0 < Wi16l >>> 0 ? 1 : 0);
                  Wi.high = Wih;
                  Wi.low = Wil;
                }
                var chh = eh & fh ^ ~eh & gh;
                var chl = el & fl ^ ~el & gl;
                var majh = ah & bh ^ ah & ch ^ bh & ch;
                var majl = al & bl ^ al & cl ^ bl & cl;
                var sigma0h = (ah >>> 28 | al << 4) ^ (ah << 30 | al >>> 2) ^ (ah << 25 | al >>> 7);
                var sigma0l = (al >>> 28 | ah << 4) ^ (al << 30 | ah >>> 2) ^ (al << 25 | ah >>> 7);
                var sigma1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (eh << 23 | el >>> 9);
                var sigma1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (el << 23 | eh >>> 9);
                var Ki = K[i2];
                var Kih = Ki.high;
                var Kil = Ki.low;
                var t1l = hl + sigma1l;
                var t1h = hh + sigma1h + (t1l >>> 0 < hl >>> 0 ? 1 : 0);
                var t1l = t1l + chl;
                var t1h = t1h + chh + (t1l >>> 0 < chl >>> 0 ? 1 : 0);
                var t1l = t1l + Kil;
                var t1h = t1h + Kih + (t1l >>> 0 < Kil >>> 0 ? 1 : 0);
                var t1l = t1l + Wil;
                var t1h = t1h + Wih + (t1l >>> 0 < Wil >>> 0 ? 1 : 0);
                var t2l = sigma0l + majl;
                var t2h = sigma0h + majh + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0);
                hh = gh;
                hl = gl;
                gh = fh;
                gl = fl;
                fh = eh;
                fl = el;
                el = dl + t1l | 0;
                eh = dh + t1h + (el >>> 0 < dl >>> 0 ? 1 : 0) | 0;
                dh = ch;
                dl = cl;
                ch = bh;
                cl = bl;
                bh = ah;
                bl = al;
                al = t1l + t2l | 0;
                ah = t1h + t2h + (al >>> 0 < t1l >>> 0 ? 1 : 0) | 0;
              }
              H0l = H0.low = H0l + al;
              H0.high = H0h + ah + (H0l >>> 0 < al >>> 0 ? 1 : 0);
              H1l = H1.low = H1l + bl;
              H1.high = H1h + bh + (H1l >>> 0 < bl >>> 0 ? 1 : 0);
              H2l = H2.low = H2l + cl;
              H2.high = H2h + ch + (H2l >>> 0 < cl >>> 0 ? 1 : 0);
              H3l = H3.low = H3l + dl;
              H3.high = H3h + dh + (H3l >>> 0 < dl >>> 0 ? 1 : 0);
              H4l = H4.low = H4l + el;
              H4.high = H4h + eh + (H4l >>> 0 < el >>> 0 ? 1 : 0);
              H5l = H5.low = H5l + fl;
              H5.high = H5h + fh + (H5l >>> 0 < fl >>> 0 ? 1 : 0);
              H6l = H6.low = H6l + gl;
              H6.high = H6h + gh + (H6l >>> 0 < gl >>> 0 ? 1 : 0);
              H7l = H7.low = H7l + hl;
              H7.high = H7h + hh + (H7l >>> 0 < hl >>> 0 ? 1 : 0);
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              var nBitsTotal = this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
              dataWords[(nBitsLeft + 128 >>> 10 << 5) + 30] = Math.floor(nBitsTotal / 4294967296);
              dataWords[(nBitsLeft + 128 >>> 10 << 5) + 31] = nBitsTotal;
              data2.sigBytes = dataWords.length * 4;
              this._process();
              var hash = this._hash.toX32();
              return hash;
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              clone._hash = this._hash.clone();
              return clone;
            },
            blockSize: 1024 / 32
          });
          C.SHA512 = Hasher._createHelper(SHA512);
          C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
        })();
        return CryptoJS2.SHA512;
      });
    })(sha512);
    return sha512.exports;
  }
  var sha384 = { exports: {} };
  var hasRequiredSha384;
  function requireSha384() {
    if (hasRequiredSha384)
      return sha384.exports;
    hasRequiredSha384 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireX64Core(), requireSha512());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_x64 = C.x64;
          var X64Word = C_x64.Word;
          var X64WordArray = C_x64.WordArray;
          var C_algo = C.algo;
          var SHA512 = C_algo.SHA512;
          var SHA384 = C_algo.SHA384 = SHA512.extend({
            _doReset: function() {
              this._hash = new X64WordArray.init([
                new X64Word.init(3418070365, 3238371032),
                new X64Word.init(1654270250, 914150663),
                new X64Word.init(2438529370, 812702999),
                new X64Word.init(355462360, 4144912697),
                new X64Word.init(1731405415, 4290775857),
                new X64Word.init(2394180231, 1750603025),
                new X64Word.init(3675008525, 1694076839),
                new X64Word.init(1203062813, 3204075428)
              ]);
            },
            _doFinalize: function() {
              var hash = SHA512._doFinalize.call(this);
              hash.sigBytes -= 16;
              return hash;
            }
          });
          C.SHA384 = SHA512._createHelper(SHA384);
          C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
        })();
        return CryptoJS2.SHA384;
      });
    })(sha384);
    return sha384.exports;
  }
  var sha3 = { exports: {} };
  var hasRequiredSha3;
  function requireSha3() {
    if (hasRequiredSha3)
      return sha3.exports;
    hasRequiredSha3 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireX64Core());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function(Math2) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var Hasher = C_lib.Hasher;
          var C_x64 = C.x64;
          var X64Word = C_x64.Word;
          var C_algo = C.algo;
          var RHO_OFFSETS = [];
          var PI_INDEXES = [];
          var ROUND_CONSTANTS = [];
          (function() {
            var x = 1, y = 0;
            for (var t = 0; t < 24; t++) {
              RHO_OFFSETS[x + 5 * y] = (t + 1) * (t + 2) / 2 % 64;
              var newX = y % 5;
              var newY = (2 * x + 3 * y) % 5;
              x = newX;
              y = newY;
            }
            for (var x = 0; x < 5; x++) {
              for (var y = 0; y < 5; y++) {
                PI_INDEXES[x + 5 * y] = y + (2 * x + 3 * y) % 5 * 5;
              }
            }
            var LFSR = 1;
            for (var i2 = 0; i2 < 24; i2++) {
              var roundConstantMsw = 0;
              var roundConstantLsw = 0;
              for (var j2 = 0; j2 < 7; j2++) {
                if (LFSR & 1) {
                  var bitPosition = (1 << j2) - 1;
                  if (bitPosition < 32) {
                    roundConstantLsw ^= 1 << bitPosition;
                  } else {
                    roundConstantMsw ^= 1 << bitPosition - 32;
                  }
                }
                if (LFSR & 128) {
                  LFSR = LFSR << 1 ^ 113;
                } else {
                  LFSR <<= 1;
                }
              }
              ROUND_CONSTANTS[i2] = X64Word.create(roundConstantMsw, roundConstantLsw);
            }
          })();
          var T = [];
          (function() {
            for (var i2 = 0; i2 < 25; i2++) {
              T[i2] = X64Word.create();
            }
          })();
          var SHA3 = C_algo.SHA3 = Hasher.extend({
            /**
             * Configuration options.
             *
             * @property {number} outputLength
             *   The desired number of bits in the output hash.
             *   Only values permitted are: 224, 256, 384, 512.
             *   Default: 512
             */
            cfg: Hasher.cfg.extend({
              outputLength: 512
            }),
            _doReset: function() {
              var state = this._state = [];
              for (var i2 = 0; i2 < 25; i2++) {
                state[i2] = new X64Word.init();
              }
              this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
            },
            _doProcessBlock: function(M, offset) {
              var state = this._state;
              var nBlockSizeLanes = this.blockSize / 2;
              for (var i2 = 0; i2 < nBlockSizeLanes; i2++) {
                var M2i = M[offset + 2 * i2];
                var M2i1 = M[offset + 2 * i2 + 1];
                M2i = (M2i << 8 | M2i >>> 24) & 16711935 | (M2i << 24 | M2i >>> 8) & 4278255360;
                M2i1 = (M2i1 << 8 | M2i1 >>> 24) & 16711935 | (M2i1 << 24 | M2i1 >>> 8) & 4278255360;
                var lane = state[i2];
                lane.high ^= M2i1;
                lane.low ^= M2i;
              }
              for (var round = 0; round < 24; round++) {
                for (var x = 0; x < 5; x++) {
                  var tMsw = 0, tLsw = 0;
                  for (var y = 0; y < 5; y++) {
                    var lane = state[x + 5 * y];
                    tMsw ^= lane.high;
                    tLsw ^= lane.low;
                  }
                  var Tx = T[x];
                  Tx.high = tMsw;
                  Tx.low = tLsw;
                }
                for (var x = 0; x < 5; x++) {
                  var Tx4 = T[(x + 4) % 5];
                  var Tx1 = T[(x + 1) % 5];
                  var Tx1Msw = Tx1.high;
                  var Tx1Lsw = Tx1.low;
                  var tMsw = Tx4.high ^ (Tx1Msw << 1 | Tx1Lsw >>> 31);
                  var tLsw = Tx4.low ^ (Tx1Lsw << 1 | Tx1Msw >>> 31);
                  for (var y = 0; y < 5; y++) {
                    var lane = state[x + 5 * y];
                    lane.high ^= tMsw;
                    lane.low ^= tLsw;
                  }
                }
                for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
                  var tMsw;
                  var tLsw;
                  var lane = state[laneIndex];
                  var laneMsw = lane.high;
                  var laneLsw = lane.low;
                  var rhoOffset = RHO_OFFSETS[laneIndex];
                  if (rhoOffset < 32) {
                    tMsw = laneMsw << rhoOffset | laneLsw >>> 32 - rhoOffset;
                    tLsw = laneLsw << rhoOffset | laneMsw >>> 32 - rhoOffset;
                  } else {
                    tMsw = laneLsw << rhoOffset - 32 | laneMsw >>> 64 - rhoOffset;
                    tLsw = laneMsw << rhoOffset - 32 | laneLsw >>> 64 - rhoOffset;
                  }
                  var TPiLane = T[PI_INDEXES[laneIndex]];
                  TPiLane.high = tMsw;
                  TPiLane.low = tLsw;
                }
                var T0 = T[0];
                var state0 = state[0];
                T0.high = state0.high;
                T0.low = state0.low;
                for (var x = 0; x < 5; x++) {
                  for (var y = 0; y < 5; y++) {
                    var laneIndex = x + 5 * y;
                    var lane = state[laneIndex];
                    var TLane = T[laneIndex];
                    var Tx1Lane = T[(x + 1) % 5 + 5 * y];
                    var Tx2Lane = T[(x + 2) % 5 + 5 * y];
                    lane.high = TLane.high ^ ~Tx1Lane.high & Tx2Lane.high;
                    lane.low = TLane.low ^ ~Tx1Lane.low & Tx2Lane.low;
                  }
                }
                var lane = state[0];
                var roundConstant = ROUND_CONSTANTS[round];
                lane.high ^= roundConstant.high;
                lane.low ^= roundConstant.low;
              }
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              var blockSizeBits = this.blockSize * 32;
              dataWords[nBitsLeft >>> 5] |= 1 << 24 - nBitsLeft % 32;
              dataWords[(Math2.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits >>> 5) - 1] |= 128;
              data2.sigBytes = dataWords.length * 4;
              this._process();
              var state = this._state;
              var outputLengthBytes = this.cfg.outputLength / 8;
              var outputLengthLanes = outputLengthBytes / 8;
              var hashWords = [];
              for (var i2 = 0; i2 < outputLengthLanes; i2++) {
                var lane = state[i2];
                var laneMsw = lane.high;
                var laneLsw = lane.low;
                laneMsw = (laneMsw << 8 | laneMsw >>> 24) & 16711935 | (laneMsw << 24 | laneMsw >>> 8) & 4278255360;
                laneLsw = (laneLsw << 8 | laneLsw >>> 24) & 16711935 | (laneLsw << 24 | laneLsw >>> 8) & 4278255360;
                hashWords.push(laneLsw);
                hashWords.push(laneMsw);
              }
              return new WordArray.init(hashWords, outputLengthBytes);
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              var state = clone._state = this._state.slice(0);
              for (var i2 = 0; i2 < 25; i2++) {
                state[i2] = state[i2].clone();
              }
              return clone;
            }
          });
          C.SHA3 = Hasher._createHelper(SHA3);
          C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
        })(Math);
        return CryptoJS2.SHA3;
      });
    })(sha3);
    return sha3.exports;
  }
  var ripemd160 = { exports: {} };
  var hasRequiredRipemd160;
  function requireRipemd160() {
    if (hasRequiredRipemd160)
      return ripemd160.exports;
    hasRequiredRipemd160 = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        /** @preserve
        			(c) 2012 by Cédric Mesnil. All rights reserved.
        
        			Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
        
        			    - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
        			    - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
        
        			THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
        			*/
        (function(Math2) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var Hasher = C_lib.Hasher;
          var C_algo = C.algo;
          var _zl = WordArray.create([
            0,
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            10,
            11,
            12,
            13,
            14,
            15,
            7,
            4,
            13,
            1,
            10,
            6,
            15,
            3,
            12,
            0,
            9,
            5,
            2,
            14,
            11,
            8,
            3,
            10,
            14,
            4,
            9,
            15,
            8,
            1,
            2,
            7,
            0,
            6,
            13,
            11,
            5,
            12,
            1,
            9,
            11,
            10,
            0,
            8,
            12,
            4,
            13,
            3,
            7,
            15,
            14,
            5,
            6,
            2,
            4,
            0,
            5,
            9,
            7,
            12,
            2,
            10,
            14,
            1,
            3,
            8,
            11,
            6,
            15,
            13
          ]);
          var _zr = WordArray.create([
            5,
            14,
            7,
            0,
            9,
            2,
            11,
            4,
            13,
            6,
            15,
            8,
            1,
            10,
            3,
            12,
            6,
            11,
            3,
            7,
            0,
            13,
            5,
            10,
            14,
            15,
            8,
            12,
            4,
            9,
            1,
            2,
            15,
            5,
            1,
            3,
            7,
            14,
            6,
            9,
            11,
            8,
            12,
            2,
            10,
            0,
            4,
            13,
            8,
            6,
            4,
            1,
            3,
            11,
            15,
            0,
            5,
            12,
            2,
            13,
            9,
            7,
            10,
            14,
            12,
            15,
            10,
            4,
            1,
            5,
            8,
            7,
            6,
            2,
            13,
            14,
            0,
            3,
            9,
            11
          ]);
          var _sl = WordArray.create([
            11,
            14,
            15,
            12,
            5,
            8,
            7,
            9,
            11,
            13,
            14,
            15,
            6,
            7,
            9,
            8,
            7,
            6,
            8,
            13,
            11,
            9,
            7,
            15,
            7,
            12,
            15,
            9,
            11,
            7,
            13,
            12,
            11,
            13,
            6,
            7,
            14,
            9,
            13,
            15,
            14,
            8,
            13,
            6,
            5,
            12,
            7,
            5,
            11,
            12,
            14,
            15,
            14,
            15,
            9,
            8,
            9,
            14,
            5,
            6,
            8,
            6,
            5,
            12,
            9,
            15,
            5,
            11,
            6,
            8,
            13,
            12,
            5,
            12,
            13,
            14,
            11,
            8,
            5,
            6
          ]);
          var _sr = WordArray.create([
            8,
            9,
            9,
            11,
            13,
            15,
            15,
            5,
            7,
            7,
            8,
            11,
            14,
            14,
            12,
            6,
            9,
            13,
            15,
            7,
            12,
            8,
            9,
            11,
            7,
            7,
            12,
            7,
            6,
            15,
            13,
            11,
            9,
            7,
            15,
            11,
            8,
            6,
            6,
            14,
            12,
            13,
            5,
            14,
            13,
            13,
            7,
            5,
            15,
            5,
            8,
            11,
            14,
            14,
            6,
            14,
            6,
            9,
            12,
            9,
            12,
            5,
            15,
            8,
            8,
            5,
            12,
            9,
            12,
            5,
            14,
            6,
            8,
            13,
            6,
            5,
            15,
            13,
            11,
            11
          ]);
          var _hl = WordArray.create([0, 1518500249, 1859775393, 2400959708, 2840853838]);
          var _hr = WordArray.create([1352829926, 1548603684, 1836072691, 2053994217, 0]);
          var RIPEMD160 = C_algo.RIPEMD160 = Hasher.extend({
            _doReset: function() {
              this._hash = WordArray.create([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
            },
            _doProcessBlock: function(M, offset) {
              for (var i2 = 0; i2 < 16; i2++) {
                var offset_i = offset + i2;
                var M_offset_i = M[offset_i];
                M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
              }
              var H = this._hash.words;
              var hl = _hl.words;
              var hr = _hr.words;
              var zl = _zl.words;
              var zr = _zr.words;
              var sl = _sl.words;
              var sr = _sr.words;
              var al, bl, cl, dl, el;
              var ar, br, cr, dr, er;
              ar = al = H[0];
              br = bl = H[1];
              cr = cl = H[2];
              dr = dl = H[3];
              er = el = H[4];
              var t;
              for (var i2 = 0; i2 < 80; i2 += 1) {
                t = al + M[offset + zl[i2]] | 0;
                if (i2 < 16) {
                  t += f1(bl, cl, dl) + hl[0];
                } else if (i2 < 32) {
                  t += f2(bl, cl, dl) + hl[1];
                } else if (i2 < 48) {
                  t += f3(bl, cl, dl) + hl[2];
                } else if (i2 < 64) {
                  t += f4(bl, cl, dl) + hl[3];
                } else {
                  t += f5(bl, cl, dl) + hl[4];
                }
                t = t | 0;
                t = rotl(t, sl[i2]);
                t = t + el | 0;
                al = el;
                el = dl;
                dl = rotl(cl, 10);
                cl = bl;
                bl = t;
                t = ar + M[offset + zr[i2]] | 0;
                if (i2 < 16) {
                  t += f5(br, cr, dr) + hr[0];
                } else if (i2 < 32) {
                  t += f4(br, cr, dr) + hr[1];
                } else if (i2 < 48) {
                  t += f3(br, cr, dr) + hr[2];
                } else if (i2 < 64) {
                  t += f2(br, cr, dr) + hr[3];
                } else {
                  t += f1(br, cr, dr) + hr[4];
                }
                t = t | 0;
                t = rotl(t, sr[i2]);
                t = t + er | 0;
                ar = er;
                er = dr;
                dr = rotl(cr, 10);
                cr = br;
                br = t;
              }
              t = H[1] + cl + dr | 0;
              H[1] = H[2] + dl + er | 0;
              H[2] = H[3] + el + ar | 0;
              H[3] = H[4] + al + br | 0;
              H[4] = H[0] + bl + cr | 0;
              H[0] = t;
            },
            _doFinalize: function() {
              var data2 = this._data;
              var dataWords = data2.words;
              var nBitsTotal = this._nDataBytes * 8;
              var nBitsLeft = data2.sigBytes * 8;
              dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
              dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotal << 8 | nBitsTotal >>> 24) & 16711935 | (nBitsTotal << 24 | nBitsTotal >>> 8) & 4278255360;
              data2.sigBytes = (dataWords.length + 1) * 4;
              this._process();
              var hash = this._hash;
              var H = hash.words;
              for (var i2 = 0; i2 < 5; i2++) {
                var H_i = H[i2];
                H[i2] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
              }
              return hash;
            },
            clone: function() {
              var clone = Hasher.clone.call(this);
              clone._hash = this._hash.clone();
              return clone;
            }
          });
          function f1(x, y, z) {
            return x ^ y ^ z;
          }
          function f2(x, y, z) {
            return x & y | ~x & z;
          }
          function f3(x, y, z) {
            return (x | ~y) ^ z;
          }
          function f4(x, y, z) {
            return x & z | y & ~z;
          }
          function f5(x, y, z) {
            return x ^ (y | ~z);
          }
          function rotl(x, n) {
            return x << n | x >>> 32 - n;
          }
          C.RIPEMD160 = Hasher._createHelper(RIPEMD160);
          C.HmacRIPEMD160 = Hasher._createHmacHelper(RIPEMD160);
        })();
        return CryptoJS2.RIPEMD160;
      });
    })(ripemd160);
    return ripemd160.exports;
  }
  var hmac = { exports: {} };
  var hasRequiredHmac;
  function requireHmac() {
    if (hasRequiredHmac)
      return hmac.exports;
    hasRequiredHmac = 1;
    (function(module, exports) {
      (function(root, factory) {
        {
          module.exports = factory(requireCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Base = C_lib.Base;
          var C_enc = C.enc;
          var Utf8 = C_enc.Utf8;
          var C_algo = C.algo;
          C_algo.HMAC = Base.extend({
            /**
             * Initializes a newly created HMAC.
             *
             * @param {Hasher} hasher The hash algorithm to use.
             * @param {WordArray|string} key The secret key.
             *
             * @example
             *
             *     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
             */
            init: function(hasher, key2) {
              hasher = this._hasher = new hasher.init();
              if (typeof key2 == "string") {
                key2 = Utf8.parse(key2);
              }
              var hasherBlockSize = hasher.blockSize;
              var hasherBlockSizeBytes = hasherBlockSize * 4;
              if (key2.sigBytes > hasherBlockSizeBytes) {
                key2 = hasher.finalize(key2);
              }
              key2.clamp();
              var oKey = this._oKey = key2.clone();
              var iKey = this._iKey = key2.clone();
              var oKeyWords = oKey.words;
              var iKeyWords = iKey.words;
              for (var i2 = 0; i2 < hasherBlockSize; i2++) {
                oKeyWords[i2] ^= 1549556828;
                iKeyWords[i2] ^= 909522486;
              }
              oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
              this.reset();
            },
            /**
             * Resets this HMAC to its initial state.
             *
             * @example
             *
             *     hmacHasher.reset();
             */
            reset: function() {
              var hasher = this._hasher;
              hasher.reset();
              hasher.update(this._iKey);
            },
            /**
             * Updates this HMAC with a message.
             *
             * @param {WordArray|string} messageUpdate The message to append.
             *
             * @return {HMAC} This HMAC instance.
             *
             * @example
             *
             *     hmacHasher.update('message');
             *     hmacHasher.update(wordArray);
             */
            update: function(messageUpdate) {
              this._hasher.update(messageUpdate);
              return this;
            },
            /**
             * Finalizes the HMAC computation.
             * Note that the finalize operation is effectively a destructive, read-once operation.
             *
             * @param {WordArray|string} messageUpdate (Optional) A final message update.
             *
             * @return {WordArray} The HMAC.
             *
             * @example
             *
             *     var hmac = hmacHasher.finalize();
             *     var hmac = hmacHasher.finalize('message');
             *     var hmac = hmacHasher.finalize(wordArray);
             */
            finalize: function(messageUpdate) {
              var hasher = this._hasher;
              var innerHash = hasher.finalize(messageUpdate);
              hasher.reset();
              var hmac2 = hasher.finalize(this._oKey.clone().concat(innerHash));
              return hmac2;
            }
          });
        })();
      });
    })(hmac);
    return hmac.exports;
  }
  var pbkdf2 = { exports: {} };
  var hasRequiredPbkdf2;
  function requirePbkdf2() {
    if (hasRequiredPbkdf2)
      return pbkdf2.exports;
    hasRequiredPbkdf2 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireSha256(), requireHmac());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Base = C_lib.Base;
          var WordArray = C_lib.WordArray;
          var C_algo = C.algo;
          var SHA256 = C_algo.SHA256;
          var HMAC = C_algo.HMAC;
          var PBKDF2 = C_algo.PBKDF2 = Base.extend({
            /**
             * Configuration options.
             *
             * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
             * @property {Hasher} hasher The hasher to use. Default: SHA256
             * @property {number} iterations The number of iterations to perform. Default: 250000
             */
            cfg: Base.extend({
              keySize: 128 / 32,
              hasher: SHA256,
              iterations: 25e4
            }),
            /**
             * Initializes a newly created key derivation function.
             *
             * @param {Object} cfg (Optional) The configuration options to use for the derivation.
             *
             * @example
             *
             *     var kdf = CryptoJS.algo.PBKDF2.create();
             *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
             *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
             */
            init: function(cfg) {
              this.cfg = this.cfg.extend(cfg);
            },
            /**
             * Computes the Password-Based Key Derivation Function 2.
             *
             * @param {WordArray|string} password The password.
             * @param {WordArray|string} salt A salt.
             *
             * @return {WordArray} The derived key.
             *
             * @example
             *
             *     var key = kdf.compute(password, salt);
             */
            compute: function(password, salt) {
              var cfg = this.cfg;
              var hmac2 = HMAC.create(cfg.hasher, password);
              var derivedKey = WordArray.create();
              var blockIndex = WordArray.create([1]);
              var derivedKeyWords = derivedKey.words;
              var blockIndexWords = blockIndex.words;
              var keySize = cfg.keySize;
              var iterations = cfg.iterations;
              while (derivedKeyWords.length < keySize) {
                var block = hmac2.update(salt).finalize(blockIndex);
                hmac2.reset();
                var blockWords = block.words;
                var blockWordsLength = blockWords.length;
                var intermediate = block;
                for (var i2 = 1; i2 < iterations; i2++) {
                  intermediate = hmac2.finalize(intermediate);
                  hmac2.reset();
                  var intermediateWords = intermediate.words;
                  for (var j2 = 0; j2 < blockWordsLength; j2++) {
                    blockWords[j2] ^= intermediateWords[j2];
                  }
                }
                derivedKey.concat(block);
                blockIndexWords[0]++;
              }
              derivedKey.sigBytes = keySize * 4;
              return derivedKey;
            }
          });
          C.PBKDF2 = function(password, salt, cfg) {
            return PBKDF2.create(cfg).compute(password, salt);
          };
        })();
        return CryptoJS2.PBKDF2;
      });
    })(pbkdf2);
    return pbkdf2.exports;
  }
  var evpkdf = { exports: {} };
  var hasRequiredEvpkdf;
  function requireEvpkdf() {
    if (hasRequiredEvpkdf)
      return evpkdf.exports;
    hasRequiredEvpkdf = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireSha1(), requireHmac());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Base = C_lib.Base;
          var WordArray = C_lib.WordArray;
          var C_algo = C.algo;
          var MD5 = C_algo.MD5;
          var EvpKDF = C_algo.EvpKDF = Base.extend({
            /**
             * Configuration options.
             *
             * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
             * @property {Hasher} hasher The hash algorithm to use. Default: MD5
             * @property {number} iterations The number of iterations to perform. Default: 1
             */
            cfg: Base.extend({
              keySize: 128 / 32,
              hasher: MD5,
              iterations: 1
            }),
            /**
             * Initializes a newly created key derivation function.
             *
             * @param {Object} cfg (Optional) The configuration options to use for the derivation.
             *
             * @example
             *
             *     var kdf = CryptoJS.algo.EvpKDF.create();
             *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
             *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
             */
            init: function(cfg) {
              this.cfg = this.cfg.extend(cfg);
            },
            /**
             * Derives a key from a password.
             *
             * @param {WordArray|string} password The password.
             * @param {WordArray|string} salt A salt.
             *
             * @return {WordArray} The derived key.
             *
             * @example
             *
             *     var key = kdf.compute(password, salt);
             */
            compute: function(password, salt) {
              var block;
              var cfg = this.cfg;
              var hasher = cfg.hasher.create();
              var derivedKey = WordArray.create();
              var derivedKeyWords = derivedKey.words;
              var keySize = cfg.keySize;
              var iterations = cfg.iterations;
              while (derivedKeyWords.length < keySize) {
                if (block) {
                  hasher.update(block);
                }
                block = hasher.update(password).finalize(salt);
                hasher.reset();
                for (var i2 = 1; i2 < iterations; i2++) {
                  block = hasher.finalize(block);
                  hasher.reset();
                }
                derivedKey.concat(block);
              }
              derivedKey.sigBytes = keySize * 4;
              return derivedKey;
            }
          });
          C.EvpKDF = function(password, salt, cfg) {
            return EvpKDF.create(cfg).compute(password, salt);
          };
        })();
        return CryptoJS2.EvpKDF;
      });
    })(evpkdf);
    return evpkdf.exports;
  }
  var cipherCore = { exports: {} };
  var hasRequiredCipherCore;
  function requireCipherCore() {
    if (hasRequiredCipherCore)
      return cipherCore.exports;
    hasRequiredCipherCore = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEvpkdf());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.lib.Cipher || function(undefined$1) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var Base = C_lib.Base;
          var WordArray = C_lib.WordArray;
          var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
          var C_enc = C.enc;
          C_enc.Utf8;
          var Base64 = C_enc.Base64;
          var C_algo = C.algo;
          var EvpKDF = C_algo.EvpKDF;
          var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
            /**
             * Configuration options.
             *
             * @property {WordArray} iv The IV to use for this operation.
             */
            cfg: Base.extend(),
            /**
             * Creates this cipher in encryption mode.
             *
             * @param {WordArray} key The key.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {Cipher} A cipher instance.
             *
             * @static
             *
             * @example
             *
             *     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
             */
            createEncryptor: function(key2, cfg) {
              return this.create(this._ENC_XFORM_MODE, key2, cfg);
            },
            /**
             * Creates this cipher in decryption mode.
             *
             * @param {WordArray} key The key.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {Cipher} A cipher instance.
             *
             * @static
             *
             * @example
             *
             *     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
             */
            createDecryptor: function(key2, cfg) {
              return this.create(this._DEC_XFORM_MODE, key2, cfg);
            },
            /**
             * Initializes a newly created cipher.
             *
             * @param {number} xformMode Either the encryption or decryption transormation mode constant.
             * @param {WordArray} key The key.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @example
             *
             *     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
             */
            init: function(xformMode, key2, cfg) {
              this.cfg = this.cfg.extend(cfg);
              this._xformMode = xformMode;
              this._key = key2;
              this.reset();
            },
            /**
             * Resets this cipher to its initial state.
             *
             * @example
             *
             *     cipher.reset();
             */
            reset: function() {
              BufferedBlockAlgorithm.reset.call(this);
              this._doReset();
            },
            /**
             * Adds data to be encrypted or decrypted.
             *
             * @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
             *
             * @return {WordArray} The data after processing.
             *
             * @example
             *
             *     var encrypted = cipher.process('data');
             *     var encrypted = cipher.process(wordArray);
             */
            process: function(dataUpdate) {
              this._append(dataUpdate);
              return this._process();
            },
            /**
             * Finalizes the encryption or decryption process.
             * Note that the finalize operation is effectively a destructive, read-once operation.
             *
             * @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
             *
             * @return {WordArray} The data after final processing.
             *
             * @example
             *
             *     var encrypted = cipher.finalize();
             *     var encrypted = cipher.finalize('data');
             *     var encrypted = cipher.finalize(wordArray);
             */
            finalize: function(dataUpdate) {
              if (dataUpdate) {
                this._append(dataUpdate);
              }
              var finalProcessedData = this._doFinalize();
              return finalProcessedData;
            },
            keySize: 128 / 32,
            ivSize: 128 / 32,
            _ENC_XFORM_MODE: 1,
            _DEC_XFORM_MODE: 2,
            /**
             * Creates shortcut functions to a cipher's object interface.
             *
             * @param {Cipher} cipher The cipher to create a helper for.
             *
             * @return {Object} An object with encrypt and decrypt shortcut functions.
             *
             * @static
             *
             * @example
             *
             *     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
             */
            _createHelper: function() {
              function selectCipherStrategy(key2) {
                if (typeof key2 == "string") {
                  return PasswordBasedCipher;
                } else {
                  return SerializableCipher;
                }
              }
              return function(cipher) {
                return {
                  encrypt: function(message, key2, cfg) {
                    return selectCipherStrategy(key2).encrypt(cipher, message, key2, cfg);
                  },
                  decrypt: function(ciphertext, key2, cfg) {
                    return selectCipherStrategy(key2).decrypt(cipher, ciphertext, key2, cfg);
                  }
                };
              };
            }()
          });
          C_lib.StreamCipher = Cipher.extend({
            _doFinalize: function() {
              var finalProcessedBlocks = this._process(true);
              return finalProcessedBlocks;
            },
            blockSize: 1
          });
          var C_mode = C.mode = {};
          var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
            /**
             * Creates this mode for encryption.
             *
             * @param {Cipher} cipher A block cipher instance.
             * @param {Array} iv The IV words.
             *
             * @static
             *
             * @example
             *
             *     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
             */
            createEncryptor: function(cipher, iv) {
              return this.Encryptor.create(cipher, iv);
            },
            /**
             * Creates this mode for decryption.
             *
             * @param {Cipher} cipher A block cipher instance.
             * @param {Array} iv The IV words.
             *
             * @static
             *
             * @example
             *
             *     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
             */
            createDecryptor: function(cipher, iv) {
              return this.Decryptor.create(cipher, iv);
            },
            /**
             * Initializes a newly created mode.
             *
             * @param {Cipher} cipher A block cipher instance.
             * @param {Array} iv The IV words.
             *
             * @example
             *
             *     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
             */
            init: function(cipher, iv) {
              this._cipher = cipher;
              this._iv = iv;
            }
          });
          var CBC = C_mode.CBC = function() {
            var CBC2 = BlockCipherMode.extend();
            CBC2.Encryptor = CBC2.extend({
              /**
               * Processes the data block at offset.
               *
               * @param {Array} words The data words to operate on.
               * @param {number} offset The offset where the block starts.
               *
               * @example
               *
               *     mode.processBlock(data.words, offset);
               */
              processBlock: function(words, offset) {
                var cipher = this._cipher;
                var blockSize = cipher.blockSize;
                xorBlock.call(this, words, offset, blockSize);
                cipher.encryptBlock(words, offset);
                this._prevBlock = words.slice(offset, offset + blockSize);
              }
            });
            CBC2.Decryptor = CBC2.extend({
              /**
               * Processes the data block at offset.
               *
               * @param {Array} words The data words to operate on.
               * @param {number} offset The offset where the block starts.
               *
               * @example
               *
               *     mode.processBlock(data.words, offset);
               */
              processBlock: function(words, offset) {
                var cipher = this._cipher;
                var blockSize = cipher.blockSize;
                var thisBlock = words.slice(offset, offset + blockSize);
                cipher.decryptBlock(words, offset);
                xorBlock.call(this, words, offset, blockSize);
                this._prevBlock = thisBlock;
              }
            });
            function xorBlock(words, offset, blockSize) {
              var block;
              var iv = this._iv;
              if (iv) {
                block = iv;
                this._iv = undefined$1;
              } else {
                block = this._prevBlock;
              }
              for (var i2 = 0; i2 < blockSize; i2++) {
                words[offset + i2] ^= block[i2];
              }
            }
            return CBC2;
          }();
          var C_pad = C.pad = {};
          var Pkcs7 = C_pad.Pkcs7 = {
            /**
             * Pads data using the algorithm defined in PKCS #5/7.
             *
             * @param {WordArray} data The data to pad.
             * @param {number} blockSize The multiple that the data should be padded to.
             *
             * @static
             *
             * @example
             *
             *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
             */
            pad: function(data2, blockSize) {
              var blockSizeBytes = blockSize * 4;
              var nPaddingBytes = blockSizeBytes - data2.sigBytes % blockSizeBytes;
              var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
              var paddingWords = [];
              for (var i2 = 0; i2 < nPaddingBytes; i2 += 4) {
                paddingWords.push(paddingWord);
              }
              var padding = WordArray.create(paddingWords, nPaddingBytes);
              data2.concat(padding);
            },
            /**
             * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
             *
             * @param {WordArray} data The data to unpad.
             *
             * @static
             *
             * @example
             *
             *     CryptoJS.pad.Pkcs7.unpad(wordArray);
             */
            unpad: function(data2) {
              var nPaddingBytes = data2.words[data2.sigBytes - 1 >>> 2] & 255;
              data2.sigBytes -= nPaddingBytes;
            }
          };
          C_lib.BlockCipher = Cipher.extend({
            /**
             * Configuration options.
             *
             * @property {Mode} mode The block mode to use. Default: CBC
             * @property {Padding} padding The padding strategy to use. Default: Pkcs7
             */
            cfg: Cipher.cfg.extend({
              mode: CBC,
              padding: Pkcs7
            }),
            reset: function() {
              var modeCreator;
              Cipher.reset.call(this);
              var cfg = this.cfg;
              var iv = cfg.iv;
              var mode = cfg.mode;
              if (this._xformMode == this._ENC_XFORM_MODE) {
                modeCreator = mode.createEncryptor;
              } else {
                modeCreator = mode.createDecryptor;
                this._minBufferSize = 1;
              }
              if (this._mode && this._mode.__creator == modeCreator) {
                this._mode.init(this, iv && iv.words);
              } else {
                this._mode = modeCreator.call(mode, this, iv && iv.words);
                this._mode.__creator = modeCreator;
              }
            },
            _doProcessBlock: function(words, offset) {
              this._mode.processBlock(words, offset);
            },
            _doFinalize: function() {
              var finalProcessedBlocks;
              var padding = this.cfg.padding;
              if (this._xformMode == this._ENC_XFORM_MODE) {
                padding.pad(this._data, this.blockSize);
                finalProcessedBlocks = this._process(true);
              } else {
                finalProcessedBlocks = this._process(true);
                padding.unpad(finalProcessedBlocks);
              }
              return finalProcessedBlocks;
            },
            blockSize: 128 / 32
          });
          var CipherParams = C_lib.CipherParams = Base.extend({
            /**
             * Initializes a newly created cipher params object.
             *
             * @param {Object} cipherParams An object with any of the possible cipher parameters.
             *
             * @example
             *
             *     var cipherParams = CryptoJS.lib.CipherParams.create({
             *         ciphertext: ciphertextWordArray,
             *         key: keyWordArray,
             *         iv: ivWordArray,
             *         salt: saltWordArray,
             *         algorithm: CryptoJS.algo.AES,
             *         mode: CryptoJS.mode.CBC,
             *         padding: CryptoJS.pad.PKCS7,
             *         blockSize: 4,
             *         formatter: CryptoJS.format.OpenSSL
             *     });
             */
            init: function(cipherParams) {
              this.mixIn(cipherParams);
            },
            /**
             * Converts this cipher params object to a string.
             *
             * @param {Format} formatter (Optional) The formatting strategy to use.
             *
             * @return {string} The stringified cipher params.
             *
             * @throws Error If neither the formatter nor the default formatter is set.
             *
             * @example
             *
             *     var string = cipherParams + '';
             *     var string = cipherParams.toString();
             *     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
             */
            toString: function(formatter) {
              return (formatter || this.formatter).stringify(this);
            }
          });
          var C_format = C.format = {};
          var OpenSSLFormatter = C_format.OpenSSL = {
            /**
             * Converts a cipher params object to an OpenSSL-compatible string.
             *
             * @param {CipherParams} cipherParams The cipher params object.
             *
             * @return {string} The OpenSSL-compatible string.
             *
             * @static
             *
             * @example
             *
             *     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
             */
            stringify: function(cipherParams) {
              var wordArray;
              var ciphertext = cipherParams.ciphertext;
              var salt = cipherParams.salt;
              if (salt) {
                wordArray = WordArray.create([1398893684, 1701076831]).concat(salt).concat(ciphertext);
              } else {
                wordArray = ciphertext;
              }
              return wordArray.toString(Base64);
            },
            /**
             * Converts an OpenSSL-compatible string to a cipher params object.
             *
             * @param {string} openSSLStr The OpenSSL-compatible string.
             *
             * @return {CipherParams} The cipher params object.
             *
             * @static
             *
             * @example
             *
             *     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
             */
            parse: function(openSSLStr) {
              var salt;
              var ciphertext = Base64.parse(openSSLStr);
              var ciphertextWords = ciphertext.words;
              if (ciphertextWords[0] == 1398893684 && ciphertextWords[1] == 1701076831) {
                salt = WordArray.create(ciphertextWords.slice(2, 4));
                ciphertextWords.splice(0, 4);
                ciphertext.sigBytes -= 16;
              }
              return CipherParams.create({ ciphertext, salt });
            }
          };
          var SerializableCipher = C_lib.SerializableCipher = Base.extend({
            /**
             * Configuration options.
             *
             * @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
             */
            cfg: Base.extend({
              format: OpenSSLFormatter
            }),
            /**
             * Encrypts a message.
             *
             * @param {Cipher} cipher The cipher algorithm to use.
             * @param {WordArray|string} message The message to encrypt.
             * @param {WordArray} key The key.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {CipherParams} A cipher params object.
             *
             * @static
             *
             * @example
             *
             *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
             *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
             *     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
             */
            encrypt: function(cipher, message, key2, cfg) {
              cfg = this.cfg.extend(cfg);
              var encryptor = cipher.createEncryptor(key2, cfg);
              var ciphertext = encryptor.finalize(message);
              var cipherCfg = encryptor.cfg;
              return CipherParams.create({
                ciphertext,
                key: key2,
                iv: cipherCfg.iv,
                algorithm: cipher,
                mode: cipherCfg.mode,
                padding: cipherCfg.padding,
                blockSize: cipher.blockSize,
                formatter: cfg.format
              });
            },
            /**
             * Decrypts serialized ciphertext.
             *
             * @param {Cipher} cipher The cipher algorithm to use.
             * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
             * @param {WordArray} key The key.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {WordArray} The plaintext.
             *
             * @static
             *
             * @example
             *
             *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
             *     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
             */
            decrypt: function(cipher, ciphertext, key2, cfg) {
              cfg = this.cfg.extend(cfg);
              ciphertext = this._parse(ciphertext, cfg.format);
              var plaintext = cipher.createDecryptor(key2, cfg).finalize(ciphertext.ciphertext);
              return plaintext;
            },
            /**
             * Converts serialized ciphertext to CipherParams,
             * else assumed CipherParams already and returns ciphertext unchanged.
             *
             * @param {CipherParams|string} ciphertext The ciphertext.
             * @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
             *
             * @return {CipherParams} The unserialized ciphertext.
             *
             * @static
             *
             * @example
             *
             *     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
             */
            _parse: function(ciphertext, format2) {
              if (typeof ciphertext == "string") {
                return format2.parse(ciphertext, this);
              } else {
                return ciphertext;
              }
            }
          });
          var C_kdf = C.kdf = {};
          var OpenSSLKdf = C_kdf.OpenSSL = {
            /**
             * Derives a key and IV from a password.
             *
             * @param {string} password The password to derive from.
             * @param {number} keySize The size in words of the key to generate.
             * @param {number} ivSize The size in words of the IV to generate.
             * @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
             *
             * @return {CipherParams} A cipher params object with the key, IV, and salt.
             *
             * @static
             *
             * @example
             *
             *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
             *     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
             */
            execute: function(password, keySize, ivSize, salt, hasher) {
              if (!salt) {
                salt = WordArray.random(64 / 8);
              }
              if (!hasher) {
                var key2 = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
              } else {
                var key2 = EvpKDF.create({ keySize: keySize + ivSize, hasher }).compute(password, salt);
              }
              var iv = WordArray.create(key2.words.slice(keySize), ivSize * 4);
              key2.sigBytes = keySize * 4;
              return CipherParams.create({ key: key2, iv, salt });
            }
          };
          var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
            /**
             * Configuration options.
             *
             * @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
             */
            cfg: SerializableCipher.cfg.extend({
              kdf: OpenSSLKdf
            }),
            /**
             * Encrypts a message using a password.
             *
             * @param {Cipher} cipher The cipher algorithm to use.
             * @param {WordArray|string} message The message to encrypt.
             * @param {string} password The password.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {CipherParams} A cipher params object.
             *
             * @static
             *
             * @example
             *
             *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
             *     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
             */
            encrypt: function(cipher, message, password, cfg) {
              cfg = this.cfg.extend(cfg);
              var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher);
              cfg.iv = derivedParams.iv;
              var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
              ciphertext.mixIn(derivedParams);
              return ciphertext;
            },
            /**
             * Decrypts serialized ciphertext using a password.
             *
             * @param {Cipher} cipher The cipher algorithm to use.
             * @param {CipherParams|string} ciphertext The ciphertext to decrypt.
             * @param {string} password The password.
             * @param {Object} cfg (Optional) The configuration options to use for this operation.
             *
             * @return {WordArray} The plaintext.
             *
             * @static
             *
             * @example
             *
             *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
             *     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
             */
            decrypt: function(cipher, ciphertext, password, cfg) {
              cfg = this.cfg.extend(cfg);
              ciphertext = this._parse(ciphertext, cfg.format);
              var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher);
              cfg.iv = derivedParams.iv;
              var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
              return plaintext;
            }
          });
        }();
      });
    })(cipherCore);
    return cipherCore.exports;
  }
  var modeCfb = { exports: {} };
  var hasRequiredModeCfb;
  function requireModeCfb() {
    if (hasRequiredModeCfb)
      return modeCfb.exports;
    hasRequiredModeCfb = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.mode.CFB = function() {
          var CFB = CryptoJS2.lib.BlockCipherMode.extend();
          CFB.Encryptor = CFB.extend({
            processBlock: function(words, offset) {
              var cipher = this._cipher;
              var blockSize = cipher.blockSize;
              generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
              this._prevBlock = words.slice(offset, offset + blockSize);
            }
          });
          CFB.Decryptor = CFB.extend({
            processBlock: function(words, offset) {
              var cipher = this._cipher;
              var blockSize = cipher.blockSize;
              var thisBlock = words.slice(offset, offset + blockSize);
              generateKeystreamAndEncrypt.call(this, words, offset, blockSize, cipher);
              this._prevBlock = thisBlock;
            }
          });
          function generateKeystreamAndEncrypt(words, offset, blockSize, cipher) {
            var keystream;
            var iv = this._iv;
            if (iv) {
              keystream = iv.slice(0);
              this._iv = void 0;
            } else {
              keystream = this._prevBlock;
            }
            cipher.encryptBlock(keystream, 0);
            for (var i2 = 0; i2 < blockSize; i2++) {
              words[offset + i2] ^= keystream[i2];
            }
          }
          return CFB;
        }();
        return CryptoJS2.mode.CFB;
      });
    })(modeCfb);
    return modeCfb.exports;
  }
  var modeCtr = { exports: {} };
  var hasRequiredModeCtr;
  function requireModeCtr() {
    if (hasRequiredModeCtr)
      return modeCtr.exports;
    hasRequiredModeCtr = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.mode.CTR = function() {
          var CTR = CryptoJS2.lib.BlockCipherMode.extend();
          var Encryptor = CTR.Encryptor = CTR.extend({
            processBlock: function(words, offset) {
              var cipher = this._cipher;
              var blockSize = cipher.blockSize;
              var iv = this._iv;
              var counter = this._counter;
              if (iv) {
                counter = this._counter = iv.slice(0);
                this._iv = void 0;
              }
              var keystream = counter.slice(0);
              cipher.encryptBlock(keystream, 0);
              counter[blockSize - 1] = counter[blockSize - 1] + 1 | 0;
              for (var i2 = 0; i2 < blockSize; i2++) {
                words[offset + i2] ^= keystream[i2];
              }
            }
          });
          CTR.Decryptor = Encryptor;
          return CTR;
        }();
        return CryptoJS2.mode.CTR;
      });
    })(modeCtr);
    return modeCtr.exports;
  }
  var modeCtrGladman = { exports: {} };
  var hasRequiredModeCtrGladman;
  function requireModeCtrGladman() {
    if (hasRequiredModeCtrGladman)
      return modeCtrGladman.exports;
    hasRequiredModeCtrGladman = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        /** @preserve
         * Counter block mode compatible with  Dr Brian Gladman fileenc.c
         * derived from CryptoJS.mode.CTR
         * Jan Hruby [email protected]
         */
        CryptoJS2.mode.CTRGladman = function() {
          var CTRGladman = CryptoJS2.lib.BlockCipherMode.extend();
          function incWord(word) {
            if ((word >> 24 & 255) === 255) {
              var b1 = word >> 16 & 255;
              var b2 = word >> 8 & 255;
              var b3 = word & 255;
              if (b1 === 255) {
                b1 = 0;
                if (b2 === 255) {
                  b2 = 0;
                  if (b3 === 255) {
                    b3 = 0;
                  } else {
                    ++b3;
                  }
                } else {
                  ++b2;
                }
              } else {
                ++b1;
              }
              word = 0;
              word += b1 << 16;
              word += b2 << 8;
              word += b3;
            } else {
              word += 1 << 24;
            }
            return word;
          }
          function incCounter(counter) {
            if ((counter[0] = incWord(counter[0])) === 0) {
              counter[1] = incWord(counter[1]);
            }
            return counter;
          }
          var Encryptor = CTRGladman.Encryptor = CTRGladman.extend({
            processBlock: function(words, offset) {
              var cipher = this._cipher;
              var blockSize = cipher.blockSize;
              var iv = this._iv;
              var counter = this._counter;
              if (iv) {
                counter = this._counter = iv.slice(0);
                this._iv = void 0;
              }
              incCounter(counter);
              var keystream = counter.slice(0);
              cipher.encryptBlock(keystream, 0);
              for (var i2 = 0; i2 < blockSize; i2++) {
                words[offset + i2] ^= keystream[i2];
              }
            }
          });
          CTRGladman.Decryptor = Encryptor;
          return CTRGladman;
        }();
        return CryptoJS2.mode.CTRGladman;
      });
    })(modeCtrGladman);
    return modeCtrGladman.exports;
  }
  var modeOfb = { exports: {} };
  var hasRequiredModeOfb;
  function requireModeOfb() {
    if (hasRequiredModeOfb)
      return modeOfb.exports;
    hasRequiredModeOfb = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.mode.OFB = function() {
          var OFB = CryptoJS2.lib.BlockCipherMode.extend();
          var Encryptor = OFB.Encryptor = OFB.extend({
            processBlock: function(words, offset) {
              var cipher = this._cipher;
              var blockSize = cipher.blockSize;
              var iv = this._iv;
              var keystream = this._keystream;
              if (iv) {
                keystream = this._keystream = iv.slice(0);
                this._iv = void 0;
              }
              cipher.encryptBlock(keystream, 0);
              for (var i2 = 0; i2 < blockSize; i2++) {
                words[offset + i2] ^= keystream[i2];
              }
            }
          });
          OFB.Decryptor = Encryptor;
          return OFB;
        }();
        return CryptoJS2.mode.OFB;
      });
    })(modeOfb);
    return modeOfb.exports;
  }
  var modeEcb = { exports: {} };
  var hasRequiredModeEcb;
  function requireModeEcb() {
    if (hasRequiredModeEcb)
      return modeEcb.exports;
    hasRequiredModeEcb = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.mode.ECB = function() {
          var ECB = CryptoJS2.lib.BlockCipherMode.extend();
          ECB.Encryptor = ECB.extend({
            processBlock: function(words, offset) {
              this._cipher.encryptBlock(words, offset);
            }
          });
          ECB.Decryptor = ECB.extend({
            processBlock: function(words, offset) {
              this._cipher.decryptBlock(words, offset);
            }
          });
          return ECB;
        }();
        return CryptoJS2.mode.ECB;
      });
    })(modeEcb);
    return modeEcb.exports;
  }
  var padAnsix923 = { exports: {} };
  var hasRequiredPadAnsix923;
  function requirePadAnsix923() {
    if (hasRequiredPadAnsix923)
      return padAnsix923.exports;
    hasRequiredPadAnsix923 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.pad.AnsiX923 = {
          pad: function(data2, blockSize) {
            var dataSigBytes = data2.sigBytes;
            var blockSizeBytes = blockSize * 4;
            var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
            var lastBytePos = dataSigBytes + nPaddingBytes - 1;
            data2.clamp();
            data2.words[lastBytePos >>> 2] |= nPaddingBytes << 24 - lastBytePos % 4 * 8;
            data2.sigBytes += nPaddingBytes;
          },
          unpad: function(data2) {
            var nPaddingBytes = data2.words[data2.sigBytes - 1 >>> 2] & 255;
            data2.sigBytes -= nPaddingBytes;
          }
        };
        return CryptoJS2.pad.Ansix923;
      });
    })(padAnsix923);
    return padAnsix923.exports;
  }
  var padIso10126 = { exports: {} };
  var hasRequiredPadIso10126;
  function requirePadIso10126() {
    if (hasRequiredPadIso10126)
      return padIso10126.exports;
    hasRequiredPadIso10126 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.pad.Iso10126 = {
          pad: function(data2, blockSize) {
            var blockSizeBytes = blockSize * 4;
            var nPaddingBytes = blockSizeBytes - data2.sigBytes % blockSizeBytes;
            data2.concat(CryptoJS2.lib.WordArray.random(nPaddingBytes - 1)).concat(CryptoJS2.lib.WordArray.create([nPaddingBytes << 24], 1));
          },
          unpad: function(data2) {
            var nPaddingBytes = data2.words[data2.sigBytes - 1 >>> 2] & 255;
            data2.sigBytes -= nPaddingBytes;
          }
        };
        return CryptoJS2.pad.Iso10126;
      });
    })(padIso10126);
    return padIso10126.exports;
  }
  var padIso97971 = { exports: {} };
  var hasRequiredPadIso97971;
  function requirePadIso97971() {
    if (hasRequiredPadIso97971)
      return padIso97971.exports;
    hasRequiredPadIso97971 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.pad.Iso97971 = {
          pad: function(data2, blockSize) {
            data2.concat(CryptoJS2.lib.WordArray.create([2147483648], 1));
            CryptoJS2.pad.ZeroPadding.pad(data2, blockSize);
          },
          unpad: function(data2) {
            CryptoJS2.pad.ZeroPadding.unpad(data2);
            data2.sigBytes--;
          }
        };
        return CryptoJS2.pad.Iso97971;
      });
    })(padIso97971);
    return padIso97971.exports;
  }
  var padZeropadding = { exports: {} };
  var hasRequiredPadZeropadding;
  function requirePadZeropadding() {
    if (hasRequiredPadZeropadding)
      return padZeropadding.exports;
    hasRequiredPadZeropadding = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.pad.ZeroPadding = {
          pad: function(data2, blockSize) {
            var blockSizeBytes = blockSize * 4;
            data2.clamp();
            data2.sigBytes += blockSizeBytes - (data2.sigBytes % blockSizeBytes || blockSizeBytes);
          },
          unpad: function(data2) {
            var dataWords = data2.words;
            var i2 = data2.sigBytes - 1;
            for (var i2 = data2.sigBytes - 1; i2 >= 0; i2--) {
              if (dataWords[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255) {
                data2.sigBytes = i2 + 1;
                break;
              }
            }
          }
        };
        return CryptoJS2.pad.ZeroPadding;
      });
    })(padZeropadding);
    return padZeropadding.exports;
  }
  var padNopadding = { exports: {} };
  var hasRequiredPadNopadding;
  function requirePadNopadding() {
    if (hasRequiredPadNopadding)
      return padNopadding.exports;
    hasRequiredPadNopadding = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        CryptoJS2.pad.NoPadding = {
          pad: function() {
          },
          unpad: function() {
          }
        };
        return CryptoJS2.pad.NoPadding;
      });
    })(padNopadding);
    return padNopadding.exports;
  }
  var formatHex = { exports: {} };
  var hasRequiredFormatHex;
  function requireFormatHex() {
    if (hasRequiredFormatHex)
      return formatHex.exports;
    hasRequiredFormatHex = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function(undefined$1) {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var CipherParams = C_lib.CipherParams;
          var C_enc = C.enc;
          var Hex = C_enc.Hex;
          var C_format = C.format;
          C_format.Hex = {
            /**
             * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
             *
             * @param {CipherParams} cipherParams The cipher params object.
             *
             * @return {string} The hexadecimally encoded string.
             *
             * @static
             *
             * @example
             *
             *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
             */
            stringify: function(cipherParams) {
              return cipherParams.ciphertext.toString(Hex);
            },
            /**
             * Converts a hexadecimally encoded ciphertext string to a cipher params object.
             *
             * @param {string} input The hexadecimally encoded string.
             *
             * @return {CipherParams} The cipher params object.
             *
             * @static
             *
             * @example
             *
             *     var cipherParams = CryptoJS.format.Hex.parse(hexString);
             */
            parse: function(input) {
              var ciphertext = Hex.parse(input);
              return CipherParams.create({ ciphertext });
            }
          };
        })();
        return CryptoJS2.format.Hex;
      });
    })(formatHex);
    return formatHex.exports;
  }
  var aes = { exports: {} };
  var hasRequiredAes;
  function requireAes() {
    if (hasRequiredAes)
      return aes.exports;
    hasRequiredAes = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var BlockCipher = C_lib.BlockCipher;
          var C_algo = C.algo;
          var SBOX = [];
          var INV_SBOX = [];
          var SUB_MIX_0 = [];
          var SUB_MIX_1 = [];
          var SUB_MIX_2 = [];
          var SUB_MIX_3 = [];
          var INV_SUB_MIX_0 = [];
          var INV_SUB_MIX_1 = [];
          var INV_SUB_MIX_2 = [];
          var INV_SUB_MIX_3 = [];
          (function() {
            var d2 = [];
            for (var i2 = 0; i2 < 256; i2++) {
              if (i2 < 128) {
                d2[i2] = i2 << 1;
              } else {
                d2[i2] = i2 << 1 ^ 283;
              }
            }
            var x = 0;
            var xi = 0;
            for (var i2 = 0; i2 < 256; i2++) {
              var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
              sx = sx >>> 8 ^ sx & 255 ^ 99;
              SBOX[x] = sx;
              INV_SBOX[sx] = x;
              var x2 = d2[x];
              var x4 = d2[x2];
              var x8 = d2[x4];
              var t = d2[sx] * 257 ^ sx * 16843008;
              SUB_MIX_0[x] = t << 24 | t >>> 8;
              SUB_MIX_1[x] = t << 16 | t >>> 16;
              SUB_MIX_2[x] = t << 8 | t >>> 24;
              SUB_MIX_3[x] = t;
              var t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
              INV_SUB_MIX_0[sx] = t << 24 | t >>> 8;
              INV_SUB_MIX_1[sx] = t << 16 | t >>> 16;
              INV_SUB_MIX_2[sx] = t << 8 | t >>> 24;
              INV_SUB_MIX_3[sx] = t;
              if (!x) {
                x = xi = 1;
              } else {
                x = x2 ^ d2[d2[d2[x8 ^ x2]]];
                xi ^= d2[d2[xi]];
              }
            }
          })();
          var RCON = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54];
          var AES = C_algo.AES = BlockCipher.extend({
            _doReset: function() {
              var t;
              if (this._nRounds && this._keyPriorReset === this._key) {
                return;
              }
              var key2 = this._keyPriorReset = this._key;
              var keyWords = key2.words;
              var keySize = key2.sigBytes / 4;
              var nRounds = this._nRounds = keySize + 6;
              var ksRows = (nRounds + 1) * 4;
              var keySchedule = this._keySchedule = [];
              for (var ksRow = 0; ksRow < ksRows; ksRow++) {
                if (ksRow < keySize) {
                  keySchedule[ksRow] = keyWords[ksRow];
                } else {
                  t = keySchedule[ksRow - 1];
                  if (!(ksRow % keySize)) {
                    t = t << 8 | t >>> 24;
                    t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
                    t ^= RCON[ksRow / keySize | 0] << 24;
                  } else if (keySize > 6 && ksRow % keySize == 4) {
                    t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
                  }
                  keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
                }
              }
              var invKeySchedule = this._invKeySchedule = [];
              for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
                var ksRow = ksRows - invKsRow;
                if (invKsRow % 4) {
                  var t = keySchedule[ksRow];
                } else {
                  var t = keySchedule[ksRow - 4];
                }
                if (invKsRow < 4 || ksRow <= 4) {
                  invKeySchedule[invKsRow] = t;
                } else {
                  invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t & 255]];
                }
              }
            },
            encryptBlock: function(M, offset) {
              this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
            },
            decryptBlock: function(M, offset) {
              var t = M[offset + 1];
              M[offset + 1] = M[offset + 3];
              M[offset + 3] = t;
              this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
              var t = M[offset + 1];
              M[offset + 1] = M[offset + 3];
              M[offset + 3] = t;
            },
            _doCryptBlock: function(M, offset, keySchedule, SUB_MIX_02, SUB_MIX_12, SUB_MIX_22, SUB_MIX_32, SBOX2) {
              var nRounds = this._nRounds;
              var s0 = M[offset] ^ keySchedule[0];
              var s1 = M[offset + 1] ^ keySchedule[1];
              var s2 = M[offset + 2] ^ keySchedule[2];
              var s3 = M[offset + 3] ^ keySchedule[3];
              var ksRow = 4;
              for (var round = 1; round < nRounds; round++) {
                var t0 = SUB_MIX_02[s0 >>> 24] ^ SUB_MIX_12[s1 >>> 16 & 255] ^ SUB_MIX_22[s2 >>> 8 & 255] ^ SUB_MIX_32[s3 & 255] ^ keySchedule[ksRow++];
                var t1 = SUB_MIX_02[s1 >>> 24] ^ SUB_MIX_12[s2 >>> 16 & 255] ^ SUB_MIX_22[s3 >>> 8 & 255] ^ SUB_MIX_32[s0 & 255] ^ keySchedule[ksRow++];
                var t2 = SUB_MIX_02[s2 >>> 24] ^ SUB_MIX_12[s3 >>> 16 & 255] ^ SUB_MIX_22[s0 >>> 8 & 255] ^ SUB_MIX_32[s1 & 255] ^ keySchedule[ksRow++];
                var t3 = SUB_MIX_02[s3 >>> 24] ^ SUB_MIX_12[s0 >>> 16 & 255] ^ SUB_MIX_22[s1 >>> 8 & 255] ^ SUB_MIX_32[s2 & 255] ^ keySchedule[ksRow++];
                s0 = t0;
                s1 = t1;
                s2 = t2;
                s3 = t3;
              }
              var t0 = (SBOX2[s0 >>> 24] << 24 | SBOX2[s1 >>> 16 & 255] << 16 | SBOX2[s2 >>> 8 & 255] << 8 | SBOX2[s3 & 255]) ^ keySchedule[ksRow++];
              var t1 = (SBOX2[s1 >>> 24] << 24 | SBOX2[s2 >>> 16 & 255] << 16 | SBOX2[s3 >>> 8 & 255] << 8 | SBOX2[s0 & 255]) ^ keySchedule[ksRow++];
              var t2 = (SBOX2[s2 >>> 24] << 24 | SBOX2[s3 >>> 16 & 255] << 16 | SBOX2[s0 >>> 8 & 255] << 8 | SBOX2[s1 & 255]) ^ keySchedule[ksRow++];
              var t3 = (SBOX2[s3 >>> 24] << 24 | SBOX2[s0 >>> 16 & 255] << 16 | SBOX2[s1 >>> 8 & 255] << 8 | SBOX2[s2 & 255]) ^ keySchedule[ksRow++];
              M[offset] = t0;
              M[offset + 1] = t1;
              M[offset + 2] = t2;
              M[offset + 3] = t3;
            },
            keySize: 256 / 32
          });
          C.AES = BlockCipher._createHelper(AES);
        })();
        return CryptoJS2.AES;
      });
    })(aes);
    return aes.exports;
  }
  var tripledes = { exports: {} };
  var hasRequiredTripledes;
  function requireTripledes() {
    if (hasRequiredTripledes)
      return tripledes.exports;
    hasRequiredTripledes = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var BlockCipher = C_lib.BlockCipher;
          var C_algo = C.algo;
          var PC1 = [
            57,
            49,
            41,
            33,
            25,
            17,
            9,
            1,
            58,
            50,
            42,
            34,
            26,
            18,
            10,
            2,
            59,
            51,
            43,
            35,
            27,
            19,
            11,
            3,
            60,
            52,
            44,
            36,
            63,
            55,
            47,
            39,
            31,
            23,
            15,
            7,
            62,
            54,
            46,
            38,
            30,
            22,
            14,
            6,
            61,
            53,
            45,
            37,
            29,
            21,
            13,
            5,
            28,
            20,
            12,
            4
          ];
          var PC2 = [
            14,
            17,
            11,
            24,
            1,
            5,
            3,
            28,
            15,
            6,
            21,
            10,
            23,
            19,
            12,
            4,
            26,
            8,
            16,
            7,
            27,
            20,
            13,
            2,
            41,
            52,
            31,
            37,
            47,
            55,
            30,
            40,
            51,
            45,
            33,
            48,
            44,
            49,
            39,
            56,
            34,
            53,
            46,
            42,
            50,
            36,
            29,
            32
          ];
          var BIT_SHIFTS = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
          var SBOX_P = [
            {
              0: 8421888,
              268435456: 32768,
              536870912: 8421378,
              805306368: 2,
              1073741824: 512,
              1342177280: 8421890,
              1610612736: 8389122,
              1879048192: 8388608,
              2147483648: 514,
              2415919104: 8389120,
              2684354560: 33280,
              2952790016: 8421376,
              3221225472: 32770,
              3489660928: 8388610,
              3758096384: 0,
              4026531840: 33282,
              134217728: 0,
              402653184: 8421890,
              671088640: 33282,
              939524096: 32768,
              1207959552: 8421888,
              1476395008: 512,
              1744830464: 8421378,
              2013265920: 2,
              2281701376: 8389120,
              2550136832: 33280,
              2818572288: 8421376,
              3087007744: 8389122,
              3355443200: 8388610,
              3623878656: 32770,
              3892314112: 514,
              4160749568: 8388608,
              1: 32768,
              268435457: 2,
              536870913: 8421888,
              805306369: 8388608,
              1073741825: 8421378,
              1342177281: 33280,
              1610612737: 512,
              1879048193: 8389122,
              2147483649: 8421890,
              2415919105: 8421376,
              2684354561: 8388610,
              2952790017: 33282,
              3221225473: 514,
              3489660929: 8389120,
              3758096385: 32770,
              4026531841: 0,
              134217729: 8421890,
              402653185: 8421376,
              671088641: 8388608,
              939524097: 512,
              1207959553: 32768,
              1476395009: 8388610,
              1744830465: 2,
              2013265921: 33282,
              2281701377: 32770,
              2550136833: 8389122,
              2818572289: 514,
              3087007745: 8421888,
              3355443201: 8389120,
              3623878657: 0,
              3892314113: 33280,
              4160749569: 8421378
            },
            {
              0: 1074282512,
              16777216: 16384,
              33554432: 524288,
              50331648: 1074266128,
              67108864: 1073741840,
              83886080: 1074282496,
              100663296: 1073758208,
              117440512: 16,
              134217728: 540672,
              150994944: 1073758224,
              167772160: 1073741824,
              184549376: 540688,
              201326592: 524304,
              218103808: 0,
              234881024: 16400,
              251658240: 1074266112,
              8388608: 1073758208,
              25165824: 540688,
              41943040: 16,
              58720256: 1073758224,
              75497472: 1074282512,
              92274688: 1073741824,
              109051904: 524288,
              125829120: 1074266128,
              142606336: 524304,
              159383552: 0,
              176160768: 16384,
              192937984: 1074266112,
              209715200: 1073741840,
              226492416: 540672,
              243269632: 1074282496,
              260046848: 16400,
              268435456: 0,
              285212672: 1074266128,
              301989888: 1073758224,
              318767104: 1074282496,
              335544320: 1074266112,
              352321536: 16,
              369098752: 540688,
              385875968: 16384,
              402653184: 16400,
              419430400: 524288,
              436207616: 524304,
              452984832: 1073741840,
              469762048: 540672,
              486539264: 1073758208,
              503316480: 1073741824,
              520093696: 1074282512,
              276824064: 540688,
              293601280: 524288,
              310378496: 1074266112,
              327155712: 16384,
              343932928: 1073758208,
              360710144: 1074282512,
              377487360: 16,
              394264576: 1073741824,
              411041792: 1074282496,
              427819008: 1073741840,
              444596224: 1073758224,
              461373440: 524304,
              478150656: 0,
              494927872: 16400,
              511705088: 1074266128,
              528482304: 540672
            },
            {
              0: 260,
              1048576: 0,
              2097152: 67109120,
              3145728: 65796,
              4194304: 65540,
              5242880: 67108868,
              6291456: 67174660,
              7340032: 67174400,
              8388608: 67108864,
              9437184: 67174656,
              10485760: 65792,
              11534336: 67174404,
              12582912: 67109124,
              13631488: 65536,
              14680064: 4,
              15728640: 256,
              524288: 67174656,
              1572864: 67174404,
              2621440: 0,
              3670016: 67109120,
              4718592: 67108868,
              5767168: 65536,
              6815744: 65540,
              7864320: 260,
              8912896: 4,
              9961472: 256,
              11010048: 67174400,
              12058624: 65796,
              13107200: 65792,
              14155776: 67109124,
              15204352: 67174660,
              16252928: 67108864,
              16777216: 67174656,
              17825792: 65540,
              18874368: 65536,
              19922944: 67109120,
              20971520: 256,
              22020096: 67174660,
              23068672: 67108868,
              24117248: 0,
              25165824: 67109124,
              26214400: 67108864,
              27262976: 4,
              28311552: 65792,
              29360128: 67174400,
              30408704: 260,
              31457280: 65796,
              32505856: 67174404,
              17301504: 67108864,
              18350080: 260,
              19398656: 67174656,
              20447232: 0,
              21495808: 65540,
              22544384: 67109120,
              23592960: 256,
              24641536: 67174404,
              25690112: 65536,
              26738688: 67174660,
              27787264: 65796,
              28835840: 67108868,
              29884416: 67109124,
              30932992: 67174400,
              31981568: 4,
              33030144: 65792
            },
            {
              0: 2151682048,
              65536: 2147487808,
              131072: 4198464,
              196608: 2151677952,
              262144: 0,
              327680: 4198400,
              393216: 2147483712,
              458752: 4194368,
              524288: 2147483648,
              589824: 4194304,
              655360: 64,
              720896: 2147487744,
              786432: 2151678016,
              851968: 4160,
              917504: 4096,
              983040: 2151682112,
              32768: 2147487808,
              98304: 64,
              163840: 2151678016,
              229376: 2147487744,
              294912: 4198400,
              360448: 2151682112,
              425984: 0,
              491520: 2151677952,
              557056: 4096,
              622592: 2151682048,
              688128: 4194304,
              753664: 4160,
              819200: 2147483648,
              884736: 4194368,
              950272: 4198464,
              1015808: 2147483712,
              1048576: 4194368,
              1114112: 4198400,
              1179648: 2147483712,
              1245184: 0,
              1310720: 4160,
              1376256: 2151678016,
              1441792: 2151682048,
              1507328: 2147487808,
              1572864: 2151682112,
              1638400: 2147483648,
              1703936: 2151677952,
              1769472: 4198464,
              1835008: 2147487744,
              1900544: 4194304,
              1966080: 64,
              2031616: 4096,
              1081344: 2151677952,
              1146880: 2151682112,
              1212416: 0,
              1277952: 4198400,
              1343488: 4194368,
              1409024: 2147483648,
              1474560: 2147487808,
              1540096: 64,
              1605632: 2147483712,
              1671168: 4096,
              1736704: 2147487744,
              1802240: 2151678016,
              1867776: 4160,
              1933312: 2151682048,
              1998848: 4194304,
              2064384: 4198464
            },
            {
              0: 128,
              4096: 17039360,
              8192: 262144,
              12288: 536870912,
              16384: 537133184,
              20480: 16777344,
              24576: 553648256,
              28672: 262272,
              32768: 16777216,
              36864: 537133056,
              40960: 536871040,
              45056: 553910400,
              49152: 553910272,
              53248: 0,
              57344: 17039488,
              61440: 553648128,
              2048: 17039488,
              6144: 553648256,
              10240: 128,
              14336: 17039360,
              18432: 262144,
              22528: 537133184,
              26624: 553910272,
              30720: 536870912,
              34816: 537133056,
              38912: 0,
              43008: 553910400,
              47104: 16777344,
              51200: 536871040,
              55296: 553648128,
              59392: 16777216,
              63488: 262272,
              65536: 262144,
              69632: 128,
              73728: 536870912,
              77824: 553648256,
              81920: 16777344,
              86016: 553910272,
              90112: 537133184,
              94208: 16777216,
              98304: 553910400,
              102400: 553648128,
              106496: 17039360,
              110592: 537133056,
              114688: 262272,
              118784: 536871040,
              122880: 0,
              126976: 17039488,
              67584: 553648256,
              71680: 16777216,
              75776: 17039360,
              79872: 537133184,
              83968: 536870912,
              88064: 17039488,
              92160: 128,
              96256: 553910272,
              100352: 262272,
              104448: 553910400,
              108544: 0,
              112640: 553648128,
              116736: 16777344,
              120832: 262144,
              124928: 537133056,
              129024: 536871040
            },
            {
              0: 268435464,
              256: 8192,
              512: 270532608,
              768: 270540808,
              1024: 268443648,
              1280: 2097152,
              1536: 2097160,
              1792: 268435456,
              2048: 0,
              2304: 268443656,
              2560: 2105344,
              2816: 8,
              3072: 270532616,
              3328: 2105352,
              3584: 8200,
              3840: 270540800,
              128: 270532608,
              384: 270540808,
              640: 8,
              896: 2097152,
              1152: 2105352,
              1408: 268435464,
              1664: 268443648,
              1920: 8200,
              2176: 2097160,
              2432: 8192,
              2688: 268443656,
              2944: 270532616,
              3200: 0,
              3456: 270540800,
              3712: 2105344,
              3968: 268435456,
              4096: 268443648,
              4352: 270532616,
              4608: 270540808,
              4864: 8200,
              5120: 2097152,
              5376: 268435456,
              5632: 268435464,
              5888: 2105344,
              6144: 2105352,
              6400: 0,
              6656: 8,
              6912: 270532608,
              7168: 8192,
              7424: 268443656,
              7680: 270540800,
              7936: 2097160,
              4224: 8,
              4480: 2105344,
              4736: 2097152,
              4992: 268435464,
              5248: 268443648,
              5504: 8200,
              5760: 270540808,
              6016: 270532608,
              6272: 270540800,
              6528: 270532616,
              6784: 8192,
              7040: 2105352,
              7296: 2097160,
              7552: 0,
              7808: 268435456,
              8064: 268443656
            },
            {
              0: 1048576,
              16: 33555457,
              32: 1024,
              48: 1049601,
              64: 34604033,
              80: 0,
              96: 1,
              112: 34603009,
              128: 33555456,
              144: 1048577,
              160: 33554433,
              176: 34604032,
              192: 34603008,
              208: 1025,
              224: 1049600,
              240: 33554432,
              8: 34603009,
              24: 0,
              40: 33555457,
              56: 34604032,
              72: 1048576,
              88: 33554433,
              104: 33554432,
              120: 1025,
              136: 1049601,
              152: 33555456,
              168: 34603008,
              184: 1048577,
              200: 1024,
              216: 34604033,
              232: 1,
              248: 1049600,
              256: 33554432,
              272: 1048576,
              288: 33555457,
              304: 34603009,
              320: 1048577,
              336: 33555456,
              352: 34604032,
              368: 1049601,
              384: 1025,
              400: 34604033,
              416: 1049600,
              432: 1,
              448: 0,
              464: 34603008,
              480: 33554433,
              496: 1024,
              264: 1049600,
              280: 33555457,
              296: 34603009,
              312: 1,
              328: 33554432,
              344: 1048576,
              360: 1025,
              376: 34604032,
              392: 33554433,
              408: 34603008,
              424: 0,
              440: 34604033,
              456: 1049601,
              472: 1024,
              488: 33555456,
              504: 1048577
            },
            {
              0: 134219808,
              1: 131072,
              2: 134217728,
              3: 32,
              4: 131104,
              5: 134350880,
              6: 134350848,
              7: 2048,
              8: 134348800,
              9: 134219776,
              10: 133120,
              11: 134348832,
              12: 2080,
              13: 0,
              14: 134217760,
              15: 133152,
              2147483648: 2048,
              2147483649: 134350880,
              2147483650: 134219808,
              2147483651: 134217728,
              2147483652: 134348800,
              2147483653: 133120,
              2147483654: 133152,
              2147483655: 32,
              2147483656: 134217760,
              2147483657: 2080,
              2147483658: 131104,
              2147483659: 134350848,
              2147483660: 0,
              2147483661: 134348832,
              2147483662: 134219776,
              2147483663: 131072,
              16: 133152,
              17: 134350848,
              18: 32,
              19: 2048,
              20: 134219776,
              21: 134217760,
              22: 134348832,
              23: 131072,
              24: 0,
              25: 131104,
              26: 134348800,
              27: 134219808,
              28: 134350880,
              29: 133120,
              30: 2080,
              31: 134217728,
              2147483664: 131072,
              2147483665: 2048,
              2147483666: 134348832,
              2147483667: 133152,
              2147483668: 32,
              2147483669: 134348800,
              2147483670: 134217728,
              2147483671: 134219808,
              2147483672: 134350880,
              2147483673: 134217760,
              2147483674: 134219776,
              2147483675: 0,
              2147483676: 133120,
              2147483677: 2080,
              2147483678: 131104,
              2147483679: 134350848
            }
          ];
          var SBOX_MASK = [
            4160749569,
            528482304,
            33030144,
            2064384,
            129024,
            8064,
            504,
            2147483679
          ];
          var DES = C_algo.DES = BlockCipher.extend({
            _doReset: function() {
              var key2 = this._key;
              var keyWords = key2.words;
              var keyBits = [];
              for (var i2 = 0; i2 < 56; i2++) {
                var keyBitPos = PC1[i2] - 1;
                keyBits[i2] = keyWords[keyBitPos >>> 5] >>> 31 - keyBitPos % 32 & 1;
              }
              var subKeys = this._subKeys = [];
              for (var nSubKey = 0; nSubKey < 16; nSubKey++) {
                var subKey = subKeys[nSubKey] = [];
                var bitShift = BIT_SHIFTS[nSubKey];
                for (var i2 = 0; i2 < 24; i2++) {
                  subKey[i2 / 6 | 0] |= keyBits[(PC2[i2] - 1 + bitShift) % 28] << 31 - i2 % 6;
                  subKey[4 + (i2 / 6 | 0)] |= keyBits[28 + (PC2[i2 + 24] - 1 + bitShift) % 28] << 31 - i2 % 6;
                }
                subKey[0] = subKey[0] << 1 | subKey[0] >>> 31;
                for (var i2 = 1; i2 < 7; i2++) {
                  subKey[i2] = subKey[i2] >>> (i2 - 1) * 4 + 3;
                }
                subKey[7] = subKey[7] << 5 | subKey[7] >>> 27;
              }
              var invSubKeys = this._invSubKeys = [];
              for (var i2 = 0; i2 < 16; i2++) {
                invSubKeys[i2] = subKeys[15 - i2];
              }
            },
            encryptBlock: function(M, offset) {
              this._doCryptBlock(M, offset, this._subKeys);
            },
            decryptBlock: function(M, offset) {
              this._doCryptBlock(M, offset, this._invSubKeys);
            },
            _doCryptBlock: function(M, offset, subKeys) {
              this._lBlock = M[offset];
              this._rBlock = M[offset + 1];
              exchangeLR.call(this, 4, 252645135);
              exchangeLR.call(this, 16, 65535);
              exchangeRL.call(this, 2, 858993459);
              exchangeRL.call(this, 8, 16711935);
              exchangeLR.call(this, 1, 1431655765);
              for (var round = 0; round < 16; round++) {
                var subKey = subKeys[round];
                var lBlock = this._lBlock;
                var rBlock = this._rBlock;
                var f = 0;
                for (var i2 = 0; i2 < 8; i2++) {
                  f |= SBOX_P[i2][((rBlock ^ subKey[i2]) & SBOX_MASK[i2]) >>> 0];
                }
                this._lBlock = rBlock;
                this._rBlock = lBlock ^ f;
              }
              var t = this._lBlock;
              this._lBlock = this._rBlock;
              this._rBlock = t;
              exchangeLR.call(this, 1, 1431655765);
              exchangeRL.call(this, 8, 16711935);
              exchangeRL.call(this, 2, 858993459);
              exchangeLR.call(this, 16, 65535);
              exchangeLR.call(this, 4, 252645135);
              M[offset] = this._lBlock;
              M[offset + 1] = this._rBlock;
            },
            keySize: 64 / 32,
            ivSize: 64 / 32,
            blockSize: 64 / 32
          });
          function exchangeLR(offset, mask) {
            var t = (this._lBlock >>> offset ^ this._rBlock) & mask;
            this._rBlock ^= t;
            this._lBlock ^= t << offset;
          }
          function exchangeRL(offset, mask) {
            var t = (this._rBlock >>> offset ^ this._lBlock) & mask;
            this._lBlock ^= t;
            this._rBlock ^= t << offset;
          }
          C.DES = BlockCipher._createHelper(DES);
          var TripleDES = C_algo.TripleDES = BlockCipher.extend({
            _doReset: function() {
              var key2 = this._key;
              var keyWords = key2.words;
              if (keyWords.length !== 2 && keyWords.length !== 4 && keyWords.length < 6) {
                throw new Error("Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.");
              }
              var key1 = keyWords.slice(0, 2);
              var key22 = keyWords.length < 4 ? keyWords.slice(0, 2) : keyWords.slice(2, 4);
              var key3 = keyWords.length < 6 ? keyWords.slice(0, 2) : keyWords.slice(4, 6);
              this._des1 = DES.createEncryptor(WordArray.create(key1));
              this._des2 = DES.createEncryptor(WordArray.create(key22));
              this._des3 = DES.createEncryptor(WordArray.create(key3));
            },
            encryptBlock: function(M, offset) {
              this._des1.encryptBlock(M, offset);
              this._des2.decryptBlock(M, offset);
              this._des3.encryptBlock(M, offset);
            },
            decryptBlock: function(M, offset) {
              this._des3.decryptBlock(M, offset);
              this._des2.encryptBlock(M, offset);
              this._des1.decryptBlock(M, offset);
            },
            keySize: 192 / 32,
            ivSize: 64 / 32,
            blockSize: 64 / 32
          });
          C.TripleDES = BlockCipher._createHelper(TripleDES);
        })();
        return CryptoJS2.TripleDES;
      });
    })(tripledes);
    return tripledes.exports;
  }
  var rc4 = { exports: {} };
  var hasRequiredRc4;
  function requireRc4() {
    if (hasRequiredRc4)
      return rc4.exports;
    hasRequiredRc4 = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var StreamCipher = C_lib.StreamCipher;
          var C_algo = C.algo;
          var RC4 = C_algo.RC4 = StreamCipher.extend({
            _doReset: function() {
              var key2 = this._key;
              var keyWords = key2.words;
              var keySigBytes = key2.sigBytes;
              var S = this._S = [];
              for (var i2 = 0; i2 < 256; i2++) {
                S[i2] = i2;
              }
              for (var i2 = 0, j2 = 0; i2 < 256; i2++) {
                var keyByteIndex = i2 % keySigBytes;
                var keyByte = keyWords[keyByteIndex >>> 2] >>> 24 - keyByteIndex % 4 * 8 & 255;
                j2 = (j2 + S[i2] + keyByte) % 256;
                var t = S[i2];
                S[i2] = S[j2];
                S[j2] = t;
              }
              this._i = this._j = 0;
            },
            _doProcessBlock: function(M, offset) {
              M[offset] ^= generateKeystreamWord.call(this);
            },
            keySize: 256 / 32,
            ivSize: 0
          });
          function generateKeystreamWord() {
            var S = this._S;
            var i2 = this._i;
            var j2 = this._j;
            var keystreamWord = 0;
            for (var n = 0; n < 4; n++) {
              i2 = (i2 + 1) % 256;
              j2 = (j2 + S[i2]) % 256;
              var t = S[i2];
              S[i2] = S[j2];
              S[j2] = t;
              keystreamWord |= S[(S[i2] + S[j2]) % 256] << 24 - n * 8;
            }
            this._i = i2;
            this._j = j2;
            return keystreamWord;
          }
          C.RC4 = StreamCipher._createHelper(RC4);
          var RC4Drop = C_algo.RC4Drop = RC4.extend({
            /**
             * Configuration options.
             *
             * @property {number} drop The number of keystream words to drop. Default 192
             */
            cfg: RC4.cfg.extend({
              drop: 192
            }),
            _doReset: function() {
              RC4._doReset.call(this);
              for (var i2 = this.cfg.drop; i2 > 0; i2--) {
                generateKeystreamWord.call(this);
              }
            }
          });
          C.RC4Drop = StreamCipher._createHelper(RC4Drop);
        })();
        return CryptoJS2.RC4;
      });
    })(rc4);
    return rc4.exports;
  }
  var rabbit = { exports: {} };
  var hasRequiredRabbit;
  function requireRabbit() {
    if (hasRequiredRabbit)
      return rabbit.exports;
    hasRequiredRabbit = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var StreamCipher = C_lib.StreamCipher;
          var C_algo = C.algo;
          var S = [];
          var C_ = [];
          var G = [];
          var Rabbit = C_algo.Rabbit = StreamCipher.extend({
            _doReset: function() {
              var K = this._key.words;
              var iv = this.cfg.iv;
              for (var i2 = 0; i2 < 4; i2++) {
                K[i2] = (K[i2] << 8 | K[i2] >>> 24) & 16711935 | (K[i2] << 24 | K[i2] >>> 8) & 4278255360;
              }
              var X = this._X = [
                K[0],
                K[3] << 16 | K[2] >>> 16,
                K[1],
                K[0] << 16 | K[3] >>> 16,
                K[2],
                K[1] << 16 | K[0] >>> 16,
                K[3],
                K[2] << 16 | K[1] >>> 16
              ];
              var C2 = this._C = [
                K[2] << 16 | K[2] >>> 16,
                K[0] & 4294901760 | K[1] & 65535,
                K[3] << 16 | K[3] >>> 16,
                K[1] & 4294901760 | K[2] & 65535,
                K[0] << 16 | K[0] >>> 16,
                K[2] & 4294901760 | K[3] & 65535,
                K[1] << 16 | K[1] >>> 16,
                K[3] & 4294901760 | K[0] & 65535
              ];
              this._b = 0;
              for (var i2 = 0; i2 < 4; i2++) {
                nextState.call(this);
              }
              for (var i2 = 0; i2 < 8; i2++) {
                C2[i2] ^= X[i2 + 4 & 7];
              }
              if (iv) {
                var IV = iv.words;
                var IV_0 = IV[0];
                var IV_1 = IV[1];
                var i0 = (IV_0 << 8 | IV_0 >>> 24) & 16711935 | (IV_0 << 24 | IV_0 >>> 8) & 4278255360;
                var i22 = (IV_1 << 8 | IV_1 >>> 24) & 16711935 | (IV_1 << 24 | IV_1 >>> 8) & 4278255360;
                var i1 = i0 >>> 16 | i22 & 4294901760;
                var i3 = i22 << 16 | i0 & 65535;
                C2[0] ^= i0;
                C2[1] ^= i1;
                C2[2] ^= i22;
                C2[3] ^= i3;
                C2[4] ^= i0;
                C2[5] ^= i1;
                C2[6] ^= i22;
                C2[7] ^= i3;
                for (var i2 = 0; i2 < 4; i2++) {
                  nextState.call(this);
                }
              }
            },
            _doProcessBlock: function(M, offset) {
              var X = this._X;
              nextState.call(this);
              S[0] = X[0] ^ X[5] >>> 16 ^ X[3] << 16;
              S[1] = X[2] ^ X[7] >>> 16 ^ X[5] << 16;
              S[2] = X[4] ^ X[1] >>> 16 ^ X[7] << 16;
              S[3] = X[6] ^ X[3] >>> 16 ^ X[1] << 16;
              for (var i2 = 0; i2 < 4; i2++) {
                S[i2] = (S[i2] << 8 | S[i2] >>> 24) & 16711935 | (S[i2] << 24 | S[i2] >>> 8) & 4278255360;
                M[offset + i2] ^= S[i2];
              }
            },
            blockSize: 128 / 32,
            ivSize: 64 / 32
          });
          function nextState() {
            var X = this._X;
            var C2 = this._C;
            for (var i2 = 0; i2 < 8; i2++) {
              C_[i2] = C2[i2];
            }
            C2[0] = C2[0] + 1295307597 + this._b | 0;
            C2[1] = C2[1] + 3545052371 + (C2[0] >>> 0 < C_[0] >>> 0 ? 1 : 0) | 0;
            C2[2] = C2[2] + 886263092 + (C2[1] >>> 0 < C_[1] >>> 0 ? 1 : 0) | 0;
            C2[3] = C2[3] + 1295307597 + (C2[2] >>> 0 < C_[2] >>> 0 ? 1 : 0) | 0;
            C2[4] = C2[4] + 3545052371 + (C2[3] >>> 0 < C_[3] >>> 0 ? 1 : 0) | 0;
            C2[5] = C2[5] + 886263092 + (C2[4] >>> 0 < C_[4] >>> 0 ? 1 : 0) | 0;
            C2[6] = C2[6] + 1295307597 + (C2[5] >>> 0 < C_[5] >>> 0 ? 1 : 0) | 0;
            C2[7] = C2[7] + 3545052371 + (C2[6] >>> 0 < C_[6] >>> 0 ? 1 : 0) | 0;
            this._b = C2[7] >>> 0 < C_[7] >>> 0 ? 1 : 0;
            for (var i2 = 0; i2 < 8; i2++) {
              var gx = X[i2] + C2[i2];
              var ga = gx & 65535;
              var gb = gx >>> 16;
              var gh = ((ga * ga >>> 17) + ga * gb >>> 15) + gb * gb;
              var gl = ((gx & 4294901760) * gx | 0) + ((gx & 65535) * gx | 0);
              G[i2] = gh ^ gl;
            }
            X[0] = G[0] + (G[7] << 16 | G[7] >>> 16) + (G[6] << 16 | G[6] >>> 16) | 0;
            X[1] = G[1] + (G[0] << 8 | G[0] >>> 24) + G[7] | 0;
            X[2] = G[2] + (G[1] << 16 | G[1] >>> 16) + (G[0] << 16 | G[0] >>> 16) | 0;
            X[3] = G[3] + (G[2] << 8 | G[2] >>> 24) + G[1] | 0;
            X[4] = G[4] + (G[3] << 16 | G[3] >>> 16) + (G[2] << 16 | G[2] >>> 16) | 0;
            X[5] = G[5] + (G[4] << 8 | G[4] >>> 24) + G[3] | 0;
            X[6] = G[6] + (G[5] << 16 | G[5] >>> 16) + (G[4] << 16 | G[4] >>> 16) | 0;
            X[7] = G[7] + (G[6] << 8 | G[6] >>> 24) + G[5] | 0;
          }
          C.Rabbit = StreamCipher._createHelper(Rabbit);
        })();
        return CryptoJS2.Rabbit;
      });
    })(rabbit);
    return rabbit.exports;
  }
  var rabbitLegacy = { exports: {} };
  var hasRequiredRabbitLegacy;
  function requireRabbitLegacy() {
    if (hasRequiredRabbitLegacy)
      return rabbitLegacy.exports;
    hasRequiredRabbitLegacy = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var StreamCipher = C_lib.StreamCipher;
          var C_algo = C.algo;
          var S = [];
          var C_ = [];
          var G = [];
          var RabbitLegacy = C_algo.RabbitLegacy = StreamCipher.extend({
            _doReset: function() {
              var K = this._key.words;
              var iv = this.cfg.iv;
              var X = this._X = [
                K[0],
                K[3] << 16 | K[2] >>> 16,
                K[1],
                K[0] << 16 | K[3] >>> 16,
                K[2],
                K[1] << 16 | K[0] >>> 16,
                K[3],
                K[2] << 16 | K[1] >>> 16
              ];
              var C2 = this._C = [
                K[2] << 16 | K[2] >>> 16,
                K[0] & 4294901760 | K[1] & 65535,
                K[3] << 16 | K[3] >>> 16,
                K[1] & 4294901760 | K[2] & 65535,
                K[0] << 16 | K[0] >>> 16,
                K[2] & 4294901760 | K[3] & 65535,
                K[1] << 16 | K[1] >>> 16,
                K[3] & 4294901760 | K[0] & 65535
              ];
              this._b = 0;
              for (var i2 = 0; i2 < 4; i2++) {
                nextState.call(this);
              }
              for (var i2 = 0; i2 < 8; i2++) {
                C2[i2] ^= X[i2 + 4 & 7];
              }
              if (iv) {
                var IV = iv.words;
                var IV_0 = IV[0];
                var IV_1 = IV[1];
                var i0 = (IV_0 << 8 | IV_0 >>> 24) & 16711935 | (IV_0 << 24 | IV_0 >>> 8) & 4278255360;
                var i22 = (IV_1 << 8 | IV_1 >>> 24) & 16711935 | (IV_1 << 24 | IV_1 >>> 8) & 4278255360;
                var i1 = i0 >>> 16 | i22 & 4294901760;
                var i3 = i22 << 16 | i0 & 65535;
                C2[0] ^= i0;
                C2[1] ^= i1;
                C2[2] ^= i22;
                C2[3] ^= i3;
                C2[4] ^= i0;
                C2[5] ^= i1;
                C2[6] ^= i22;
                C2[7] ^= i3;
                for (var i2 = 0; i2 < 4; i2++) {
                  nextState.call(this);
                }
              }
            },
            _doProcessBlock: function(M, offset) {
              var X = this._X;
              nextState.call(this);
              S[0] = X[0] ^ X[5] >>> 16 ^ X[3] << 16;
              S[1] = X[2] ^ X[7] >>> 16 ^ X[5] << 16;
              S[2] = X[4] ^ X[1] >>> 16 ^ X[7] << 16;
              S[3] = X[6] ^ X[3] >>> 16 ^ X[1] << 16;
              for (var i2 = 0; i2 < 4; i2++) {
                S[i2] = (S[i2] << 8 | S[i2] >>> 24) & 16711935 | (S[i2] << 24 | S[i2] >>> 8) & 4278255360;
                M[offset + i2] ^= S[i2];
              }
            },
            blockSize: 128 / 32,
            ivSize: 64 / 32
          });
          function nextState() {
            var X = this._X;
            var C2 = this._C;
            for (var i2 = 0; i2 < 8; i2++) {
              C_[i2] = C2[i2];
            }
            C2[0] = C2[0] + 1295307597 + this._b | 0;
            C2[1] = C2[1] + 3545052371 + (C2[0] >>> 0 < C_[0] >>> 0 ? 1 : 0) | 0;
            C2[2] = C2[2] + 886263092 + (C2[1] >>> 0 < C_[1] >>> 0 ? 1 : 0) | 0;
            C2[3] = C2[3] + 1295307597 + (C2[2] >>> 0 < C_[2] >>> 0 ? 1 : 0) | 0;
            C2[4] = C2[4] + 3545052371 + (C2[3] >>> 0 < C_[3] >>> 0 ? 1 : 0) | 0;
            C2[5] = C2[5] + 886263092 + (C2[4] >>> 0 < C_[4] >>> 0 ? 1 : 0) | 0;
            C2[6] = C2[6] + 1295307597 + (C2[5] >>> 0 < C_[5] >>> 0 ? 1 : 0) | 0;
            C2[7] = C2[7] + 3545052371 + (C2[6] >>> 0 < C_[6] >>> 0 ? 1 : 0) | 0;
            this._b = C2[7] >>> 0 < C_[7] >>> 0 ? 1 : 0;
            for (var i2 = 0; i2 < 8; i2++) {
              var gx = X[i2] + C2[i2];
              var ga = gx & 65535;
              var gb = gx >>> 16;
              var gh = ((ga * ga >>> 17) + ga * gb >>> 15) + gb * gb;
              var gl = ((gx & 4294901760) * gx | 0) + ((gx & 65535) * gx | 0);
              G[i2] = gh ^ gl;
            }
            X[0] = G[0] + (G[7] << 16 | G[7] >>> 16) + (G[6] << 16 | G[6] >>> 16) | 0;
            X[1] = G[1] + (G[0] << 8 | G[0] >>> 24) + G[7] | 0;
            X[2] = G[2] + (G[1] << 16 | G[1] >>> 16) + (G[0] << 16 | G[0] >>> 16) | 0;
            X[3] = G[3] + (G[2] << 8 | G[2] >>> 24) + G[1] | 0;
            X[4] = G[4] + (G[3] << 16 | G[3] >>> 16) + (G[2] << 16 | G[2] >>> 16) | 0;
            X[5] = G[5] + (G[4] << 8 | G[4] >>> 24) + G[3] | 0;
            X[6] = G[6] + (G[5] << 16 | G[5] >>> 16) + (G[4] << 16 | G[4] >>> 16) | 0;
            X[7] = G[7] + (G[6] << 8 | G[6] >>> 24) + G[5] | 0;
          }
          C.RabbitLegacy = StreamCipher._createHelper(RabbitLegacy);
        })();
        return CryptoJS2.RabbitLegacy;
      });
    })(rabbitLegacy);
    return rabbitLegacy.exports;
  }
  var blowfish = { exports: {} };
  var hasRequiredBlowfish;
  function requireBlowfish() {
    if (hasRequiredBlowfish)
      return blowfish.exports;
    hasRequiredBlowfish = 1;
    (function(module, exports) {
      (function(root, factory, undef) {
        {
          module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
        }
      })(commonjsGlobal, function(CryptoJS2) {
        (function() {
          var C = CryptoJS2;
          var C_lib = C.lib;
          var BlockCipher = C_lib.BlockCipher;
          var C_algo = C.algo;
          const N = 16;
          const ORIG_P = [
            608135816,
            2242054355,
            320440878,
            57701188,
            2752067618,
            698298832,
            137296536,
            3964562569,
            1160258022,
            953160567,
            3193202383,
            887688300,
            3232508343,
            3380367581,
            1065670069,
            3041331479,
            2450970073,
            2306472731
          ];
          const ORIG_S = [
            [
              3509652390,
              2564797868,
              805139163,
              3491422135,
              3101798381,
              1780907670,
              3128725573,
              4046225305,
              614570311,
              3012652279,
              134345442,
              2240740374,
              1667834072,
              1901547113,
              2757295779,
              4103290238,
              227898511,
              1921955416,
              1904987480,
              2182433518,
              2069144605,
              3260701109,
              2620446009,
              720527379,
              3318853667,
              677414384,
              3393288472,
              3101374703,
              2390351024,
              1614419982,
              1822297739,
              2954791486,
              3608508353,
              3174124327,
              2024746970,
              1432378464,
              3864339955,
              2857741204,
              1464375394,
              1676153920,
              1439316330,
              715854006,
              3033291828,
              289532110,
              2706671279,
              2087905683,
              3018724369,
              1668267050,
              732546397,
              1947742710,
              3462151702,
              2609353502,
              2950085171,
              1814351708,
              2050118529,
              680887927,
              999245976,
              1800124847,
              3300911131,
              1713906067,
              1641548236,
              4213287313,
              1216130144,
              1575780402,
              4018429277,
              3917837745,
              3693486850,
              3949271944,
              596196993,
              3549867205,
              258830323,
              2213823033,
              772490370,
              2760122372,
              1774776394,
              2652871518,
              566650946,
              4142492826,
              1728879713,
              2882767088,
              1783734482,
              3629395816,
              2517608232,
              2874225571,
              1861159788,
              326777828,
              3124490320,
              2130389656,
              2716951837,
              967770486,
              1724537150,
              2185432712,
              2364442137,
              1164943284,
              2105845187,
              998989502,
              3765401048,
              2244026483,
              1075463327,
              1455516326,
              1322494562,
              910128902,
              469688178,
              1117454909,
              936433444,
              3490320968,
              3675253459,
              1240580251,
              122909385,
              2157517691,
              634681816,
              4142456567,
              3825094682,
              3061402683,
              2540495037,
              79693498,
              3249098678,
              1084186820,
              1583128258,
              426386531,
              1761308591,
              1047286709,
              322548459,
              995290223,
              1845252383,
              2603652396,
              3431023940,
              2942221577,
              3202600964,
              3727903485,
              1712269319,
              422464435,
              3234572375,
              1170764815,
              3523960633,
              3117677531,
              1434042557,
              442511882,
              3600875718,
              1076654713,
              1738483198,
              4213154764,
              2393238008,
              3677496056,
              1014306527,
              4251020053,
              793779912,
              2902807211,
              842905082,
              4246964064,
              1395751752,
              1040244610,
              2656851899,
              3396308128,
              445077038,
              3742853595,
              3577915638,
              679411651,
              2892444358,
              2354009459,
              1767581616,
              3150600392,
              3791627101,
              3102740896,
              284835224,
              4246832056,
              1258075500,
              768725851,
              2589189241,
              3069724005,
              3532540348,
              1274779536,
              3789419226,
              2764799539,
              1660621633,
              3471099624,
              4011903706,
              913787905,
              3497959166,
              737222580,
              2514213453,
              2928710040,
              3937242737,
              1804850592,
              3499020752,
              2949064160,
              2386320175,
              2390070455,
              2415321851,
              4061277028,
              2290661394,
              2416832540,
              1336762016,
              1754252060,
              3520065937,
              3014181293,
              791618072,
              3188594551,
              3933548030,
              2332172193,
              3852520463,
              3043980520,
              413987798,
              3465142937,
              3030929376,
              4245938359,
              2093235073,
              3534596313,
              375366246,
              2157278981,
              2479649556,
              555357303,
              3870105701,
              2008414854,
              3344188149,
              4221384143,
              3956125452,
              2067696032,
              3594591187,
              2921233993,
              2428461,
              544322398,
              577241275,
              1471733935,
              610547355,
              4027169054,
              1432588573,
              1507829418,
              2025931657,
              3646575487,
              545086370,
              48609733,
              2200306550,
              1653985193,
              298326376,
              1316178497,
              3007786442,
              2064951626,
              458293330,
              2589141269,
              3591329599,
              3164325604,
              727753846,
              2179363840,
              146436021,
              1461446943,
              4069977195,
              705550613,
              3059967265,
              3887724982,
              4281599278,
              3313849956,
              1404054877,
              2845806497,
              146425753,
              1854211946
            ],
            [
              1266315497,
              3048417604,
              3681880366,
              3289982499,
              290971e4,
              1235738493,
              2632868024,
              2414719590,
              3970600049,
              1771706367,
              1449415276,
              3266420449,
              422970021,
              1963543593,
              2690192192,
              3826793022,
              1062508698,
              1531092325,
              1804592342,
              2583117782,
              2714934279,
              4024971509,
              1294809318,
              4028980673,
              1289560198,
              2221992742,
              1669523910,
              35572830,
              157838143,
              1052438473,
              1016535060,
              1802137761,
              1753167236,
              1386275462,
              3080475397,
              2857371447,
              1040679964,
              2145300060,
              2390574316,
              1461121720,
              2956646967,
              4031777805,
              4028374788,
              33600511,
              2920084762,
              1018524850,
              629373528,
              3691585981,
              3515945977,
              2091462646,
              2486323059,
              586499841,
              988145025,
              935516892,
              3367335476,
              2599673255,
              2839830854,
              265290510,
              3972581182,
              2759138881,
              3795373465,
              1005194799,
              847297441,
              406762289,
              1314163512,
              1332590856,
              1866599683,
              4127851711,
              750260880,
              613907577,
              1450815602,
              3165620655,
              3734664991,
              3650291728,
              3012275730,
              3704569646,
              1427272223,
              778793252,
              1343938022,
              2676280711,
              2052605720,
              1946737175,
              3164576444,
              3914038668,
              3967478842,
              3682934266,
              1661551462,
              3294938066,
              4011595847,
              840292616,
              3712170807,
              616741398,
              312560963,
              711312465,
              1351876610,
              322626781,
              1910503582,
              271666773,
              2175563734,
              1594956187,
              70604529,
              3617834859,
              1007753275,
              1495573769,
              4069517037,
              2549218298,
              2663038764,
              504708206,
              2263041392,
              3941167025,
              2249088522,
              1514023603,
              1998579484,
              1312622330,
              694541497,
              2582060303,
              2151582166,
              1382467621,
              776784248,
              2618340202,
              3323268794,
              2497899128,
              2784771155,
              503983604,
              4076293799,
              907881277,
              423175695,
              432175456,
              1378068232,
              4145222326,
              3954048622,
              3938656102,
              3820766613,
              2793130115,
              2977904593,
              26017576,
              3274890735,
              3194772133,
              1700274565,
              1756076034,
              4006520079,
              3677328699,
              720338349,
              1533947780,
              354530856,
              688349552,
              3973924725,
              1637815568,
              332179504,
              3949051286,
              53804574,
              2852348879,
              3044236432,
              1282449977,
              3583942155,
              3416972820,
              4006381244,
              1617046695,
              2628476075,
              3002303598,
              1686838959,
              431878346,
              2686675385,
              1700445008,
              1080580658,
              1009431731,
              832498133,
              3223435511,
              2605976345,
              2271191193,
              2516031870,
              1648197032,
              4164389018,
              2548247927,
              300782431,
              375919233,
              238389289,
              3353747414,
              2531188641,
              2019080857,
              1475708069,
              455242339,
              2609103871,
              448939670,
              3451063019,
              1395535956,
              2413381860,
              1841049896,
              1491858159,
              885456874,
              4264095073,
              4001119347,
              1565136089,
              3898914787,
              1108368660,
              540939232,
              1173283510,
              2745871338,
              3681308437,
              4207628240,
              3343053890,
              4016749493,
              1699691293,
              1103962373,
              3625875870,
              2256883143,
              3830138730,
              1031889488,
              3479347698,
              1535977030,
              4236805024,
              3251091107,
              2132092099,
              1774941330,
              1199868427,
              1452454533,
              157007616,
              2904115357,
              342012276,
              595725824,
              1480756522,
              206960106,
              497939518,
              591360097,
              863170706,
              2375253569,
              3596610801,
              1814182875,
              2094937945,
              3421402208,
              1082520231,
              3463918190,
              2785509508,
              435703966,
              3908032597,
              1641649973,
              2842273706,
              3305899714,
              1510255612,
              2148256476,
              2655287854,
              3276092548,
              4258621189,
              236887753,
              3681803219,
              274041037,
              1734335097,
              3815195456,
              3317970021,
              1899903192,
              1026095262,
              4050517792,
              356393447,
              2410691914,
              3873677099,
              3682840055
            ],
            [
              3913112168,
              2491498743,
              4132185628,
              2489919796,
              1091903735,
              1979897079,
              3170134830,
              3567386728,
              3557303409,
              857797738,
              1136121015,
              1342202287,
              507115054,
              2535736646,
              337727348,
              3213592640,
              1301675037,
              2528481711,
              1895095763,
              1721773893,
              3216771564,
              62756741,
              2142006736,
              835421444,
              2531993523,
              1442658625,
              3659876326,
              2882144922,
              676362277,
              1392781812,
              170690266,
              3921047035,
              1759253602,
              3611846912,
              1745797284,
              664899054,
              1329594018,
              3901205900,
              3045908486,
              2062866102,
              2865634940,
              3543621612,
              3464012697,
              1080764994,
              553557557,
              3656615353,
              3996768171,
              991055499,
              499776247,
              1265440854,
              648242737,
              3940784050,
              980351604,
              3713745714,
              1749149687,
              3396870395,
              4211799374,
              3640570775,
              1161844396,
              3125318951,
              1431517754,
              545492359,
              4268468663,
              3499529547,
              1437099964,
              2702547544,
              3433638243,
              2581715763,
              2787789398,
              1060185593,
              1593081372,
              2418618748,
              4260947970,
              69676912,
              2159744348,
              86519011,
              2512459080,
              3838209314,
              1220612927,
              3339683548,
              133810670,
              1090789135,
              1078426020,
              1569222167,
              845107691,
              3583754449,
              4072456591,
              1091646820,
              628848692,
              1613405280,
              3757631651,
              526609435,
              236106946,
              48312990,
              2942717905,
              3402727701,
              1797494240,
              859738849,
              992217954,
              4005476642,
              2243076622,
              3870952857,
              3732016268,
              765654824,
              3490871365,
              2511836413,
              1685915746,
              3888969200,
              1414112111,
              2273134842,
              3281911079,
              4080962846,
              172450625,
              2569994100,
              980381355,
              4109958455,
              2819808352,
              2716589560,
              2568741196,
              3681446669,
              3329971472,
              1835478071,
              660984891,
              3704678404,
              4045999559,
              3422617507,
              3040415634,
              1762651403,
              1719377915,
              3470491036,
              2693910283,
              3642056355,
              3138596744,
              1364962596,
              2073328063,
              1983633131,
              926494387,
              3423689081,
              2150032023,
              4096667949,
              1749200295,
              3328846651,
              309677260,
              2016342300,
              1779581495,
              3079819751,
              111262694,
              1274766160,
              443224088,
              298511866,
              1025883608,
              3806446537,
              1145181785,
              168956806,
              3641502830,
              3584813610,
              1689216846,
              3666258015,
              3200248200,
              1692713982,
              2646376535,
              4042768518,
              1618508792,
              1610833997,
              3523052358,
              4130873264,
              2001055236,
              3610705100,
              2202168115,
              4028541809,
              2961195399,
              1006657119,
              2006996926,
              3186142756,
              1430667929,
              3210227297,
              1314452623,
              4074634658,
              4101304120,
              2273951170,
              1399257539,
              3367210612,
              3027628629,
              1190975929,
              2062231137,
              2333990788,
              2221543033,
              2438960610,
              1181637006,
              548689776,
              2362791313,
              3372408396,
              3104550113,
              3145860560,
              296247880,
              1970579870,
              3078560182,
              3769228297,
              1714227617,
              3291629107,
              3898220290,
              166772364,
              1251581989,
              493813264,
              448347421,
              195405023,
              2709975567,
              677966185,
              3703036547,
              1463355134,
              2715995803,
              1338867538,
              1343315457,
              2802222074,
              2684532164,
              233230375,
              2599980071,
              2000651841,
              3277868038,
              1638401717,
              4028070440,
              3237316320,
              6314154,
              819756386,
              300326615,
              590932579,
              1405279636,
              3267499572,
              3150704214,
              2428286686,
              3959192993,
              3461946742,
              1862657033,
              1266418056,
              963775037,
              2089974820,
              2263052895,
              1917689273,
              448879540,
              3550394620,
              3981727096,
              150775221,
              3627908307,
              1303187396,
              508620638,
              2975983352,
              2726630617,
              1817252668,
              1876281319,
              1457606340,
              908771278,
              3720792119,
              3617206836,
              2455994898,
              1729034894,
              1080033504
            ],
            [
              976866871,
              3556439503,
              2881648439,
              1522871579,
              1555064734,
              1336096578,
              3548522304,
              2579274686,
              3574697629,
              3205460757,
              3593280638,
              3338716283,
              3079412587,
              564236357,
              2993598910,
              1781952180,
              1464380207,
              3163844217,
              3332601554,
              1699332808,
              1393555694,
              1183702653,
              3581086237,
              1288719814,
              691649499,
              2847557200,
              2895455976,
              3193889540,
              2717570544,
              1781354906,
              1676643554,
              2592534050,
              3230253752,
              1126444790,
              2770207658,
              2633158820,
              2210423226,
              2615765581,
              2414155088,
              3127139286,
              673620729,
              2805611233,
              1269405062,
              4015350505,
              3341807571,
              4149409754,
              1057255273,
              2012875353,
              2162469141,
              2276492801,
              2601117357,
              993977747,
              3918593370,
              2654263191,
              753973209,
              36408145,
              2530585658,
              25011837,
              3520020182,
              2088578344,
              530523599,
              2918365339,
              1524020338,
              1518925132,
              3760827505,
              3759777254,
              1202760957,
              3985898139,
              3906192525,
              674977740,
              4174734889,
              2031300136,
              2019492241,
              3983892565,
              4153806404,
              3822280332,
              352677332,
              2297720250,
              60907813,
              90501309,
              3286998549,
              1016092578,
              2535922412,
              2839152426,
              457141659,
              509813237,
              4120667899,
              652014361,
              1966332200,
              2975202805,
              55981186,
              2327461051,
              676427537,
              3255491064,
              2882294119,
              3433927263,
              1307055953,
              942726286,
              933058658,
              2468411793,
              3933900994,
              4215176142,
              1361170020,
              2001714738,
              2830558078,
              3274259782,
              1222529897,
              1679025792,
              2729314320,
              3714953764,
              1770335741,
              151462246,
              3013232138,
              1682292957,
              1483529935,
              471910574,
              1539241949,
              458788160,
              3436315007,
              1807016891,
              3718408830,
              978976581,
              1043663428,
              3165965781,
              1927990952,
              4200891579,
              2372276910,
              3208408903,
              3533431907,
              1412390302,
              2931980059,
              4132332400,
              1947078029,
              3881505623,
              4168226417,
              2941484381,
              1077988104,
              1320477388,
              886195818,
              18198404,
              3786409e3,
              2509781533,
              112762804,
              3463356488,
              1866414978,
              891333506,
              18488651,
              661792760,
              1628790961,
              3885187036,
              3141171499,
              876946877,
              2693282273,
              1372485963,
              791857591,
              2686433993,
              3759982718,
              3167212022,
              3472953795,
              2716379847,
              445679433,
              3561995674,
              3504004811,
              3574258232,
              54117162,
              3331405415,
              2381918588,
              3769707343,
              4154350007,
              1140177722,
              4074052095,
              668550556,
              3214352940,
              367459370,
              261225585,
              2610173221,
              4209349473,
              3468074219,
              3265815641,
              314222801,
              3066103646,
              3808782860,
              282218597,
              3406013506,
              3773591054,
              379116347,
              1285071038,
              846784868,
              2669647154,
              3771962079,
              3550491691,
              2305946142,
              453669953,
              1268987020,
              3317592352,
              3279303384,
              3744833421,
              2610507566,
              3859509063,
              266596637,
              3847019092,
              517658769,
              3462560207,
              3443424879,
              370717030,
              4247526661,
              2224018117,
              4143653529,
              4112773975,
              2788324899,
              2477274417,
              1456262402,
              2901442914,
              1517677493,
              1846949527,
              2295493580,
              3734397586,
              2176403920,
              1280348187,
              1908823572,
              3871786941,
              846861322,
              1172426758,
              3287448474,
              3383383037,
              1655181056,
              3139813346,
              901632758,
              1897031941,
              2986607138,
              3066810236,
              3447102507,
              1393639104,
              373351379,
              950779232,
              625454576,
              3124240540,
              4148612726,
              2007998917,
              544563296,
              2244738638,
              2330496472,
              2058025392,
              1291430526,
              424198748,
              50039436,
              29584100,
              3605783033,
              2429876329,
              2791104160,
              1057563949,
              3255363231,
              3075367218,
              3463963227,
              1469046755,
              985887462
            ]
          ];
          var BLOWFISH_CTX = {
            pbox: [],
            sbox: []
          };
          function F(ctx, x) {
            let a2 = x >> 24 & 255;
            let b2 = x >> 16 & 255;
            let c2 = x >> 8 & 255;
            let d2 = x & 255;
            let y = ctx.sbox[0][a2] + ctx.sbox[1][b2];
            y = y ^ ctx.sbox[2][c2];
            y = y + ctx.sbox[3][d2];
            return y;
          }
          function BlowFish_Encrypt(ctx, left, right) {
            let Xl = left;
            let Xr = right;
            let temp;
            for (let i2 = 0; i2 < N; ++i2) {
              Xl = Xl ^ ctx.pbox[i2];
              Xr = F(ctx, Xl) ^ Xr;
              temp = Xl;
              Xl = Xr;
              Xr = temp;
            }
            temp = Xl;
            Xl = Xr;
            Xr = temp;
            Xr = Xr ^ ctx.pbox[N];
            Xl = Xl ^ ctx.pbox[N + 1];
            return { left: Xl, right: Xr };
          }
          function BlowFish_Decrypt(ctx, left, right) {
            let Xl = left;
            let Xr = right;
            let temp;
            for (let i2 = N + 1; i2 > 1; --i2) {
              Xl = Xl ^ ctx.pbox[i2];
              Xr = F(ctx, Xl) ^ Xr;
              temp = Xl;
              Xl = Xr;
              Xr = temp;
            }
            temp = Xl;
            Xl = Xr;
            Xr = temp;
            Xr = Xr ^ ctx.pbox[1];
            Xl = Xl ^ ctx.pbox[0];
            return { left: Xl, right: Xr };
          }
          function BlowFishInit(ctx, key2, keysize) {
            for (let Row = 0; Row < 4; Row++) {
              ctx.sbox[Row] = [];
              for (let Col = 0; Col < 256; Col++) {
                ctx.sbox[Row][Col] = ORIG_S[Row][Col];
              }
            }
            let keyIndex = 0;
            for (let index = 0; index < N + 2; index++) {
              ctx.pbox[index] = ORIG_P[index] ^ key2[keyIndex];
              keyIndex++;
              if (keyIndex >= keysize) {
                keyIndex = 0;
              }
            }
            let Data1 = 0;
            let Data2 = 0;
            let res = 0;
            for (let i2 = 0; i2 < N + 2; i2 += 2) {
              res = BlowFish_Encrypt(ctx, Data1, Data2);
              Data1 = res.left;
              Data2 = res.right;
              ctx.pbox[i2] = Data1;
              ctx.pbox[i2 + 1] = Data2;
            }
            for (let i2 = 0; i2 < 4; i2++) {
              for (let j2 = 0; j2 < 256; j2 += 2) {
                res = BlowFish_Encrypt(ctx, Data1, Data2);
                Data1 = res.left;
                Data2 = res.right;
                ctx.sbox[i2][j2] = Data1;
                ctx.sbox[i2][j2 + 1] = Data2;
              }
            }
            return true;
          }
          var Blowfish = C_algo.Blowfish = BlockCipher.extend({
            _doReset: function() {
              if (this._keyPriorReset === this._key) {
                return;
              }
              var key2 = this._keyPriorReset = this._key;
              var keyWords = key2.words;
              var keySize = key2.sigBytes / 4;
              BlowFishInit(BLOWFISH_CTX, keyWords, keySize);
            },
            encryptBlock: function(M, offset) {
              var res = BlowFish_Encrypt(BLOWFISH_CTX, M[offset], M[offset + 1]);
              M[offset] = res.left;
              M[offset + 1] = res.right;
            },
            decryptBlock: function(M, offset) {
              var res = BlowFish_Decrypt(BLOWFISH_CTX, M[offset], M[offset + 1]);
              M[offset] = res.left;
              M[offset + 1] = res.right;
            },
            blockSize: 64 / 32,
            keySize: 128 / 32,
            ivSize: 64 / 32
          });
          C.Blowfish = BlockCipher._createHelper(Blowfish);
        })();
        return CryptoJS2.Blowfish;
      });
    })(blowfish);
    return blowfish.exports;
  }
  (function(module, exports) {
    (function(root, factory, undef) {
      {
        module.exports = factory(requireCore(), requireX64Core(), requireLibTypedarrays(), requireEncUtf16(), requireEncBase64(), requireEncBase64url(), requireMd5(), requireSha1(), requireSha256(), requireSha224(), requireSha512(), requireSha384(), requireSha3(), requireRipemd160(), requireHmac(), requirePbkdf2(), requireEvpkdf(), requireCipherCore(), requireModeCfb(), requireModeCtr(), requireModeCtrGladman(), requireModeOfb(), requireModeEcb(), requirePadAnsix923(), requirePadIso10126(), requirePadIso97971(), requirePadZeropadding(), requirePadNopadding(), requireFormatHex(), requireAes(), requireTripledes(), requireRc4(), requireRabbit(), requireRabbitLegacy(), requireBlowfish());
      }
    })(commonjsGlobal, function(CryptoJS2) {
      return CryptoJS2;
    });
  })(cryptoJs);
  var cryptoJsExports = cryptoJs.exports;
  const CryptoJS = /* @__PURE__ */ getDefaultExportFromCjs(cryptoJsExports);
  function d(d2, e, f, g) {
    var h = {}, i2 = a(16);
    return h.encText = b(d2, g), h.encText = b(h.encText, i2), h.encSecKey = c(i2, e, f), h;
  }
  function a(a2) {
    var d2, e, b2 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", c2 = "";
    for (d2 = 0; a2 > d2; d2 += 1)
      e = Math.random() * b2.length, e = Math.floor(e), c2 += b2.charAt(e);
    return c2;
  }
  function b(a2, b2) {
    var c2 = CryptoJS.enc.Utf8.parse(b2), d2 = CryptoJS.enc.Utf8.parse("0102030405060708"), e = CryptoJS.enc.Utf8.parse(a2), f = CryptoJS.AES.encrypt(e, c2, {
      iv: d2,
      mode: CryptoJS.mode.CBC
    });
    return f.toString();
  }
  function c(a2, b2, c2) {
    var d2;
    return setMaxDigits(131), d2 = new RSAKeyPair(b2, "", c2), encryptedString(d2, a2);
  }
  function RSAKeyPair(a2, b2, c2) {
    this.e = biFromHex(a2), this.d = biFromHex(b2), this.m = biFromHex(c2), this.chunkSize = 2 * biHighIndex(this.m), this.radix = 16, this.barrett = new BarrettMu(this.m);
  }
  function encryptedString(a2, b2) {
    for (var f, g, h, i2, j2, k, l, c2 = new Array(), d2 = b2.length, e = 0; d2 > e; )
      c2[e] = b2.charCodeAt(e), e++;
    for (; 0 != c2.length % a2.chunkSize; )
      c2[e++] = 0;
    for (f = c2.length, g = "", e = 0; f > e; e += a2.chunkSize) {
      for (j2 = new BigInt(), h = 0, i2 = e; i2 < e + a2.chunkSize; ++h)
        j2.digits[h] = c2[i2++], j2.digits[h] += c2[i2++] << 8;
      k = a2.barrett.powMod(j2, a2.e), l = 16 == a2.radix ? biToHex(k) : biToString(k, a2.radix), g += l + " ";
    }
    return g.substring(0, g.length - 1);
  }
  function setMaxDigits(a2) {
    maxDigits = a2, ZERO_ARRAY = new Array(maxDigits);
    for (var b2 = 0; b2 < ZERO_ARRAY.length; b2++)
      ZERO_ARRAY[b2] = 0;
    bigZero = new BigInt(), bigOne = new BigInt(), bigOne.digits[0] = 1;
  }
  function BigInt(a2) {
    this.digits = "boolean" == typeof a2 && 1 == a2 ? null : ZERO_ARRAY.slice(0), this.isNeg = false;
  }
  function biCopy(a2) {
    var b2 = new BigInt(true);
    return b2.digits = a2.digits.slice(0), b2.isNeg = a2.isNeg, b2;
  }
  function biFromNumber(a2) {
    var c2, b2 = new BigInt();
    for (b2.isNeg = 0 > a2, a2 = Math.abs(a2), c2 = 0; a2 > 0; )
      b2.digits[c2++] = a2 & maxDigitVal, a2 >>= biRadixBits;
    return b2;
  }
  function reverseStr(a2) {
    var c2, b2 = "";
    for (c2 = a2.length - 1; c2 > -1; --c2)
      b2 += a2.charAt(c2);
    return b2;
  }
  function biToString(a2, b2) {
    var d2, e, c2 = new BigInt();
    for (c2.digits[0] = b2, d2 = biDivideModulo(a2, c2), e = hexatrigesimalToChar[d2[1].digits[0]]; 1 == biCompare(d2[0], bigZero); )
      d2 = biDivideModulo(d2[0], c2), digit = d2[1].digits[0], e += hexatrigesimalToChar[d2[1].digits[0]];
    return (a2.isNeg ? "-" : "") + reverseStr(e);
  }
  function digitToHex(a2) {
    var b2 = 15, c2 = "";
    for (i = 0; 4 > i; ++i)
      c2 += hexToChar[a2 & b2], a2 >>>= 4;
    return reverseStr(c2);
  }
  function biToHex(a2) {
    var d2, b2 = "";
    for (biHighIndex(a2), d2 = biHighIndex(a2); d2 > -1; --d2)
      b2 += digitToHex(a2.digits[d2]);
    return b2;
  }
  function charToHex(a2) {
    var b2 = 48, c2 = b2 + 9, d2 = 97, e = d2 + 25, f = 65, g = 90;
    return a2 >= b2 && c2 >= a2 ? a2 - b2 : a2 >= f && g >= a2 ? 10 + a2 - f : a2 >= d2 && e >= a2 ? 10 + a2 - d2 : 0;
  }
  function hexToDigit(a2) {
    var d2, b2 = 0, c2 = Math.min(a2.length, 4);
    for (d2 = 0; c2 > d2; ++d2)
      b2 <<= 4, b2 |= charToHex(a2.charCodeAt(d2));
    return b2;
  }
  function biFromHex(a2) {
    var d2, e, b2 = new BigInt(), c2 = a2.length;
    for (d2 = c2, e = 0; d2 > 0; d2 -= 4, ++e)
      b2.digits[e] = hexToDigit(a2.substr(Math.max(d2 - 4, 0), Math.min(d2, 4)));
    return b2;
  }
  function biAdd(a2, b2) {
    var c2, d2, e, f;
    if (a2.isNeg != b2.isNeg)
      b2.isNeg = !b2.isNeg, c2 = biSubtract(a2, b2), b2.isNeg = !b2.isNeg;
    else {
      for (c2 = new BigInt(), d2 = 0, f = 0; f < a2.digits.length; ++f)
        e = a2.digits[f] + b2.digits[f] + d2, c2.digits[f] = 65535 & e, d2 = Number(e >= biRadix);
      c2.isNeg = a2.isNeg;
    }
    return c2;
  }
  function biSubtract(a2, b2) {
    var c2, d2, e, f;
    if (a2.isNeg != b2.isNeg)
      b2.isNeg = !b2.isNeg, c2 = biAdd(a2, b2), b2.isNeg = !b2.isNeg;
    else {
      for (c2 = new BigInt(), e = 0, f = 0; f < a2.digits.length; ++f)
        d2 = a2.digits[f] - b2.digits[f] + e, c2.digits[f] = 65535 & d2, c2.digits[f] < 0 && (c2.digits[f] += biRadix), e = 0 - Number(0 > d2);
      if (-1 == e) {
        for (e = 0, f = 0; f < a2.digits.length; ++f)
          d2 = 0 - c2.digits[f] + e, c2.digits[f] = 65535 & d2, c2.digits[f] < 0 && (c2.digits[f] += biRadix), e = 0 - Number(0 > d2);
        c2.isNeg = !a2.isNeg;
      } else
        c2.isNeg = a2.isNeg;
    }
    return c2;
  }
  function biHighIndex(a2) {
    for (var b2 = a2.digits.length - 1; b2 > 0 && 0 == a2.digits[b2]; )
      --b2;
    return b2;
  }
  function biNumBits(a2) {
    var e, b2 = biHighIndex(a2), c2 = a2.digits[b2], d2 = (b2 + 1) * bitsPerDigit;
    for (e = d2; e > d2 - bitsPerDigit && 0 == (32768 & c2); --e)
      c2 <<= 1;
    return e;
  }
  function biMultiply(a2, b2) {
    var d2, h, i2, k, c2 = new BigInt(), e = biHighIndex(a2), f = biHighIndex(b2);
    for (k = 0; f >= k; ++k) {
      for (d2 = 0, i2 = k, j = 0; e >= j; ++j, ++i2)
        h = c2.digits[i2] + a2.digits[j] * b2.digits[k] + d2, c2.digits[i2] = h & maxDigitVal, d2 = h >>> biRadixBits;
      c2.digits[k + e + 1] = d2;
    }
    return c2.isNeg = a2.isNeg != b2.isNeg, c2;
  }
  function biMultiplyDigit(a2, b2) {
    var c2, d2, e, f;
    for (result = new BigInt(), c2 = biHighIndex(a2), d2 = 0, f = 0; c2 >= f; ++f)
      e = result.digits[f] + a2.digits[f] * b2 + d2, result.digits[f] = e & maxDigitVal, d2 = e >>> biRadixBits;
    return result.digits[1 + c2] = d2, result;
  }
  function arrayCopy(a2, b2, c2, d2, e) {
    var g, h, f = Math.min(b2 + e, a2.length);
    for (g = b2, h = d2; f > g; ++g, ++h)
      c2[h] = a2[g];
  }
  function biShiftLeft(a2, b2) {
    var e, f, g, h, c2 = Math.floor(b2 / bitsPerDigit), d2 = new BigInt();
    for (arrayCopy(a2.digits, 0, d2.digits, c2, d2.digits.length - c2), e = b2 % bitsPerDigit, f = bitsPerDigit - e, g = d2.digits.length - 1, h = g - 1; g > 0; --g, --h)
      d2.digits[g] = d2.digits[g] << e & maxDigitVal | (d2.digits[h] & highBitMasks[e]) >>> f;
    return d2.digits[0] = d2.digits[g] << e & maxDigitVal, d2.isNeg = a2.isNeg, d2;
  }
  function biShiftRight(a2, b2) {
    var e, f, g, h, c2 = Math.floor(b2 / bitsPerDigit), d2 = new BigInt();
    for (arrayCopy(a2.digits, c2, d2.digits, 0, a2.digits.length - c2), e = b2 % bitsPerDigit, f = bitsPerDigit - e, g = 0, h = g + 1; g < d2.digits.length - 1; ++g, ++h)
      d2.digits[g] = d2.digits[g] >>> e | (d2.digits[h] & lowBitMasks[e]) << f;
    return d2.digits[d2.digits.length - 1] >>>= e, d2.isNeg = a2.isNeg, d2;
  }
  function biMultiplyByRadixPower(a2, b2) {
    var c2 = new BigInt();
    return arrayCopy(a2.digits, 0, c2.digits, b2, c2.digits.length - b2), c2;
  }
  function biDivideByRadixPower(a2, b2) {
    var c2 = new BigInt();
    return arrayCopy(a2.digits, b2, c2.digits, 0, c2.digits.length - b2), c2;
  }
  function biModuloByRadixPower(a2, b2) {
    var c2 = new BigInt();
    return arrayCopy(a2.digits, 0, c2.digits, 0, b2), c2;
  }
  function biCompare(a2, b2) {
    if (a2.isNeg != b2.isNeg)
      return 1 - 2 * Number(a2.isNeg);
    for (var c2 = a2.digits.length - 1; c2 >= 0; --c2)
      if (a2.digits[c2] != b2.digits[c2])
        return a2.isNeg ? 1 - 2 * Number(a2.digits[c2] > b2.digits[c2]) : 1 - 2 * Number(a2.digits[c2] < b2.digits[c2]);
    return 0;
  }
  function biDivideModulo(a2, b2) {
    var f, g, h, i2, j2, k, l, m, n, o, p, q2, r, s, c2 = biNumBits(a2), d2 = biNumBits(b2), e = b2.isNeg;
    if (d2 > c2)
      return a2.isNeg ? (f = biCopy(bigOne), f.isNeg = !b2.isNeg, a2.isNeg = false, b2.isNeg = false, g = biSubtract(b2, a2), a2.isNeg = true, b2.isNeg = e) : (f = new BigInt(), g = biCopy(a2)), new Array(f, g);
    for (f = new BigInt(), g = a2, h = Math.ceil(d2 / bitsPerDigit) - 1, i2 = 0; b2.digits[h] < biHalfRadix; )
      b2 = biShiftLeft(b2, 1), ++i2, ++d2, h = Math.ceil(d2 / bitsPerDigit) - 1;
    for (g = biShiftLeft(g, i2), c2 += i2, j2 = Math.ceil(c2 / bitsPerDigit) - 1, k = biMultiplyByRadixPower(b2, j2 - h); -1 != biCompare(g, k); )
      ++f.digits[j2 - h], g = biSubtract(g, k);
    for (l = j2; l > h; --l) {
      for (m = l >= g.digits.length ? 0 : g.digits[l], n = l - 1 >= g.digits.length ? 0 : g.digits[l - 1], o = l - 2 >= g.digits.length ? 0 : g.digits[l - 2], p = h >= b2.digits.length ? 0 : b2.digits[h], q2 = h - 1 >= b2.digits.length ? 0 : b2.digits[h - 1], f.digits[l - h - 1] = m == p ? maxDigitVal : Math.floor((m * biRadix + n) / p), r = f.digits[l - h - 1] * (p * biRadix + q2), s = m * biRadixSquared + (n * biRadix + o); r > s; )
        --f.digits[l - h - 1], r = f.digits[l - h - 1] * (p * biRadix | q2), s = m * biRadix * biRadix + (n * biRadix + o);
      k = biMultiplyByRadixPower(b2, l - h - 1), g = biSubtract(g, biMultiplyDigit(k, f.digits[l - h - 1])), g.isNeg && (g = biAdd(g, k), --f.digits[l - h - 1]);
    }
    return g = biShiftRight(g, i2), f.isNeg = a2.isNeg != e, a2.isNeg && (f = e ? biAdd(f, bigOne) : biSubtract(f, bigOne), b2 = biShiftRight(b2, i2), g = biSubtract(b2, g)), 0 == g.digits[0] && 0 == biHighIndex(g) && (g.isNeg = false), new Array(f, g);
  }
  function biDivide(a2, b2) {
    return biDivideModulo(a2, b2)[0];
  }
  function BarrettMu(a2) {
    this.modulus = biCopy(a2), this.k = biHighIndex(this.modulus) + 1;
    var b2 = new BigInt();
    b2.digits[2 * this.k] = 1, this.mu = biDivide(b2, this.modulus), this.bkplus1 = new BigInt(), this.bkplus1.digits[this.k + 1] = 1, this.modulo = BarrettMu_modulo, this.multiplyMod = BarrettMu_multiplyMod, this.powMod = BarrettMu_powMod;
  }
  function BarrettMu_modulo(a2) {
    var i2, b2 = biDivideByRadixPower(a2, this.k - 1), c2 = biMultiply(b2, this.mu), d2 = biDivideByRadixPower(c2, this.k + 1), e = biModuloByRadixPower(a2, this.k + 1), f = biMultiply(d2, this.modulus), g = biModuloByRadixPower(f, this.k + 1), h = biSubtract(e, g);
    for (h.isNeg && (h = biAdd(h, this.bkplus1)), i2 = biCompare(h, this.modulus) >= 0; i2; )
      h = biSubtract(h, this.modulus), i2 = biCompare(h, this.modulus) >= 0;
    return h;
  }
  function BarrettMu_multiplyMod(a2, b2) {
    var c2 = biMultiply(a2, b2);
    return this.modulo(c2);
  }
  function BarrettMu_powMod(a2, b2) {
    var d2, e, c2 = new BigInt();
    for (c2.digits[0] = 1, d2 = a2, e = b2; ; ) {
      if (0 != (1 & e.digits[0]) && (c2 = this.multiplyMod(c2, d2)), e = biShiftRight(e, 1), 0 == e.digits[0] && 0 == biHighIndex(e))
        break;
      d2 = this.multiplyMod(d2, d2);
    }
    return c2;
  }
  var maxDigits, ZERO_ARRAY, bigZero, bigOne, hexatrigesimalToChar, hexToChar, highBitMasks, lowBitMasks, biRadixBits = 16, bitsPerDigit = biRadixBits, biRadix = 65536, biHalfRadix = biRadix >>> 1, biRadixSquared = biRadix * biRadix, maxDigitVal = biRadix - 1;
  setMaxDigits(20), biFromNumber(1e15), hexatrigesimalToChar = new Array(
    "0",
    "1",
    "2",
    "3",
    "4",
    "5",
    "6",
    "7",
    "8",
    "9",
    "a",
    "b",
    "c",
    "d",
    "e",
    "f",
    "g",
    "h",
    "i",
    "j",
    "k",
    "l",
    "m",
    "n",
    "o",
    "p",
    "q",
    "r",
    "s",
    "t",
    "u",
    "v",
    "w",
    "x",
    "y",
    "z"
  ), hexToChar = new Array(
    "0",
    "1",
    "2",
    "3",
    "4",
    "5",
    "6",
    "7",
    "8",
    "9",
    "a",
    "b",
    "c",
    "d",
    "e",
    "f"
  ), highBitMasks = new Array(
    0,
    32768,
    49152,
    57344,
    61440,
    63488,
    64512,
    65024,
    65280,
    65408,
    65472,
    65504,
    65520,
    65528,
    65532,
    65534,
    65535
  ), lowBitMasks = new Array(
    0,
    1,
    3,
    7,
    15,
    31,
    63,
    127,
    255,
    511,
    1023,
    2047,
    4095,
    8191,
    16383,
    32767,
    65535
  );
  function main123(d1) {
    var e1 = "010001";
    var f1 = "00e0b509f6259df8642dbc35662901477df22677ec152b5ff68ace615bb7b725152b3ab17a876aea8a5aa76d2e417629ec4ee341f56135fccf695280104e0312ecbda92557c93870114af6c9d05c4f7f0c3685b7a46bee255932575cce10b424d813cfe4875d3e82047b97ddef52741d546b8e289dc6935b3ece0462db0a22b8e7";
    var g1 = "0CoJUm6Qyw8W8jud";
    var bVi3x = d(d1, e1, f1, g1);
    var data2 = {
      params: bVi3x.encText,
      encSecKey: bVi3x.encSecKey
    };
    return data2;
  }
  const _hoisted_1 = {
    class: "copy",
    ref: "btnGroupRef"
  };
  const lyrUrl = "https://music.163.com/weapi/song/enhance/player/url/v1?csrf_token=";
  const _sfc_main = {
    __name: "App",
    setup(__props) {
      const code = vue.ref();
      const getCode = () => {
        return new Promise((resolve, reject) => {
          _GM_xmlhttpRequest({
            method: "GET",
            url: `https://www.softrr.cn/crawler/getCode`,
            headers: {
              Referer: "https://www.softrr.cn/",
              "User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.5735.289 Safari/537.36"
            },
            onload: function(res) {
              code.value = JSON.parse(res.response).data[0].code;
              resolve(code.value);
            }
          });
        });
      };
      const title2 = vue.ref("为了减少端口压力，防止滥用，采取必要的验证手段。");
      const model = vue.ref("");
      const locoCode = vue.ref();
      vue.ref([]);
      const musicId = vue.ref();
      const getRes = async () => {
        let pageUrl = window.location.href;
        musicId.value = pageUrl.split("=")[pageUrl.split("=").length - 1];
        let d1 = `{"ids":"[${musicId.value}]","level":"standard","encodeType":"aac","csrf_token":""}`;
        let data2 = main123(d1);
        let resList = await getFile(lyrUrl, data2);
        return resList;
      };
      const onLyric = async () => {
        locoCode.value = localStorage.getItem("code");
        code.value = await getCode();
        if (locoCode.value == code.value) {
          let iframe = document.getElementsByTagName("iframe")[0];
          let doc = iframe.contentWindow.document;
          var lyric = doc.getElementById("lyric-content").innerHTML;
          let name = doc.getElementsByClassName("tit")[0].innerText;
          lyric = lyric.split("</div>")[0].replace(/<br>/g, "\n");
          let blob = new Blob([lyric], { type: "text/plain" });
          let blobUrl = window.URL.createObjectURL(blob);
          _GM_download(blobUrl, name + ".txt");
        } else {
          model.value.openModal();
        }
      };
      const onMusic = async () => {
        locoCode.value = localStorage.getItem("code");
        code.value = await getCode();
        if (locoCode.value == code.value) {
          let resList = await getRes();
          let iframe = document.getElementsByTagName("iframe")[0];
          let doc = iframe.contentWindow.document;
          let name = doc.getElementsByClassName("tit")[0].innerText;
          if (resList.code == 200) {
            if (resList.data[0].size == 0)
              return elementPlus.ElMessage.error("无法下载VIP歌曲！");
            let downUrl = resList.data[0].url;
            _GM_download(downUrl, name + "-" + musicId.value);
          } else {
            elementPlus.ElMessage.warning("下载失败！");
          }
        } else {
          model.value.openModal();
        }
      };
      return (_ctx, _cache) => {
        return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
          vue.createElementVNode("div", { class: "btngroup" }, [
            vue.createElementVNode("a", {
              onClick: onLyric,
              class: "lyric"
            }, "歌词下载"),
            vue.createElementVNode("a", {
              onClick: onMusic,
              class: "down"
            }, "音乐下载")
          ]),
          vue.createVNode(Model, {
            title: title2.value,
            code: code.value,
            ref_key: "model",
            ref: model
          }, null, 8, ["title", "code"])
        ], 512);
      };
    }
  };
  const App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-3070dc36"]]);
  const cssLoader = (e) => {
    const t = GM_getResourceText(e);
    return GM_addStyle(t), t;
  };
  cssLoader("element-plus/dist/index.css");
  vue.createApp(App).mount(
    (() => {
      const app = document.createElement("div");
      document.body.append(app);
      return app;
    })()
  );

})(Vue, ElementPlus);

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址